From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752820AbdI0PZf (ORCPT ); Wed, 27 Sep 2017 11:25:35 -0400 Received: from mga07.intel.com ([134.134.136.100]:58751 "EHLO mga07.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751934AbdI0PZd (ORCPT ); Wed, 27 Sep 2017 11:25:33 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.42,445,1500966000"; d="cpp'?txt'?zip'48?scan'48,208,48";a="132881370" To: Peter Zijlstra , Ingo Molnar , Arnaldo Carvalho de Melo From: Alexey Budankov Organization: Intel Corp. Cc: Alexander Shishkin , Andi Kleen , Kan Liang , Dmitri Prokhorov , Valery Cherepennikov , linux-kernel Subject: [RFC][PATCH v1] perf stat: FD based pause/resume for counting mode Message-ID: <77297f66-29b5-de51-5fd0-54ff31444afe@linux.intel.com> Date: Wed, 27 Sep 2017 18:25:26 +0300 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Thunderbird/52.3.0 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------B9E611723D3D0896E6F5D838" Content-Language: en-US Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This is a multi-part message in MIME format. --------------B9E611723D3D0896E6F5D838 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit Hi, Here is FD based concept for perf stat pause/resume functionality. The patch implements asynchronous pause/resume commands for configured counters thru file descriptors passed over new cmd-fd, cmd-ack-fd options. The commands are sent over cmd-fd option. File descriptor passed thru cmd-ack-fd option is employed for confirmation on command completion. Handling of signals and the timer for processing intervals is also implemented thru file descriptors. Thus all sources of async events are switched to file descriptors and multiplexed at the single place using poll system call. initial_delay option is changed to signed int and negative values (-1) mean to start paused so that switching state would be controlled thru cmd-fd, cmd-ack-fd file descriptors. I tested that as for launch mode when perf tool starts a workload as for attach mode thru -p option. See attached logs and straces for more details. Attached pause_test.cpp demonstrates one of the usage models for this functionality. Signed-off-by: Alexey Budankov --- tools/perf/builtin-stat.c | 434 +++++++++++++++++++++++++++++++++------------- tools/perf/util/evlist.c | 8 +- 2 files changed, 321 insertions(+), 121 deletions(-) Sources of async events: enum perf_async_event Pause/resume protocol (perf_async_cmd_done is sent back on the completion): enum perf_async_cmd Global state specific to this change: struct perf_async Initialization: int perf_async_init(const int interval) Finalization: int perf_async_fini(void) poll() loop calling handlers below: int perf_async_handle_events(void *param) For signals: int perf_async_signal_handler(union perf_async_data *data, void *param) For timer intervals: int perf_async_timer_handler(union perf_async_data *data, void *param) For pause/resume commands: int perf_async_cmd_handler(union perf_async_data *data, void *param) diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c index 866da7a..a03e30e 100644 --- a/tools/perf/builtin-stat.c +++ b/tools/perf/builtin-stat.c @@ -80,6 +80,9 @@ #include #include #include +#include +#include +#include #include "sane_ctype.h" @@ -156,7 +159,7 @@ static bool group = false; static const char *pre_cmd = NULL; static const char *post_cmd = NULL; static bool sync_run = false; -static unsigned int initial_delay = 0; +static int initial_delay = 0; static unsigned int unit_width = 4; /* strlen("unit") */ static bool forever = false; static bool metric_only = false; @@ -185,13 +188,49 @@ struct perf_stat { static struct perf_stat perf_stat; #define STAT_RECORD perf_stat.record -static volatile int done = 0; - static struct perf_stat_config stat_config = { .aggr_mode = AGGR_GLOBAL, .scale = true, }; +enum perf_async_event +{ + perf_async_signal = 0, + perf_async_timer, + perf_async_cmd, + perf_async_cmd_ack, + perf_async_event_eof +}; + +enum perf_async_cmd +{ + perf_async_cmd_pause = 0, + perf_async_cmd_resume, + perf_async_cmd_done, + perf_async_cmd_eof +}; + +union perf_async_data { + struct signalfd_siginfo siginfo; + uint64_t timer_expired; + enum perf_async_cmd cmd; +}; + +struct perf_async_handler_data { + int argc; + const char **argv; + int *status; +}; + +typedef int (*perf_async_handler_t)(union perf_async_data*, void *); + +struct { + struct pollfd fds[perf_async_event_eof]; + perf_async_handler_t handlers[perf_async_event_eof]; + struct itimerspec timer_settings; + bool paused; +} perf_async; + static inline void diff_timespec(struct timespec *r, struct timespec *a, struct timespec *b) { @@ -410,31 +449,6 @@ static void process_interval(void) print_counters(&rs, 0, NULL); } -static void enable_counters(void) -{ - if (initial_delay) - usleep(initial_delay * USEC_PER_MSEC); - - /* - * We need to enable counters only if: - * - we don't have tracee (attaching to task or cpu) - * - we have initial delay configured - */ - if (!target__none(&target) || initial_delay) - perf_evlist__enable(evsel_list); -} - -static void disable_counters(void) -{ - /* - * If we don't have tracee (attaching to task or cpu), counters may - * still be running. To get accurate group ratios, we must stop groups - * from counting before reading their constituent counters. - */ - if (!target__none(&target)) - perf_evlist__disable(evsel_list); -} - static volatile int workload_exec_errno; /* @@ -582,26 +596,257 @@ static bool perf_evsel__should_store_id(struct perf_evsel *counter) return STAT_RECORD || counter->attr.read_format & PERF_FORMAT_ID; } +static int perf_async_signal_handler(union perf_async_data *data, void *param) +{ + uint32_t signo = data->siginfo.ssi_signo; + int32_t code = data->siginfo.ssi_code; + struct perf_async_handler_data *handler_data = param; + char msg[BUFSIZ]; + + if (verbose > 1) { + fprintf(stat_config.output, + "%s: signo %d, code %d\n", __FUNCTION__, signo, code); + } + + switch (signo) { + case SIGCHLD: + if (code == CLD_EXITED || code == CLD_KILLED || code == CLD_DUMPED) { + *handler_data->status = data->siginfo.ssi_status; + + if (workload_exec_errno) { + const char *emsg = + str_error_r(workload_exec_errno, msg, sizeof(msg)); + pr_err("Workload failed: %s\n", emsg); + return 1; + } + + if (WIFSIGNALED(*handler_data->status)) + psignal(WTERMSIG(*handler_data->status), + handler_data->argv[0]); + + if (verbose > 1) { + fprintf(stat_config.output, + "%s: workload exited: status %d\n", + __FUNCTION__, *handler_data->status); + } + + return 1; + } + case SIGINT: + if (forever) { + forever = !forever; + return 1; + } + if (!(handler_data->argc > 0)) + return 1; + case SIGABRT: + case SIGALRM: + default: + break; + } + + return 0; +} + +static int perf_async_timer_handler(union perf_async_data *data, void *param) +{ + param = param; + + if (verbose > 1) { + fprintf(stat_config.output, + "%s: timer_expired: %"PRIu64"\n", + __FUNCTION__, data->timer_expired); + } + + process_interval(); + + return 0; +} + +static int perf_async_cmd_handler(union perf_async_data *data, void *param) +{ + param = param; + + if (verbose > 1) { + fprintf(stat_config.output, "%s: cmd %d\n", + __FUNCTION__, data->cmd); + } + + if (data->cmd == perf_async_cmd_resume && perf_async.paused) { + + perf_evlist__enable(evsel_list); + + if (perf_async.fds[perf_async_timer].fd != -1 && + (perf_async.timer_settings.it_value.tv_sec || + perf_async.timer_settings.it_value.tv_nsec)) + timerfd_settime(perf_async.fds[perf_async_timer].fd, + 0, &perf_async.timer_settings, NULL); + + perf_async.paused = !perf_async.paused; + if (verbose > 1) { + fprintf(stat_config.output, + "%s: events resumed\n", __FUNCTION__); + } + } else if (data->cmd == perf_async_cmd_pause && !perf_async.paused) { + + struct itimerspec timer_settings = {0}; + + if (perf_async.fds[perf_async_timer].fd != -1 && + (perf_async.timer_settings.it_value.tv_sec || + perf_async.timer_settings.it_value.tv_nsec)) + timerfd_settime(perf_async.fds[perf_async_timer].fd, + 0, &timer_settings, NULL); + + perf_evlist__disable(evsel_list); + + perf_async.paused = !perf_async.paused; + if (verbose > 1) { + fprintf(stat_config.output, + "%s: events paused\n", __FUNCTION__); + } + } + + return 0; +} + +static int perf_async_init(const int interval) +{ + int i = 0; + sigset_t mask; + + sigemptyset(&mask); + + for (i = 0; i < perf_async_event_eof; i++) { + //perf_async.fds[i].fd = -1; + perf_async.fds[i].events = POLLIN; + perf_async.fds[i].revents = 0; + perf_async.handlers[i] = NULL; + } + + memset(&perf_async.timer_settings, 0, + sizeof(perf_async.timer_settings)); + + sigaddset(&mask, SIGCHLD); + sigaddset(&mask, SIGINT); + sigaddset(&mask, SIGALRM); + sigaddset(&mask, SIGABRT); + + if (sigprocmask(SIG_BLOCK, &mask, NULL)) + return 0; + + perf_async.fds[perf_async_signal].fd = signalfd(-1, &mask, SFD_CLOEXEC); + if (perf_async.fds[perf_async_signal].fd == -1) + return 0; + + perf_async.handlers[perf_async_signal] = perf_async_signal_handler; + + if (interval) { + perf_async.timer_settings.it_interval.tv_sec = + interval / USEC_PER_MSEC; + perf_async.timer_settings.it_interval.tv_nsec = + (interval % USEC_PER_MSEC) * NSEC_PER_MSEC; + perf_async.timer_settings.it_value = + perf_async.timer_settings.it_interval; + + perf_async.fds[perf_async_timer].fd = + timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC); + if (perf_async.fds[perf_async_timer].fd == -1) + return 0; + + perf_async.handlers[perf_async_timer] = + perf_async_timer_handler; + } + + perf_async.paused = true; + perf_async.handlers[perf_async_cmd] = perf_async_cmd_handler; + perf_async.fds[perf_async_cmd_ack].events = POLLOUT; + + return 1; +} + +static int perf_async_fini(void) +{ + int i = 0; + sigset_t mask; + + sigemptyset(&mask); + + sigaddset(&mask, SIGCHLD); + sigaddset(&mask, SIGINT); + sigaddset(&mask, SIGALRM); + sigaddset(&mask, SIGABRT); + + sigprocmask(SIG_UNBLOCK, &mask, NULL); + + if (perf_async.fds[perf_async_signal].fd != -1) + close(perf_async.fds[perf_async_signal].fd); + + if (perf_async.fds[perf_async_timer].fd != -1) + close(perf_async.fds[perf_async_timer].fd); + + if (perf_async.fds[perf_async_cmd].fd != -1) + close(perf_async.fds[perf_async_cmd].fd); + + if (perf_async.fds[perf_async_cmd].fd != -1) + close(perf_async.fds[perf_async_cmd].fd); + + if (perf_async.fds[perf_async_cmd_ack].fd != -1) + close(perf_async.fds[perf_async_cmd_ack].fd); + + for (i = 0; i < perf_async_event_eof; i++) { + perf_async.fds[i].fd = -1; + perf_async.fds[i].events = 0; + perf_async.fds[i].revents = 0; + perf_async.handlers[i] = NULL; + } + + return 0; +} + +static int perf_async_handle_events(void *param) +{ + union perf_async_data data; + int ret, i = 0; + bool stop = false; + + while (!stop) { + + ret = poll(perf_async.fds, perf_async_event_eof, -1); + if (!(ret > 0)) + break; + + for (i = 0; i < perf_async_event_eof; i++) { + if (perf_async.fds[i].revents & POLLIN) { + memset(&data, 0, sizeof(data)); + ret = read(perf_async.fds[i].fd, &data, sizeof(data)); + if (!(ret > 0)) + continue; + ret = perf_async.handlers[i](&data, param); + if (ret) + stop = true; + } else if (perf_async.fds[i].revents & POLLOUT) { + enum perf_async_cmd cmd = perf_async_cmd_done; + ret = write(perf_async.fds[i].fd, &cmd, sizeof(cmd)); + if (!(ret > 0)) + continue; + } + } + } + + return 0; +} + static int __run_perf_stat(int argc, const char **argv) { - int interval = stat_config.interval; char msg[BUFSIZ]; unsigned long long t0, t1; struct perf_evsel *counter; - struct timespec ts; size_t l; int status = 0; const bool forks = (argc > 0); bool is_pipe = STAT_RECORD ? perf_stat.file.is_pipe : false; struct perf_evsel_config_term *err_term; - - if (interval) { - ts.tv_sec = interval / USEC_PER_MSEC; - ts.tv_nsec = (interval % USEC_PER_MSEC) * NSEC_PER_MSEC; - } else { - ts.tv_sec = 1; - ts.tv_nsec = 0; - } + struct perf_async_handler_data handler_data = { argc, argv, &status}; if (forks) { if (perf_evlist__prepare_workload(evsel_list, &target, argv, is_pipe, @@ -697,36 +942,37 @@ static int __run_perf_stat(int argc, const char **argv) t0 = rdclock(); clock_gettime(CLOCK_MONOTONIC, &ref_time); - if (forks) { + if (forks) perf_evlist__start_workload(evsel_list); - enable_counters(); - if (interval) { - while (!waitpid(child_pid, &status, WNOHANG)) { - nanosleep(&ts, NULL); - process_interval(); - } - } - wait(&status); - - if (workload_exec_errno) { - const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg)); - pr_err("Workload failed: %s\n", emsg); - return -1; - } + if (initial_delay > 0) + usleep(initial_delay * USEC_PER_MSEC); - if (WIFSIGNALED(status)) - psignal(WTERMSIG(status), argv[0]); - } else { - enable_counters(); - while (!done) { - nanosleep(&ts, NULL); - if (interval) - process_interval(); + /* + * We need to enable counters only if: + * - we don't have tracee (attaching to task or cpu) + * - we have initial delay configured + */ + if (initial_delay >= 0) { + if (!target__none(&target) || initial_delay) { + union perf_async_data data; + data.cmd = perf_async_cmd_resume; + perf_async_cmd_handler(&data, NULL); } } - disable_counters(); + perf_async_handle_events(&handler_data); + + /* + * If we don't have tracee (attaching to task or cpu), counters may + * still be running. To get accurate group ratios, we must stop groups + * from counting before reading their constituent counters. + */ + if (!target__none(&target)) { + union perf_async_data data; + data.cmd = perf_async_cmd_pause; + perf_async_cmd_handler(&data, NULL); + } t1 = rdclock(); @@ -1696,49 +1942,6 @@ static void print_counters(struct timespec *ts, int argc, const char **argv) fflush(stat_config.output); } -static volatile int signr = -1; - -static void skip_signal(int signo) -{ - if ((child_pid == -1) || stat_config.interval) - done = 1; - - signr = signo; - /* - * render child_pid harmless - * won't send SIGTERM to a random - * process in case of race condition - * and fast PID recycling - */ - child_pid = -1; -} - -static void sig_atexit(void) -{ - sigset_t set, oset; - - /* - * avoid race condition with SIGCHLD handler - * in skip_signal() which is modifying child_pid - * goal is to avoid send SIGTERM to a random - * process - */ - sigemptyset(&set); - sigaddset(&set, SIGCHLD); - sigprocmask(SIG_BLOCK, &set, &oset); - - if (child_pid != -1) - kill(child_pid, SIGTERM); - - sigprocmask(SIG_SETMASK, &oset, NULL); - - if (signr == -1) - return; - - signal(signr, SIG_DFL); - kill(getpid(), signr); -} - static int stat__set_big_num(const struct option *opt __maybe_unused, const char *s __maybe_unused, int unset) { @@ -1811,8 +2014,10 @@ static const struct option stat_options[] = { "aggregate counts per physical processor core", AGGR_CORE), OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode, "aggregate counts per thread", AGGR_THREAD), - OPT_UINTEGER('D', "delay", &initial_delay, - "ms to wait before starting measurement after program start"), + OPT_INTEGER('D', "delay", &initial_delay, + "ms to wait (forever: -1) before starting measurement after program start"), + OPT_INTEGER(0, "cmd-fd", &(perf_async.fds[perf_async_cmd].fd), ""), + OPT_INTEGER(0, "cmd-ack-fd", &(perf_async.fds[perf_async_cmd_ack].fd), ""), OPT_CALLBACK_NOOPT(0, "metric-only", &metric_only, NULL, "Only print computed metrics. No raw values", enable_metric_only), OPT_BOOLEAN(0, "topdown", &topdown_run, @@ -2745,18 +2950,7 @@ int cmd_stat(int argc, const char **argv) if (perf_stat_init_aggr_mode()) goto out; - /* - * We dont want to block the signals - that would cause - * child tasks to inherit that and Ctrl-C would not work. - * What we want is for Ctrl-C to work in the exec()-ed - * task, but being ignored by perf stat itself: - */ - atexit(sig_atexit); - if (!forever) - signal(SIGINT, skip_signal); - signal(SIGCHLD, skip_signal); - signal(SIGALRM, skip_signal); - signal(SIGABRT, skip_signal); + perf_async_init(interval); status = 0; for (run_idx = 0; forever || run_idx < run_count; run_idx++) { @@ -2771,6 +2965,8 @@ int cmd_stat(int argc, const char **argv) } } + perf_async_fini(); + if (!forever && status != -1 && !interval) print_counters(NULL, argc, argv); diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c index 6a0d7ff..433e095 100644 --- a/tools/perf/util/evlist.c +++ b/tools/perf/util/evlist.c @@ -1712,12 +1712,16 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *tar if (!evlist->workload.pid) { int ret; + sigset_t mask; - if (pipe_output) - dup2(2, 1); + sigfillset(&mask); + sigprocmask(SIG_UNBLOCK, &mask, NULL); signal(SIGTERM, SIG_DFL); + if (pipe_output) + dup2(2, 1); + close(child_ready_pipe[0]); close(go_pipe[1]); fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC); --------------B9E611723D3D0896E6F5D838 Content-Type: application/x-zip-compressed; name="pause_resume_fd.zip" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="pause_resume_fd.zip" UEsDBBQAAAAAAAliOUsAAAAAAAAAAAAAAAAQAAAAcGF1c2VfcmVzdW1lX2ZkL1BLAwQUAAAA CAB2XDZLJ3GSgBUIAAABHAAAHgAAAHBhdXNlX3Jlc3VtZV9mZC9tYXRyaXgubG9nLnR4dO1Z yY7TQBC9I80/tMSBCxl6X2IhsQ0QiU0sJ4QiEztgkXGi2GETH89rJ6HL2OxwIyOY57hr6dfV VdU9z7frdXutrtu37a4uVWCb7bxp83a+LF5cZE27zRclmyyXbNK2bLJmLTu9ssl3TTlvy6Zl gsfP/hdr1+tVc2VTbpfdf5DOIfMWHza5xSaCTRZs8p5dyi6xyayTYZOSLT4sVmVzuaphbLdo q3XdsMmEnZ5eOc/bbfX+yqqqd+8PD6evFouTC+d5VU/Zk6fXHz89u3V8bMoa/pxceNZU9St2 89Gz2S12p6x3VV3O6rZcTezEnJ1cqCKeb1pWlMt8t2rZYl0vq1dT1jaLy+dt928O96t1cVVd 3jQvyUN7+eU2rxevTy5M/uBzciGyMy/fwuF53rbb6ckFxprqY8m+9xFCduPy880K7H/YfGP4 7NbZg6ez27Ozx3H4tsyL+XK9BX3jw58+fHr93vzp7P7Z/OzB9Rv3zm59Il89fvbgwezBnaip qJr85aosvu1gHFXVr0EXbH13VPl+sdoV5fzVDkE0OupPKW4+NHNC83pTIkQ2VcGkCoIzttjs YkSyV9v1boNg7x6Wq/xVw/h7z64y/6ce/Mki72Py28Pgo/gfDD/5+QvBEA7LmTcf6sV8cV7M X+d1sSq3U4YHJr79urPYgPlmd14Wx1yVL94wLPT1otiy9ZK93C0Fuwpbbpn7Ilci54KfXHi4 XDbjr4XnPWmZXnslwhfp8ddi0ZdW6bVVUH2UHn8teF9ap9daCfdFevy10Hj99HWMxIZdnDLP HrX7p5ML97sU322SKZNc+2MyP0eerjarD+xNua3L1fTLF33i2+q83Cbq94/l+021LYtpXKR9 qZkyjieluPfwx3LmjDegxUpL4HH0Tw0lxWuvXikTJF6FEMc5J5UxnMC+yM+M3++EU86FMsIE nxG3smzva5Z8yrBMGJzhMyKbzGUZdSRLFo8K+Kk0cUzNwPS+WP826dJYY6Q0wRkm4ImHL8JK igntUmmr4xQNiHBKOszNJjhGu8V+NlLI0Om0wmAiihM8JJ4rKaNx1WnG9tCeJ3gkXkbytOTG h4w4Roh3QYbAvaDED2WTuSHx3DkHIgjx+m8Rr7yQxgmnjWFSBiyCskYLiinx2nEd9kS4YC2o cIHAEeKDFjx4Z1TodHqBH20pHhIvgrYWtvaapcXyE3ggT51yKbSQXsmMOJaIt6abllCU+KFs MtcjvlMgHX68/BfEGy48fBZcWcxY62Cw+q6HKfHcCiUVKGNOBy19wEYlcEB8t0t4sJ5jRFQK lVgILij+Wgq6vA3S+9CpVjJwYwg8sKf3YavgVEY8I8zDthfaBsr8UDaZ+5p5qBQS6YaGvPpb zFvtvIcDQQSmgrLYm9h3luI0HrPgcCVAgnlIGBOC5wSOMW98nJc1tlPqJPZv7CYSHiYbg9lq TNvvVVvHeSDwwJ45RRHGVnKCZ8SzxLx3IN7hhzI/lE3mesx3CrRGQuzFvP9bzCOS4LLlEiGp DaxEPoKjmDDPBdI1OAMRVnjECfaoIHCMeWjRmJhSMirFKBQVaSkexLwGZyI4rJVFfwR5JSg8 sGdj3CL3Y8tmxDOS5vFoJRe9+jqUTeYGaT5E32GVMM//FvMxLpDOdEyqpmvVtPecU9xL895I FDJsEGfBmUMMKgJHmEc6jfUVe9l2SmErlkqKh3leY8FR+XWn2gWj4F2CB/ZcZM9qlFCZJc8o 81CC3eYNZX4om8wNmXc+xJT4L/J8iGUrKI8dxyy36E9iL+ApJsxj7lYLjQYubhZnEBAYm+AY 81p5DUXOdkrRe6CASE7xIOaDRbCh/sioGu450H2EiXnfsceRMnSWPOv1lNpLTE1S5oeyydyw tTEiKPFvWhshhDUKezU2ldZLIRQqlZEUE+oFooQ7pQL4Ngp1H8RqAseod4h4iyly3ynVUsCg oXhYYhVqvkUId6rjbvKGwAN9oSuTCuzajHjW6yq5QrvTC/qhbDLXo36vQJm4Hf5aiSWXbby/ ENKKGLxGx7AGZwg0jieKvzr/pvKrLcqZiu0pSFCo3SgfBI6dsDg6P9jUYm8BuQ+pL1A8SEVa ITdCq42qNRIZlpzAPbOCo4SinRIwnBHPvqzKl/n0VmUom8x9tSrJRbIq7qtV+f6NA//hjUN3 SVv0L0d/eItBVueHBg5XGr8WPb0TONKCQ0mSOAHGFIPzk0GbSHHvNIhyitZfIZuBe2yLuHET HD2E29g3I+/bqDR2DBY1gOJhznTO42TtOismRO84gftllgLLbLXxXbVKnpEQQVqCHt/rjYey ydwgRAS+RtPt/knONPFcwG0QoDDEtOc1So8nuE895ma970gRsdJHUhIco95agcYprkynFCna IUlTPKTeo7nAW9epBt9GSAIP9MmOPq9QbbLkGaWeY8/hda9cDWWTuQH1PJ7OnPs35So2gB4l U6BcYfUlFhk13VKcBHx0Q2mOjjhuByk5YorAMeYDdPvuRNzpBHsaNZ/iYXOMdGRwZuFRNTjB 6cATeGBPRfaQcWNCS46RYoUDCbZJv08YiiZrPeL3ChCTJtjv9sZn78vFLkp0RLOrUTvuMJDi cGteNL2VaapXdb5KSxOf10y4y7hhL0omvjv43Xr7ZrXOC1xQVy1Wsvt71q75uuxhUlLjuBV9 wEnRS0wuiB5OAhbHMRR50Kswz7h9XEKjq4m7Jhz2cJjqFArELmKT4IEUrq1MvMALUTFuS2zw CR1T/O3Zg9mTu/GPZ58BUEsDBBQAAAAIAFNcNksNX6Z9ggYAABQYAAAeAAAAcGF1c2VfcmVz dW1lX2ZkL21hdHJpeC50LjIzOTA4tVjrctJAFP7vU+z0h0MVYe/Z6KBTIbWMCB3AO04mhK1l 5DZJWlGrz+7ZBBqStDWtSqfLZjnfue23Z3dDyGPGH2NVY1LZkiC91v65ruzV6ivvLNRupMNo r4o+5gf2CDafuLftRMvlLKyvdHASN2YojLxY+tE5fOJOK25J3Ppxuzbtk7jb3uqLn7Rp/W/+ TIfV6SKMgjM/mi4XYfzjI9PWavW5FwXTdX02XZytNw+1z76/96mK8No6OZlMiEcsD2NUf4CY QOdeEKIH9X3UQPjeTvQ2kxiNgy+V7utOZx9lPkZ2TbAUGGcxXAg0n3urGFRFiti0io77vaHb dw5aF3Hvbb89dKro1cGxe9xvvzkYOhemf9Dtdd+/6r0eVNEjAr6CQ4nDY+mPLZK3JJiFPN/X YVjZq+vIr88mtXBZWwV6tvQmkIu+23sJOkAZcro9pztEle4ShWf+KTqZzjRaBmgyDbQfLYNv +1nVCqPlSi8yin3PPzX577n9Vq/beX/Rc5udnvPOaRojLKNAEolOzExXWBX9CCN3vpzoxsBt H/adFxdYcl5FMBpOv+sGIRJjiLdWq/0szoGUZDefG+E0o5k0VhHL503wfN4gPOTPlqGusPyk FqxbTGwTMZuOJTdtGE38hw9NRmTJbFgWRoH2JiYZeyNiWU7ncERHBP7YCGf/zMhT+CKbR4rh 34LnHZk9SBVQi1EwZb4yxhTmN6XeEmIn9cLGFsXX5V6xDJdhxKa2LNDZBF1kc8vpvo+JXpwU 4cMk5kxJC81XwTICOla2chbTIFdFFNsWEdt1BKvEKfpqYxb7egm2N2BuE1F6CR623zmtq9xf E0uBOmM3YyDnBM87wb3YCUKhlN7eiSsrQqq6YF7Rksy2MKaswOx5eVKDAmHdldTo7agcm8GK UuXZTKD8Epllc6qKEDvDZphRi6q/ZzMdTzDOmRK4yGbmiy2bGRYyx+acAsUTX9MlY+rY7faT G8iMrS2ZU/35ICjlpdlEhSqwCbZcNzSMIiUZRW1yHaPwH8skxw9Kk4pRUppUNgWWXEcpJtgu pShRirF/UCCxty2QqSklipTCY780pTixEl9T3o7/JaVEyqhUfc4FIUszitu4wCj/NvVJUHbX +nQ8EiNakktCsNJcooQIKa4tUELxTIGyBbetv2fT2Nc4PxOSFNk01vakNJukoFk2YXtDRS6s O+x0BTrFzI7tpgYKUdh5JzyabLdcUn57J67cblPVefMWtUvT2VLsv1wLRMErRen/sYQLlgRH XuCfuqvAj2aVg37zyB04Q/cQ8CmMQSkr8scW5JKABQ4RydTu9F0BV+lxsVDQOLblTWiCmbxE 7+6w5dCWVJfo3dPmJRrfCFcsA5eYlTOrLFY0O7ZKom0MC/5ssV0s6dVoe6UqQCjm6pa3X8Ao HmPMr3Z8xtjFJKN5DOECraYrXfnIIJBP+zcsI9hg7Y0slFV5syyF5XniL4CZIHtomHncPnbc wQewAtHGOcsCpLUByHIAhukGwEoC2NYCLwlITvQLXfFPp7OJCxuN/6WRrOyTmfc5bDQ7UJ/d 5lG704K90DnoD9uti51BY8QMDdovmkcduC4niqLpZBUFjZ1lqibxMqXMxnbGB0EUCswO9hnY 58+98EsFlLnPO73myyr69bE/fNXuov7QJfCCZVN0imySmGyKpciTqSgrtvcY/kdZC3ayr8E0 0hUK+/zcmy4eo8EQ0uC0Ros9YLdJLLRZEBwuvnrTiFficDflSlNG4fzGYU287faODrovkniK wSjONkZlfLjYnBO2s5iVBVvJAYHkDgjNoz68CjHXbxgNJvq8Mfe+aPiuECZN+b3moEBtvo2Z XMYc6kWESBIyi0NmWYwtdo5DdNfjrMucYijtBf3AO0QT9eYcBG0GAnGihbdYhjOtV5Uf0bkb ar9BIDboLkwf/yxmk6ga1D8i6R1nI8HDO4nd2cCF2UhlzWZ0depwPnUpRglWInWxLIeaWD51 CYRJfofU0RgruLhj6hI8nANLEDmRhXV5C9bFGIFpmdQlslB/y6cugXBl3yF1LMYqYWVT9/HH 2/ah864NlaMS7qP799Fb8wTFZPh6YEYaoOLnpytyGivYVQ5pLValw3a3PTjaliURhyMyKEbI xqVHpDiVODG4faMbV3fzRjep6AiKs3kXrMP9jE4Oxwa9nkbu52B5Bpv/fqaWPsvIKmDDw4cP Y3k9QV+n0SnCZuTeb1BLAwQUAAAACABQXDZLeWpO12RHAADrPQIAHgAAAHBhdXNlX3Jlc3Vt ZV9mZC9tYXRyaXgudC4yMzkwOdxd53IjRRD+z1Oo+AXU+Tw5QJExYIKhjEmFKaGwOlTIkkuS ybw736zCRkm9u6MqCoJPJ8/0hP66p7unZ4bz16V6nbnn0gorZW80W6ySV8yrvdI/b/bYS/my TvJtWXmqrGRS9ZLfk9GvySsvrxeL2eryMVlO0h8vP+v9UPPdy6v1YB3+vLgYPYwvJuPwWWdf DEa/bL9U6Ze/4p/0wwfpT57+HKU/fw8/30g/XoefnDGW/i0JP0d/jGbJ6tl0vlovn0br6WK+ 2rQSfj5/fvkwWC+nv1/OpvOn37d/ef5iNHr5x2c99rudTBIhMRVauN7laz2pe78Olqvea5ev VuZAOdUbLn955ebrzz57tTpfv4sJE4wV62ileg8Pg8e00rOe41486315+8Vd//bq3Q/+Tj99 e3t9d/Ws9/m7X/a/vL3+5t27q7/D53dvvrj5/vMvvv7qWe+Co6/oUNphwyfCCF9pyYveYDRK VqtXXr5M1qPL2fj5avH8cZnMFoMwz7f9Lz4FDRDrXd18cXVz13vlZtFbPY1+7k2ms6S3WPbG 02UyWi+Wf7xaIG207y0ek3mB8Ggw+jnM/xf92w++uPns+7+/6L//2RdX3129HxqRBQKW6d4k 4OEV+az312rdf1iMkze/6l9/eHv10d/MKPWsh29X0z+TNzk3jGG8z58//6fKA6t0fj63hbMZ LUzjs54szxsblefNOk2WAiflbiJm06FR4efT/LfpfHzxuzN9o8LEOOKkOKt7y2QwDnPy8j23 9uqzD+/FPce/rPKvvGdv4Q+++6ti90LmS7yM+QK+pEBD4Y9CU56bY/Nvtc7m3wDm7tD0e12Y fiG4l8ZVEB0GXAX0B1c336dYr/KFJ67MF+8hOY/LxRqIfGVfbmJRDg0zL5k224YhKFeVviom N6K3rywnBpWbCeGH199dfVDX+98T0AqNFqiXeuAqPXBpD7QxjjXvQq1GyEiXm+d0/a64PYTs BpBWgpu2kH68F4qKZyW0IuNZOc1FCc8ZIS+LeGaSqe545pNRUuaGlCLD877c2O3wbLkWR/GM FbuIJj52EfE82OE5o14eAlBS7sFgi2f8snkXavGcka40bwQZz5qZCp5nfz4MApo1Ec1as7Zo BpjZBRnO2nkynLk2UppDeDbCFfGsnOWiO57HgwoYjONVPI9HY7J+tmKrHTOhGaWVFfOmOZjK eBYqA3RGvtQFy0td2PbfNW+/FswZ2XLTjjMymJ2uKufH9c8BmwHPjIhn51tr5y8HZDB7SdfN XHMu2CEwe1tSztwyGQHMQ1dWLZrxGuU8HAiqctYA+6avmcSIiMqZux2YM/LlMcArKndBpV3g Urq42jmQrjSvyHa05s5WAL1cByxzGpa1EK4tloPx3KPCWQtDN52VYvqQatYwLApo5sKBqd3R 7F0FCVLn0JyV81TVrKXf9jUTmZimhtmBOaNeHoJSiowm6McKmh4CmAwRTFocVIzyBJh635KR pE0DxciNV/wglgwTZ4kqsIpiNJrnW5LcOisiGMjG+kpTNQ4fmuNk1Nqdw5dBnkVELWc2w21G v9QHR8etE1UtOJ4F4AoicJ3tZKHeL8ng9czRwYuF+yB0vbJFNQhjz0VQg8rqMi+8MxmgsnKO CihIWWlRN9ZGBJTI4JRRL/XAWiqcDOdVlyeZTRqsqoZr2xZPvedULBnuNRlL3sN2OYAlI2Rp SfUc33bHktDjMiMQWK9iSVhFxpLkW5WdAVFGxBLfrakF8qUuGLLLYRA9q+qm35pgSenW3sY9 un4vhCAjCq4CGVFhWpg7BCmYPgVISed8DAea8Z16ypqytgoppgdUn8NAXIuQEtvKHNZxCw+2 jCmlM0xl9Et9cJKMKRgOFUwNnsbTJoY/dCRvDStG11EwO8iI4tiOqdj9GSVVCskERd19wWPj ZFRmhnNVRLGEeTKivCgG+GB7+ZhKapwBKiNf6oIV5S4M0y5IOP8t+lBr72akS81bxskLrmWG VfA8Wv7xuF6kgCaGZSxnHRB9D4v83tBADfbT1aTQHMHDQ7EZC7stj2qEMJ2M4Bcw7yosEUZW UT0cMerSa6XY+jB70RlO0srBC5ExQo1yF2sstFDqhZOlXiRuG55pFe+sBXZGuty8MmRFbXWN ol7NBvMXDXwTOCcdtjcF1n+m7xUR2EbSgzScB8E9CGxsVZ/HtS5zJPQ63xI28LHDE2FhMHxc bspxXRUhywdkEXLGF8Hrud+bGm22MssiNBntJChroDwKL8qdkHazNCiuYosQaFfa92Tf3jFd jUkhMSb17vVzoWhC5DiXrYVIgLH3kiZBjhu6TyaYsfygh+8ELxg84I3wMXAtKjkvCKCwKq4V J3tlmIWttZEJj9zvQUWANU9226qFBkqd8OR9eqdqbI5lslrMfm2gm51uv0+fwopqRjttGoSN uDIHDQ5nBC/t1BsRIW4EXpR26oOu41VUMaGpZjQSe7bGUQZdHdOM3schM/LlMTiuyl3Y6Ep4 YS1cw1pNmVGutG7Je0HOy2oUdL6aNfAJHRRzazgjKPI2Fc6eqSZ2hlDyUOKJ55XQlWO2c5wh mYwnZShA97oMzrtyCRtSlSScwuK6i4qDmHDehxky8uUxwDEsd2G0hTNv0YVaOGeUy60rRXYK vRa21ilsEuTA0tM+ri9Fg7i+hzogIzqYp+4QoJGAWgychYh8BEAP955U1pSvAfRwZMiAdmYb 5thLzSimft6HYjPq5SF4VenBRj1zhIvihjlS2sX2HVYzaioVynpRTQ1cTxtoaMe4aQ3on+65 IcLZMcEb2BsKgl2Cc0bIuqJ+Bqa679YnEz8clXkhVc7cyMolRDg7plgJTMPhOCKc+Q7OGfXy EDSjrvco62qiZvTdeseM0W1367+81/eCCCXbII9JcKTlVULAGSlvzhNTMGVGOFvcrvda+e47 YslETypNeamrsLVDSYUtZ7sQYob5bb6V0raFN1/B7XAXUyg0UOrEjjVZmW1UDrmUUZOmUtLl 5rk1VMHBLoOqhhT+WP+8mIvnNlXGxExAh4Sw1rG5d+6lNsSwAhpqsDEnBETuoBBx/KoQVkDI 2XY/epAg+0iXuaK5rUJbeqqBgWDKzvvay4/feo9wY9tkSlfjCmyL7ayFyjCQMl7qxVjvEgIl XQXRwA3a5fYdOYcLGlFVkxf+bGBhCCZ8W0j/RM0GRCuebl84r8u5rRkh5HcV7Qu0FMH/g5KZ lNiAHPCqosYqTg2SOSF3SeWZyERNXdhvnmTky2NQguqBOWxcyWpA4elh0ARN2re2V3vUY1lO mAZ5/8qAkYfQZG0pmoD0je4h1yQZe1XmhFM55ysrR7ZWEQveOooZZGNaq34Hpox6aQiScU8F k4SBUAETDo/2Vw3QJLlrnVYV0vReowJKigYbvF4gk/MAoHBWqaye8F13OzIZ2go3FFNVQA09 2Y6UaheeytAYNfV+H57KyJfHoC11c9VJm50hfVott6hCnl5wqVeXa/y/OUoafjP8UxzDWfOz vC4sPb2AkFPNv7w7HT2aTLzTQ9ayOX9itGcapjf6+DDjjA/gdYfGd2ZOKhwgODTEyFxU3B8c 5bk4iDOe4vDwXi6ptw+ub8vrJfNlVyIjbfL5DUQGySIJ12HLIWQ3aKpSV6KBzWkscoYPDVvy 4hYa3BQTw+b0pqzUsfGR86D25eyIqtSV3Pku2coxjKjU94e3M+qVIZATZlDWnek8hir3Cl9U o2eDx4v5C/pJQFDhrf1/bJg1uHoATQm6jSvCQbVD6AWlAnpD7ERFsHGRUlqZZJ1Db1ZuSNwA BoGdPZ6JSEz07h2mjHplCORcFae0qAaWJksIxUwCVERIadna/76HPvyVDCitJRlQSCmo3GWR ETKmHOLXTHUHlDYVqdUudyAvK0cOKCntty54hsaYO1b7EH9GvTwEQ3eaFJLCz6MORblXluf8 lIaJ78ea0pNJuamwwTlYjn7uPy5H69kr796+/3H/q6u7/oeon6uGNa7KPgQU6rZ4xDYLtXg8 t6a6zlykylmkYOgcr23z4Ms4TKvtRdZ2Xp0Ra+ePzWSLLbW2z6Yt792RauNMdxapyAcbiLVN dngsH/ii1eac1VyOMCD2HC5n3fldRqxt67bHh8Rx+0LsOwsu06Cqfd1m5nhEA5v2JgNbPtuE WNvJam0haG0bXj0tmKUDCvh57Gh1zbKB57Nksx2to9VNNQqS5amnmXHueH2f1c+f3qCN3aps 7PnrOIi1nao7Z0kTFRO2LKsn63SWYXS8ts9q50+r09r2QtbcMTWm1i6L6fYaKGJtW1BuPtnw ylpEu49X9DWdNoKmUy0LW1NP87BmFi9F212mVlMF2fWrZN1fT8f9wXi8DFfM5Va8gU9XPCE9 88V6yqb1lovhEyyy2XS1LtQbpJJR015IFgkW3ItBep3fK19df3R79/n1TbD3Bv2fB/PxLFm+ mXF7MhyDFH71MFj98uYPP6afJ7PBi9WbX72Lefjq7ovbq9u/8RmUrm8+/CItgHEg6pAn5Ic4 +PnPs97WbKnpmbU1Pevzgx0bGWLHwud3b+9i9NHvZg8YGYWGQy/7X9+899kX73+KuxrTqeyF bv94hAxH1uCLZL2cTR+m61duP7v+/Pqujz4GEn+Fb/ujp+WbQT5f4ywgNnyHcf7+ZihrVB9j uL65vvv+nxraljW8SBF1nEjrhN+KoFpezdfZfFup4/fB+zAXlyuEjy6D6/C0ynk1FV/GCnE0 4qLy1xWWoy0ZEZU71nUzeEhev1+HqzHv518HpuBvIQvrfv4V2gm/u+1t3J4wm6CW/lkkmD/5 +Ixt/znwoUhLqNIAHTntAGp87x2u/lhdjpNfp7hkMnxeJw+Xc8xM0UO8+WKDNHxEVO7qfUD8 mOMYTmftJvtkUO/gZCOhIaB1nMzXq0Dn8jWMvYe/LadJuMwTfo5AtkDaOhfFqkaeGF/6g10+ JA/T+WRRQo4pEnO7Y6PmJHKCqj44Hr8992ECeECjx3qfJw93i/Vg9vqWUTycKcctWlvcBHIb 3NgiLURSM1ovbwvWMztcMke8PhZllS/Ped2UV+rRr3FDWSySK9wzOu6jpcFkMp1P13+8Ahik d/r9EBYtrCGpF4uZBVIwRvtjGjYo0vHmCJNHj0/dMKx5BAwjDFOeT6HrJ9SKUlVlW7FCa0dm hbailTLVznRXprDt4ypTnNiOpUyNym0FvLwtd2ASjaYrXljG+Vt3H3+ZbvbLEhgff1zAsFpP 5y+Kc99in8XCqCncG7wViovJ9DEQ/7DlrcEgbDcbOJPVFjJh02bSX//xmLwJA/X9/ldff3l1 2//83Y+uEWCb9Id7rZj+bbYY/bJ6k4XPaTRy+3Hw62A623wO7a+2H7MSk9V0/OZfvw5mbwb1 wH78J3w5B2RmyRynmnVaZplva2eR3fW/efez6w/+xoebL776evfpg6tv0g+p7IdPt1efvXt3 /flVDU6RzZsXklTZ/JIs58ksvRa7n/wKqQxWUh8zM/rlqOA4kctBwV0j93MUNym0UFYVy0py Am44/UXs42gxXye/r1d9fE/psMkJgtt1d9cJUSxLvtjGWfgVGUKXi8U6wDTtKzo4mb7ocLc1 iEuVonRH+nlGt7B56ttunuJIiN7LQX6y18vBCBKck4qvvv/qw6/+XwKBvZLawY+T4dOLmim4 u333/av/6iQcHqcLF0i+ACx/G++ANBg+jQfzXxaXj6nsrPu47D6z0oQpVpeyzmnbuWzfXt+8 //ERbw1Z9eUN+kvM1GCWbP+4CJHr6a+0+9pBzja5rx174bgh/lAuEZLSC0cp9uWpt7Yn1o/K 2xFI3Cbrj5CIWsDg/1risGrwvKmL0MvlRqOvFk/LUbK3fTtZvCGBtbPF63BIrOK1uXq7Vdui wOyyQ06N8mk+QvykP1gOLyeLJV5/OJ05cri7lpFmttJm06kuDdWpnU/Zoe/eZFNt0qm29TON iE6hpuSy3agvgx4rWwyuSBtqb7oI22mIbt+9/9HV3Vf5NRdHhXJr7t3d971XrueDR6jIx+UU hv6mbg/N9Ta9eLVIXe3COO6k51Fyxot0zCbwEsi8vDENXhfqQgQTZxOiTudNFitZta100ut2 +C8ruyV5qKxi/IxTpvgubcCdVKtIo2oJjLTYMWCEtJEorFNaVVjHLmyRcbxYxRgy45RtwDjn z8g4bD+RGYfYSVvGjV8kR/mmRRyR04pV+MZL8laqoQWZbbhCn8w2bdU52eYMnW3etmTbdP7r Ua4ZHkfacGKuqijlMa4ZSdeSuOWRzDVjzqklkTVJ5hru/2vJtaeTyycSQKLwDXcoVPjmLrgu ck4U6wg655A6Q+YcwsNn5ByikWTO4S7CnMlEDqqGwA01hg7/WDU1Y4Pf8nInduPsblNIhkaP bXwEKzXGxkewb7LNioDADFoVH8Rp6lt3KGt004lOf188J2DYpF0QyDnsyv62nK6TVwQG9vUK UY/e+1/Cwet9lMyfpvPkGqG22YW50FfpmGXajiwOwvPyA3Qn90Adjvns903VsLxvuvm2UkeX 92cJdQxvXsdme7qytm+yWsfpUjsn63g86tSU+aPHVP12EjRcF9TYQt63W5W1jKwRMWTNM+sy WWOZqNXEaz2+p8qa57zRdI+Gi9/7srN77nkzf2TTbAwPHWLJOnvonmvZzkPH436u9cBPO+ke R5NjWBnIhdON3ehweRXVzPCCkw1ED0V5PjMDObNkAxHHYRsZiBvukT1pL4yPwj3heENP2uNx PTLvkGVC5p3k+oy8g5iReSdlB8k75Ux7PB4bhXXSmGbONK5bo0uddHSpU+ycUqc4XeqUaBTV 3HCO6E97JePInNK8mT+NWzTIURBcQUYXOeXOKXLKk6MgME07iNxJlxpXdsRZ7PAGV1OX2iOL h8w8rcmRR6/NGSOPoTqdeV60canhd5E9PfghjVzqDUC6e9XeiEZe9abdk441TkToKMa+0S7n WKuyY10sazl9up1sMd1pEcIpbnZwOL6NGtg0283YR7Csu7GP6FlZEGS9ILhSxVYWx2bcl6Ow ob2eYlP7qA7EEKLoQGty+iztAtLYJ5NnqRbGR8byCRG8WNcxsi60zQLjh+bk+ROSS7um03nH 25jz1c6sQtpG997IRlvWh3oTkqIuHn950b0/SkfpzwoL1OrnRQR2GfrqhTh5q9XLOfrq5WUb dRolWuV1G6xQAlbexFnDfIOAlffUSQ/nrmjB4VEolPQhCF2jVWhT0NJ0sjYjhKrQrNRdVy8Q UbbN6oWKpuWgTwY6QNuaCKsW6DhXE+gwsmq5Z3U4o65WKMsF0XJHWXG+/BhQl5qo+1BWmRa6 D/U09UAJyhrfVAy7mu1olLg/W2m0qu8ymt5H0HceKoLnbHZbttmLZQVd3wnZWN91NNjRJnF1 ydqMYK2jWdM5eQ5EbAX85kBo3paa9y1HfTmSFzj8OUWboz+O6j3JYljroMNrrHXG96DLArxZ FeHJak+qxnJWMxMxbHT0xcTgShQTHZ2xNJP4eGciWejoThTExjLQsYXK6IuU4jRHsKbvhiht SsZIlfKhYI20iWPSpjQ1MRFlLS3Fr24mYkubcrSQRV1fokubZrS4f11nziBtmseZm1jSpiU1 /xdlidkNNX23RGnTJkaCG+hYUSNt8pi0aUfNb0NZYjCybiZiS5shpuvX9SW6tBkRZWJiSZtp b4PYc0ibIQefULa9RhdEacOB4yjShhtqaqSNHZM2yzlZ2qxozUURW9qsahzQ2PclurRZ3Voh izNIm7Vx5iaWtFlyrj3Ketcq3IHUWrIXjvv/m3rhEeK8aFc11iSng7wgq02UoIcz1CCvZ/TI Osp6WtBjiMZ/eVxM5+ss4JqF3HDzRqsMYM+QFtm0/e7RLS9oHlHW6OnoFvJsojAaORIZo/Vx RmMHgcxob23TiY6Y6o32vWva/la+ikjjLTuAh7Voe0jFDqxitS5o05/fRuKd91M4UzS7t9Bs jC0VDlehc4gxXNrUKvsXNYkB7MLAqdm/IZebxzAKOe6wbJr9i0pCU81CvJRuqfsq6Is7374K 53SznnOiWV/gHnlTjPM4Jj3Hjkaz7F9k49NNelzbTN4T4+KMZ8ZBXZHDjQAnbXEt8I6Y/Qvq NkqkEbdtyEbZv6jh6VInmSFzDjsMZ+QcNiPInJOKFuQucI6W/QviUdKnQMfYRtm/qGHJ+zEc hgqZcee8c8Bzeto2yhJ9/wLjqNm/nsdJ3AYdzRtm/3pOT932nJ667fk5U7c9p6du44ATs22c ao4gOdX4x8MctByCAkC6O1pct0hs4yd9LbwqHOM+UdCxIpdJII5lEnBEvunT7WkxjMKwOycT 4OEiWmip0GyMfAJuRPd8AlzcqlvlT3FDTKIojLtR9i/aMFHyqDiuhW+Z/Yu6npxPhbuk20je WbJ/0RliVl+hM2fK/kVvZBsD9VzZv+iPbuPsnC37Fx0y1LN+KGtbhYQ5rq8kq1Mn26xeMaLC 3BE3DwpNUwLDcEGjxAs57nugBoa583STwROPqz8ufkuW3QNVnnhMPW0uSoDKdz+eHg5vi3Zr ljc0/ZyOlx7Z8C5OXMp70TCygR0Asn+MyxjJ/jGeMD+jfyyYJPvHAmkybXSdYIZ6cAxlLe0G xxQX3S10wYhpSGl7Jy1zvBYX4xIO0OEq02q+otWKZQU5mVpwSduFSIfb2SIXXNPC72lzMSxx AQOzs1YTWJ3LQOcH4u6GuWJV4qmz3IhRYp4sX/xxsRw8HFNuQkS5kA10hGqY94Q0cnKWoaDm dB+YgjqT2xcbMFtN69GZTxZPuGx3czsSD2Vtsez+RnF/UjiEo53VPdDxjXl+tOeS7bwo34mD eDs+mwHxXAoHynibVoeHoIxILwPSyQXf2ENQEKk3VeqLNOSZkaqJlqzMTCxXAShsrk9y/Yjm Ighp6cum9DTvr67Tj6hxVCcoFsUvx7NErkYn6GM6QUmyOy4UMcfu0BycVgrKMLJSQB40GfrK tYdc6DlBKyjvomgFzVlnrYDnZshTo2UTG74yNdEiCLg7vZuExdML2pAD39gnbK9UXzw+HVUL 2scxFQyrO/6jjqkFw8nbTcJIWujnwBSc1gpGc7JWMIYOfWObuOuVjhOUAl6hjKIUEAjtrBTw ZB55ZqxsL4uYmWg6war2hjj6EU8lWCPJKsEST33VdToE4I7bCtZHCY4Ix1TDM4G4Jo7uP1Bv pzg0CQRjAde5k9WC03TwO2Jy86GuU6wF5+L4ELgMobNiQMIAeW686IjtaKrBE1OdD/Ukor3g yTdPoyzxoZG6blenzRVpuzhuBLJcGx5glIyeESZZBwxhCk4qBtw3SbYXcMKabC9AstrbC+j4 abUgmeMx1IJkXnZVCxLZp+SZ4aITqmMpBbxn05FDkVQCrjGlvtmBska1icgj5Y6cOC85MZkj nZgou45SEJ8iSZuk7DZKxAFjxOUl4i3U3UYpNPVybJQ1tLg8xtp5r1EKYm44Goux0yixKnSO yUsoikpMXtVjXbFSVeIdjBgvOQNeShUlnxNPVLu6DHjJSxnwxUqWHHrDZcTUZ21Q1p9xrxHp teSgqVTElJkczybL8DDpfHyUbUrGeIoIdHTlKSKOHWIhj7FNGerV1yhrqa+joKw7K9s8nW2a mIKXY9vj6CjDtIhimUotfTXh3Re5Vaqh6YYp/e0olLVnTL2FOiEnL0lDfBQS3CKnYEgjotzO gK0e2TAFA0YqXS0aQ06WRsr9GQ8GSePJme7Q+zQrFRyjHimRVsRZyWzD19lQQ5Nv05DWkA9y 4Z76810oD+qefBuKdMR7yXP8ms7769+PMsyJKMe3pFPV8whSHGOYo182BHeR+gIAyjpxRoY5 +mkE7NXS3NEcwwbzP46yy0d5/RB0lKhaivwYu7ymXh2PspaT2eXd+V4/BHVPjokpRvQUc+ya jWeDygpWJBqHYYqpOhuxcuBHFitpso2IvX+yjaiYPaONqJgj24iKs8Y8O3C4LiPJo5zQUlw2 e1oDNRR5CVNck7M+FTdnNDkUJ7/OgLKelgABdpGP1MG7i2IkKiSmNT1SpxrksiHFhXwEWUl+ vgc1QJ1+B5uSxHyIstXRHz0e5Zq0UQwPBSVfNTyOipli5JUMj0STVzKl5BlXMswH2RdTyjTW iovJJD11sVwdZ5uKkxSvlNd165mRx9YzTX6qDWUF2YtWWp7vRVhQ1/T1zGjdJgivjCWfRlHG 065PATq6J8UrS9yBR2snU+IRx4pxzT/o2FxKvKqE3otlHfnCLeUY7aAPBts5IR6SSNvARGMx 0uGVE91D7wqv71YO+fAD19Dgxp1iXeqlyvsBX64Xj+PFb/ML7I4tfk2Wf1wMn4bD2fHcFkRA Y7yKBzrOVDewx/vjqfzZKP3En8Hre/Nl0Mj2taUsUvJ0xecbw+LQLMU5sap8Aw1wtEOUlBYF fRtj7xrrk8ntXW+2p7Mp58WyllP3qJGfS1+bj85GvCQWBOXpkcCjfYqYzqIZJ/sVmvzUSXUA q9livbqYrlZPydHdHlzrHCW0qZmqSYNNMq2Qz27xxZqanA2rGfHWpxMzEkUDwGyj5U+e6Eyc M+vIbG+tj/K9iSV9mhPf8zrRn3iSxwU5aPYvbdfWG0sNg/9KH0GikDi+JEg8cAeJi8TlCaFq 2W6hoi1H7QJFgv9Oprfd2ZnOfpn1gjgqPbl4nDixPzu2xIT7w3eIv1itl78hF7JEcYlAl6gj waZlOSp7tNPVYENfIvj26zWeuF6/Qmg++mlqnDJGCM0/qh/I8b78hMCXJ3sJcpM/Ylz+SJr3 2vXq+vTqj8X5tMyReZSprePkEZlbbmvBDyD6B2lb9nZIKbjspZBPfrn9/a1vfvzqq7eHvLun i/RLCDt94mOf7m81hWrs7/bRNOiTbGceoA/P6CP2QpuM0ibDPhZ25gH65GaxfN5HTudUaldC nynwOpu4wWG3Q4LfeYTWDR8hwvEM4gT7OYXBF71bFK+uavT79fVg2+T+wOoCNgpbGjmD8ssZ RK/f+5zhTBzCaJGOET74yJA0uDB3KXCSIQGTz4yR4CZDAmbfHCPCT4ZE4NdaItpsBHQUL94s lpfryZgBER9Pi0guQykSRqRIAxz+JtqOX2044VN0Q+CqMmM0OBXbELiWzBgRbkU2RNs1zA0Z fsU1RA0ObRNtiErf0enXf6wXV4+G9aRUafGRKgsjUpU2Nml4QId7lqn2ByBctix58MVHxqxd axjSAiDCYury+lnMEooIi2U4IYqgxeUnGeGnf+aGsOtXyXHURDPBjm/JqXlPPdz7NxdXl8tp XTQ7YVBZeewWRTCobLgumsFcZKOccNJGS0Nw1oAGL320xHn66AMRfhppaXg3NCDDUSctjOuk RZpvi84Svauz7gF0i/pcnsXKiIc1vAhT7umksd+3wPemhnYM9ZkTTjCuBrTy7JAEL+xWA5iP Y0CD55N7DWAi9AEVrs/tNeDP7TVos/Sv7yvFi9vJS0lDdrmUNJQxkLYAl5LGAIOzGtFatAM2 +NxIGsEcQUMCnK4jjWhJ2wEFbneRxnaL7okGv4tII27OaWw355aL5W+r0+vqGp2+ijT62HFK Y3Ycbfz63M9pQ9TvjRtxSu1G3IYbXtcRtVtvGyLcLiRqCHQdUOF4JRGYa2mUDs9LifC3E5pm xEHcQ5CjpugSQaeJZCbkqCnBUd6aeM6B6Ao5KpqOtEeDM+SoyZqVzPW9O+SoqTSL0/reH3JU DriKx2Dumb6Bt/jljz0qHicXP7wyy6QPjF8XJcZfaiq3a7qPbPBS8dAcqwMC3FQ8bsfzHilw VPGk3ZP9SIOniicEPzNSNP9rT+Qh5E6FXZ5gqmiYidypGFx5TaVd2V3f+yJ3Ku2e7PW9M3Kn 2u7MXt+7I3eqYEHAHhn+yJ1qgnFwtXbV7pfbxU0NZru8uVvf/rlcX/5xM203mbq8ulQbjc2Y ygqslnHVLoO1uyY54WQzZWre0ENavEynGa6SITF+FlQGC3dNkuNoSGW8bpfm3Cxtt6uL0+U/ yz2Bz5qLjx1VRlNvb3DykKbAiYJn4dbSDk488cIr4FlLuzX3RIJblLOWdmvuiQbH0GYt7ebc ExWe8cxa8KREFkLz/lnfA7GEFqKLFmghhTGoHIAkLDCcjsMCWPm7xwfPWEKb84Lo3jWW0MKM hxT3zrGEFtt9f+t771hCixGGIiy2+5rrj8B9ZJFdwAiLomNBTxNKn0WFn8BabH9jWX/0vIQs tkez1x9dLyGjdhCg/uh8CRmBebb7VHhfQkZ4cUKjhpwnTySjdpORujwjNTIbuYfClAgRXvPY Uvup524wWWqPefC3lCy1O42PYSJZancdH8U2sqTwy2xL7VrEo10H+G4t+VQasFTyiCzJlCwx XmnAuB1BeuSBp8fWeLbB7+myNQbLeA7IcPbZGmvz4fJIiLfT1jjDWfqNGzKovWij+91MJj61 /0xiGTOPADeTScJFStpjwNb3jm4mkxm5aO493Uwm1nyqrO993Uwm7VHG63tnN5NpwOEFbc+1 sLraH4hn6pPm05RpzEsL+JhMBY4ON53lpfULxDPNzbrM6sozEM+sIV/5CwW+gXhms566+Qbi mRFuGBk3M+3RjjudFh8TH6PI1EYfUz1kpOw9ooo7BGTcNLL2K/iJCU7C05IIvE+Al/DM8GQ9 UeAnPBkssjSkwVF4suCmUJ4brFgx+dXt6ma5xxrK5qPC5ZynI1kvJpxFVvCnvlbab+M+R7xs oxmvc/qEuJlHpf3Rb58SRwupSPs506PF00gqeLy4lfYYsH5GrdvVulJxPiluxSdwPIc45lAi wKGUA8FhRTm0H5cjPHHKCJdDO8I6Qo1XSriMllTcS46T6OXQHlIwQpBjUrgc8EolOTZUlnmi vrYBHFA5+hQEyjHR9Kv7qdcauSFRf47tjtzaxtMXleMMDPbPO1dfVI7tKSBrG2dfVKZ2o6+2 8fZFZYoCyxJRM+Oe1NzpsNhM7JJcKZPIlM31znM1gH4Oi9IfQ+GIvkztmcqeGOIUHZtphm/3 kQKv2Nic2pM0PJHgFxmb0wzP7iMRjnGxOeGO3ZwkzEmvn5MSmgM+V4Jas+/lzPKS5S+PZvnL wz5KO/MAfWxGn5xeaLNR2mzYp9jOPHv7lCDS3kf1hbbCY7QVHvTJYWceoE9p7xND3Kwpj67p sE/c3Tv7+3AK7X04vND2yyhtvwz77F2fkT46o49t1nQxStti2CfnnXn298l7s2SO9MmbNT0f pe182Kfozjz7+5Rg7X2ivdC2HKVtOexDZWeePX3q/6Wg7X3iZk0vRmm7GPbZu69H+nBs7yOb NV2N0rYa9tFdOd3fh2OEa4NsypBvqtBYvAgzbshuZsILvtT/7rymZYKmvbxZr67O3qwPLEbe zQgCVs8zHl6RvJvU6MCyKN0gWdCK5KlQr6uAWZZ2Pvq9N+u/d+2D/rjRAd/qxkkjpVx3KoPu 9EDjpLu2ApYt7Nrq0co8daMbqId2bQumvu+s2VMAyuSyaXBwpXXjxDxctjS1bErgM5GuLYO1 8Lq2crS6at3oCiY67trarPPlvTd3v5xVo+vyj/PppSsO2XzqOBZ4sHTEp2T91Uv9ThE0wbu2 KcCrZ3y0crzd6GiK3a6tYubq7urd/FHB1BrP/2Zy8cwcyoZ245Q4lLs4JXc54MdljmCl8q4t Ha22fDc6+py1awu+6BpecZNLltXhNUM3jslgyUJvxUq/Pfp+tWtbwMrXtW2JRytV3o1OoAOu a5swB9zugq3vlpMrVthHJylShkIWpoSsGOjW7tpmsPRk17Yc8XKLIcCXW0QTDA6E7O/bs9Vf k5IWQ3LAmrtxOA3WjV+XtBjQmLiurRq6ajHY0Soqd6MXMKikto2gR2N31SoQe7b+7XZ1N6lN xhhdtMkYyYYCV06JJlSSGBOsUFY6wUK9XVs9okoSo8EqSYx5nkpy8eebsz9uzvaYcDEWF50k UhzqJDIhdkSwRhIpwRpJJD6iARdJYI0kEhhAu7tw1+slYAlEyi6aSaQiQ7Hj02hTYpfQ+thd 25jh1UvpiOpJTAw+oujagskmRg7NyWVL6hCB141jI7b3hLwl9GFfbctoFfqubUxHXDFG00N1 bcHopaG8Ta8Ys88JyUqDFSsTK8YGRpB0bTMMcUUuxzwhBc2H17Wl2O5q7fqlhLlau7bMbQjz geXMuynB3Lm9KXe2oPZHtHR4TfNunJw3Nc1toqZ5basB9Gd3bWNqY/LD3/adCBpmOhGipkYn gqvrJCqX5umd/CdRtXF3L2tERXfiHbbD1Rp3+GbaiV2uRV12uYWtXR6nd7kRvsstzWT2kzp3 dxjT0WI4r04/yXxT8mG+8Yb5xGWL/bUt99tmxZlfWqWsfv0Dqr7858DdnmMjUrU19fSOz2Qu TM+pwDs+S4SZnrXxXH/+cp8dn8HcVIPpoR2fS3Rhfglpw/x0sc392jb120aBmV9Al/wQ0T6M 6wV8wLcXSdf+sCI+7H7G4HQXSe96DdXoYgVnecHiL8Z9rgexnQKYhRLy92p/6Jg9WE8hhQHr Y+rxPu70YPh6pVA3yN+3l+vVW1SHf/7MamRcLP68Wp88zXdS8f93Ok2ikvjOiZaHry39gSxD q3j3x8X678Xt6omTfZWMwjyVjEKRttkPNjgogkmcnqfca3BQJHbZMTEpejFRZFhQKSomqM9f 7GpwUGzdYK4GB8WC2TvP0zsaHERBobkfxfeX9Z2vcBG1KCR1egfpIjApzsuc+8WLxEXZJtIt ZVunxYsMVraJMrbBXz7ZV75SwI7Ql+mdBSxRaJ/fS8ISaGX+ebOsQSdny1/+uD+jg+MiKQl2 h/Sm9QiOpKR8cHAkJdNdKNHGocRYqN+zzP/w95bdrptCj4mDQ3rmbpxoowFbecJNQ4yH2xEz 7B0lliN6R4kVBv2JDQP9R1fvoeX06mUX7J8kDLH/cLrjYov9LhGG/0kIhv9Jkh1x7YRh+J/Q /Fjja3f+62py6cR8BE+yDh1tO1K306OAaWhrWw1w7BYpxSOunCY4dosUTK02unKXN39NLpx6 VI3oxrGhzFGaWjjNuMhpUXjhLBxT5CzCQeVk6QCR+3PvZWfsI3MmQ5nLp1H6i0f9Pmjy565t hoOTycoxpS4HOBKIcuQ57lLKBIOOlBMGOvY2iIORlcFkH7159xtaWV1AR8pmWzhGmsJ4KZcA s7sEDMfoffaTsXWAso8WPB+b9jBlv6R4uLJfeCAIaVwQ8k5HMNHG2He/V9d0+fv6cvn73eQZ WMwljpVKHqm3fHGxST8SBnXLN30LWI2PQwpgmoBpnnikIemIofkbc0OMS0KSjhqec1vuUuOU mqSjByy2P02PV5KSjiCFtf0U8oy8Cl2/AvsrUyQMt+ox6Bk8OugCS5ExJ/Ho1FN3WIri4iRO 0ba8N2ESLEwxwypDiqVJZbi8Xh6MViUC6/5t5vSAqhKRHnx7JUp51u2V0JITm4+GgY7kUnKi G8dyI9CR4JITtW3CI1NTOmZkakoE5mfq2iaddfQlNlgKk2DxMZvNcbjWnpI1HXp10r0qe0rZ 57hLZTsmJkyp7Ikj7KZOTE34fP3mg/X1hNZl2MzpoawnlsPTFiTWgbKexzc/GfV7glGGg69+ 73yxXpx1iz+pqicuLk8okgQdKZ0YXw2LSBJhrCIJWFpmggujynnpz8JPBm6pFH19+VFtnGJH 0oi0iDwDTmWvtIg1qdCj1A+1+SH5+fn6KoetZNlig74bu6USJVmdSp0/kj0sJvf6aCSYHWih 4Al2+JkTOvdU2RDjaEso/rQqobUJXqH8Icpo+mjQ7IJkJi1jRwO9fjRYwI8GA1OsT7EBOBss KXw2GGdYGAx8JzFFPnI4mLHL4WBZmw8HK/hZmduQmDF+eOVB7agBMzdOUOOWD7UjB03h2LWV We+KUkZTOHZtrVnfdsEZcmm+QRCQoQQfrbsQDjKUBEckpSJYzNs2vBIOxxkKmBa5N60L1FBy OVj35hBoXlQMhxkeggBHxdTvc/Hx1n9Tc1QMN2R84KCwm5ePmvGBGzI+cATzvfVWDwaLOEaX N8wcqRUs4sgwWMRRYLCIox4RLOJoMFjEESx71Vs7NCqGKfgIHkVqi4phIji4ginhUkd8xOAK JoE9HExttu7jyoFRMUw+BglT0baoGE64RcIpwuFMnNIRAys4MRzOxGmGXy3AUTGc1KHwXzdO Dq1RMZwKWP6ltuUAp1lhjkdM/MaM1pvr2vIsvyIz/g6SGXwH2dsgh+PrzOADyN68eyF2Zp+X jyzbLx9jnILYK7dhZZ8FfPnY++yDUXYWnqM1OQDtLCKHK/uiNsuvyAIWEup9d1tUDEtx8S+y BpsbFcMa4Wh41r0VGgbZu1n5OYN5CkGGWcK73w76aNyZB+hj1N5nq0LDhYxmVx/2KbIzz/4+ BpZ16u2lI0UTcSM++kjMsaKJ2NKcw/xo0URsbeEEj/QcMZqIDU+zzGZ51q1vGX5kyrnN0/vI IBeUj3NqgsYfp0aAPs7ikkqIswoK9HHOcEQsZ/Bx67JrVL+8fv7BMB+XgInm1qQeIB8XOjwa lkuaFw3LBUwos/XVOEZU1CVRORfjEYxI05TRU/DkyVwKnJ1QQijHM3okEJydUEJKc44/qXxH JVGCYK9wX7aHRy4DCSCI8jIrkM5AQnZJZyChbKcz0CmDR2LIMKsj+OB466MPNnckJgz12JrU w9iRKOHgQ0+iDgRAXvFsMPd7gi9GB59df5VqzdS7yzrp8p+pw09icUFZhQKNBRb1M67EfpcI OzeEqP0CGGGFi7IuBAZQ7yHGR1kXAssE7aHGS1kXAh2Re+hxU9aFMqysC5X5zFRQ5FJ00Tck kYwF7EyJXEqwuiFomoVRVniLXAKrnYwS4y5yCQz3HKXmCCKXyvwDSY8hchzgCDnhOJ+ZBooc J5fwWWEeE7k0JXIsuMjxDI3yhRXeIsdgNv9RYtxFToIPa7xETuJclbTScwyRE4LdvyLzHFEi uCNKRDHPyBaDXAApkdyufwBwlIhPzl/R7Zy/4TRNpJ0VJZzhmjDP3/p2sVy9+aNmhHJNeCaq GBz2Mr9DAnNR0O34Mun+FOaiPj5HsW2fI03ijmK4z1EM9Dm+fLNvEnMxME/9y/zOaczFwAdk LwR4JjIXMwxsur67PRjuFQNLa9bJPGBeyeFw967kOM+9KxnM+VK/FoZ3JftkepEs1grvSlbY jys5w1nNJJcjZjWTEuCsZlKizFIlCsEPRqUk7K183RYOV0oRzJiqs+2/S4r6KA3Ftp6I5um7 pOBpCDQETGmoH3swjKtoTb46mQd8qyEdDt9q4DQvMF2DYPDt5nPfu7u+nDrLNJgLWqshpxE7 lifsWA0FRms1BgxF63+5i9mqkXDx3cztY6VqBAMn+pN7GaUawTiJ/vRuNqhGPCxCI1h9ekPr vnqqGn0qTisFHpGOMCUdFOE0RkqEAV79L/eRDmIMtujP7SQdqKeiP7mbdKCOif70ftLR4IdQ Ks0HyZvKp4tJ+UjRJd+XJkqNKKimhN8eCQz22P12HwlJ2rxLHmZ3kpEE+nx3p3eTEjTJ9C4B fnLCuPmhDD7+26J2sVdOOPncI8zS6BPXBm+Bot6C7W/3kxPUPbA9u6OccGm+RBeuciJgqa1t AnzlRAh2sqmAUZpb1F7vlRMRHzkRbXVkqxguJ5LnfbuPnGho1riuHeVEY/Nleu0qJwomBdom wFdOlHG9S2VWsLaqwsHaqhkHkF2Bc1WwMmGd2RExV4tbEErCmWovievSXqY+5OHuzppfK8r5 8Kr/re+//PzsAS965+SnLyu5H370Xf3jq+++Pvn4i68++fmdk+61yDsnYxNbPKkj3SyuLs75 rdP42gD18Pn+s0+2AajUH6eu9Pryuu7m87NlPa5qwbCPO4LOvv62wrLffvPlxxW97Q+g/QHq gr25fLN666c6Vfn57SkO5Jie2sYKZsVYW7/e9tFZfLN6a/nb5dX5Wd0Uy98/eOTHxdXi17sP KknffHr28RdfftWR9+mH3/3w5Sf/bv/y+09/6H5Vmdwx452Tx4HWl+dv1rcfdLtG4wXJxcWi POwaSiX2aSiSnlZssVxf/nHTrdeP338Xu6tkcfbb4ub8atWNxBxM6hfVXz68nPrp54efH8n8 /sOz7z79vgKBn373b/25DvHlN599+9Cg+tjrVly9EBN/Kb/IefhvYt1LZjQFThWl51Ml1g+c bGthpwZ9fH1p7KFY/vKmQvuxsuKzyue6Q+oPm10y7FJghdkSha3Sdad7/nkqXRcfdmbsD5Rs a6DuxD57PEsW6/Xt+w93d7Tar/7Z7ye81e/kpNMOTl7955GAVB5kq/QH0twfaHH95mp11kHy rw7EWgeqf/YHyn2KupX6v7nz3JHchgHw/zzFIEGCNATspFKQ3oA0pJdJFum9IL2+e2R55mzO eLyavU25w97taklapK1vaEqyL8bppZOGnAdDzsmQACVDH33+w/sffPXxR6uueXPNsyHUZOjz bz77uP64Od8QQzL08a8ffvXTRx9ffPpTHRxnGRK9nstGdH7W6qfQxezSGfKE+yvEPhpxse+R UTNE2ZDT5kD1zj+Gk//QS0++/NTFq2+99OTFM4++/MQbj7785L3DVbb7xaOvvvpy5cTbT168 /uTLeu/uZY3j7x5/8bUXXr145o2Lx1967eLxtyr3Xhlz1nvHDt1bP/zGryb+1HOPPn2RBmZK kLEUmo+R4ddtXOi4CF9nsgSgch0RJoCgKwxMAgS4joFJgITJ0Bjhqxjych0jnABLuY4RTkB0 LSOcgLhcxwgnIJXrGOEE5NfywUBAYdcxwgkY8J8b4c++8MqrL7/2+KvPvvjCuWO85F4ejvFy eoyz9FV1z532RMiH8f19OcJVJz4JOMqUtSO0tB1PPA9XPQ84QZrr9qb8BELSmVURSOdk201G UxSuIZpifPVoerliNKN0R1Nhfx0j1gt5C1OeOsQky5Lv7eKldjU233371Vd3vvPHJx89VO/+ xpv8h1568bnnnn2hjrqh2ZabdblZUvOLr736V70lkGHQDiGgTT3UqPz9Ce3vD9Xvyl3ePxle h0DgFoa/QzioxViycDn6uH3/h9+++fDiw68/2t/F3L+pP2zGwi/DYINzkGzarrnjzpOv1zvs i2dffPziyRcefey5Cjg4Pr9GtlMrZ6mJ3bgt/eHjH4dvh1rHcHV//uPF8KrQ739+/6uH/vjx 5/rrDx+ql0P97pvh2+HuqYrU3/708fLvd7dXCwc16IjTeGI2369kBeb7VFSG00M3To8cnxwr /u9efFgvvr6LzAm73XD+l8fQ3g07GkOTF6X1TPaLmaehUv8eDplISkGyfCm0i3K6GMYfd3kd t7Dw3BDC9CK14ejw7RNbxi3vjs9I45dtGaR2bq259pVa5EnSIVDmidqHv3341cc/3L+B+zfI DBHoaLBxDWUsRru+auurJkMMfmxo2YptfGeImiFKhsRnz/bdsvLT91d/prCz/fZ4drg29Liq kt9q/8OP3//UKjOjw8xayMhKGXq666HCYEghGXKwE4aOrDjxzlVvrnoyFCmVbB8veB8AsqKW eGC6k0lqBOn4sxA3jWmd5qSByDONB1KJpgonWUI+OpFVYbez2pIso87tTmf4AQSongwHitaf SHpCMterfxoYdv2RJKsy7894f3fXib6b+lUC6j4/xHQKm8IIjHyccOuOZ/E4cbWcOFsMkazv riNVWI8qY0lnA+4jfaAe75vhLmPTTuQwNMZyJSTNesjeGLMw/O9gjdBgrXIOrEel4JuGdTOE MH8m4C9bUrtny45b3fWAKpKZtgRav3zLK82JYekgaLCMa1JTJdLiukFFDS2BGT3JEIst4ZpY TCCijmtXZ/JQPsJ1MqQQM1x/smUZiGx/7uP/eg1C9dJo515u7PFZg9e4bVxQCanQ4LjtuN26 qrmrbnqa28BEQ9S4OR68FrzCR5ihATNCoFEyZiY1Aps7Mov1nNtJA907ODPKUngHt0dZLpEJ 44VKgcBjwiQ9Rejg9ihrBB1MGWVd6CoBDZtX4qZTOOd2Uij98WQo0M3tUYPgkNvg7oq6HlVm OuS2XMrtUVO4h9ujrIr9/7iN94mcm2SPSsF009weDCGEzpJsRn/61waxGyknudaGh97c6lHD EbiSZfQTsOZAUkcX1Q1RUSU2XebNYOgkrMVBCkrAxr2YcbCXQ1gnQ4o0gzXxUxXVUB3aZ9Jk 2++/qH6lny/1UwuuAboIQglXLs3ZBOjcPTdeATQWMSPx0VmylYAVhkOe8H1AKEjBlHkyqRHo 3JEpvimxThpoPYn1KEtOPYBushw5sTZtVwvyMUqSnhTtAXSTNehJrEdZJ7tKQIPmfJpO4RzQ SaFQdzyrNesHdNNA5IOokpNT0HpUmRDPB3TTZPDeGLPA/zCxpjGxLmcBuimF3DygaUys51WQ T357v+bWvv15PPqPlcRSqwS2razypbYjdiXj6LLMaAUMB0Fg2zCIFCWNjJxkiBUWGQ2GTKyB G5ciFIVZDxmdDCnJxOh7K4OxumH1JkFvcJpMv6s+1g+irR81XeaxllijNRJDsQChGPze0bqd F83nxZ1OGqIoYYUiSnObqayErggewkXG7I8JbAkuNKbTc7VZpJdoTWek0zSm06WH1k1WwDNX kDhQrBxzJekpUQ+tm6yx9JCkybrqVQIa6YTeOIWpDJIUSnTRmsZ0mvppTWM6jQdRZSR30vWo MqMc0Jovp3XTFKLeGLPSf1R6X6M136elBMFZtG5KReKmac33GQCBz2hN5C83XJNu8QarpH4R 1y+5e/vjYuMRwvIxCi9D28QjmKBg2XBhKxCH0E6GxHQJ2mKA5CXq5R3VlA5BhU1kaCdDxjwv Wos9tuXBa6MbJY8Hao2aqmvzHy/11LGswlpjGKOmZoO/GdbJUEScTq3VncSQY3TX/HTIEDQO 2aL3YYBycYQZW7IaJlTMIjyHddKgEj1wabICXbWPJnsAXQ/nQEdfqH0kPWPrgXWTdS09IGmy 4XKVgJaU6U+nMMN6UiBE6I0nEfXXrEcNVjiIqgiqBq1HlcTtANZxOaybphbsjTE50v8P1nKV mrWMNWu+aVhLS60LzmsfIEM99ufvtrTvCA4E/6tWCurux4WmI3gl6+i0jGmXAkgGw2Umqhrs BJk5yZBELGEaEKlwYSgbwygURoIby5hOhsznxWpyqV8OT29l59tQi8faxnv3cmuP0662Suxg FxJjpsH1TOxkqNDpYghJOGNxs+p5AXY5HT2CcpRe25ANqrODzACT1fJawFmw58ROGkzaQ5gm K9RF7CarnNmitRdGgAuzjEnPuCu9brIuXTRpsiFXCmiRucvTKczEnhQYtCu9brKo0k/spkHu h1F1IWBfjypzOUyv4XJiN00F7Y0xu/P/j9jaiG1+FrGbUujNE3swhOlFjW9UUFPNnOXN+s++ Zivw6VC4fX/7yXHLEbqSbUJf5nU4hynJUHxVxkCQOE6rJ0MqslyvDiUTwLJxIzI3Bz6shSRD zjJPqwle+L7OHMqe16/9VjPsD6pb6ad1JwNXV4EQCmqVimKDq5nPyVApsFKsFihOatI89aKn o0Vo5RAnPuDEpB4i1VaTWs6Pp+AmPicNwa6MWkfmWg+fm6xZHJDEqZDFwo160vPiPXxusgW7 itWDLAPTFQLKmKr/0ymc8zkpkJXeeDLHGeUPHWkJh1GNQoqwHlU2ukKxumm6dfG5yUbg/4/P NvIZz+JzU4prKH9Y4zPOyx9D8ZYBL4Y8c+zAB2NB13GzRVtoOoJXsk6gy4QuxYwKh7pvDMxD CxwTejLEvjyjSG6CwgxDju4qBBiHhE6GVGyeURu88m2t9eg0hcgwVuPFBveOWy932khWiS0c ogXcYnA9EzsZCvDTGXWxwo7hNHhuVPx09AiJDwETDTDAxVMCmNQoXWRTsNP0YtJg61lnNspK dE0vNlkt5WClggRx6MLdetJz4h5iN9ngrqmvJltUrhBQhnQVT6dwTuykgNFF7CbLgP3EbhqC cRBVxcKIuh5VVpHzid00zbsK1k3Wi/z/iO0jseksYvt1EdsbsWG+/sOHsmytyrLX73Zd+Wj7 zTgFJ1iL2EttRwDLRzhVrkZEU4Yq4LqxqJKMvOtqtK5GMsTL5eohFQXnYVGXK5MTCcshtZMh pZjn1XUJSP3z+tb2BQ/El6tntPcut3b5bLCeZjthWHGBGBzP0E6GPGRllpEFwUygOW5+XESa DJXjtcGlTYpxEC9Oig1qBOn4s1jPoZ00CLoKrU2WsSvNbrLCeLhoD1gCFvCS9FSiB9pN1rxr lrHJelwpoAXmh5hOYYb2pMCAXR+CTRbJ+6HdNIjLYVRZndTWo8qsfP4sY9OUvjS7yar/D6Ed taTOBOetCWlKVeumod0MGc0ePP36C2+9u+X5ojVGea8inCqzlluP4JWsh9sJYJMhAYbKkCE7 oRSDZWAPhgQKLM4vijk6i+qmALCJG9CmZGAnQ1xgnmajtXXjxttbpxUghJ/XAjXsPcytPX6L 2OpKawZTRDJB2bgfQ3syZLSy0lqYhAqADc6L0vFK68mQl8PaCEKdHBMKdEuTY0mtpErWLN4Z 2pOGAnVBpskidy0NabKkqQa9v2aWaiNJj60r026y4l0rrZusFr9CQNVTUeHGKUy166QQ3LXU pskWPWOl9aBhYHwY1XA2pfWoGh7NNvrl0G6aFF13M02W/+1dmTezJXjssjhMW4KPKS5JWIk7 troOW4IhbQlORqzoOZt04ZJNurCySXc6qCud3If8xLOv7HYUH+uFwE6vnKVXCDsitdsU/N1u U3C0aKUL10mhYzftKMvwH02d6OmcgUaaK/VsPKeRyKIdsTu58Zz2+D1v4/mopnjmxvNRzQjP uaZvduP57qDRMxqXN54nQ/FvP8mgZzP52LVC3nH572T/hzOHVIaenTlzOCqF4s2mzM2QIc6e al03fog+/8hmPPab2Cqy5F5TxYWmo6wxGy6nsmUORQ8AMtqEBFEpmrPlZIitLO9JLG4owbRx gwCWhfJGMqQynzb8Zigz18XRJPtc+aeHau6MN5ybmrr8NaL1feRGUbh42OB0zpKToQBcqUe7 BzJ7c1oLHJc2JkPFD5M6wprUmWjkCa+k5ph2/c7iPM+SkwYxdmR1oyxLzwqPUVZccz6HiIEc Cwuok552bXcZZR171uSNssHlKgEtKS2dTmHOkieFAO+pR4+yGKU7Sx41qPhhVJnB0NejGoJ+ dj161FTumaUdZU3/f9tdGBqn/awF1KNSqN4sp5shQ5q9neOFegOvn25vvW08+IOVYl5v43nc L67LrUf4SvYJ8QSuFQogWEGWTSFhCfGM62SIl4sbxMFkEY1ciKFEBoe4TobUZounH//1xeqG TdsvmapPXP0T3fl3/Isux01ildtmyFBYhAfvM7eToSBd4XYIKpt68/6I23NDDkCHmKGGmeBi adtzUsNUq5gCnridNPpWKoyyXKSD26OsHpSkHagAF1u4D096Zj1rqUdZLz0l6VG2YFwhoAEJ W9MpnHM7KaBQbzyDvH/lx6ghEAdRZRBx1/Wohiqdze1R06JnHnGUDfz/rfxgbAgWPovbg5KB 3PTKvNEQ6XybIon/uSWTmkXfPnbgjrYugtzbfBvZcusRwtIxmOIUuwt7GDC6boo7MdgxuydD QkvsDnFXFhDcKEUQAXLUb3eGsBnCbMhKKkxj9YF+r//sd7Z8PW7EVN07mFu73Fa0VXIXYAxR RR58z+TOhoqvrKnGcCVwGJxXPtwFkwyZHpGbB9AgGeQddlktlbOncM9BkxScpQc0o6z1lKVH 2YCDxb/oqAWWCqhZT3qWVO9kvadkOsoW5KvEM1eOpzN4Mp59OxabrAP2zyXuNFQOozr0sdh6 VB0Knb2ketRE6plL3Mnaf5Rw8yq4izntIcIjRDK59yT/5N0tXP53GLQ3UF//SwdiO5Gkj29D mGg//PztbvyPNSZJhgQ6Df3y7fdffpWJlA3xrCrzx/P+2O3TxN32x3HekuyobR2Zg12TE58U BkDiCEMVvwQEuVL+pMiGytJHjokhOEtsWIuFEnn7LpWws6GDNSdsm/vvurH7k9lfr//sXMuN Xf6qwfpHBItxIBANTq+cEF3bKImirApl8FUKWlm5RIyw42ULO1mjjjccjLKOi28Cee2Fc98F sjMn1PESkp2sScdbYHayoTtZvVQ2wFdkhxeyPPboE09t7nzs/Y/Gd7F89PEPH37/+Xf1/RcZ JEFlZ0guP6jG/rnHB489fvyZ+thjI2iPPf6+Pmb5oa/f//Lj+v+dyDYU/ncPQT42ecNnvOzw ARD1Yea15v/p99/+9N2dcFeSfTjJisfmnnvuafL1Yey/fP7jZxsYWm75G1BLAwQUAAAACABQ XDZLAiyzyAIJAABLKgAAHgAAAHBhdXNlX3Jlc3VtZV9mZC9tYXRyaXgudC4yMzkxMM1aaW/T QBD9zq9YwZcAId3ba6SCQptCREhQGi4BshzHoRE5KtuFcv52Zp1j10eNOSK1lVJnvfN2Z97z 7sy6hNxn/D5WLY4dTBmKw8SLVuOLOPHmszhp4EtnKsmUiunU93ETUX4bHSJ8w7YjjKEo8eLZ h/NoFSz8+GPjtPvYe9F/1BscPW2in2+Ho2fdPhqOPPK+ifover0mUiU4imxw/CCZrZYaZdQZ Pmuib7HvnfnLyTyMDjX08QkgQJse6/Ct7vM+/T6d+x/iw9O2N+ycjgbDzvD75ro9HKUdojBO VhGgrP0Kp5KOXYF//G4IGx56l82eMoyC+SoOG3Az+1Psy+mmLyG3f9dXcDQNlsm8QSD+J95p Z3RyDBfH3lFv0HndOSqZinQ28O7vp6IwikJ/kqLffIdvNhG5vetLrL4UC+ai8DIMPoWNm63W wcJPotnlwXy2vLjcfGl9CAJAeFt1G2KJL+kU05BgdHAHMYk++VGM7hxsPTEjOtJF4+hjQ2um ECgNQ9wJxjkb5aLFwj9vbIRGXNpEz4eDESihffw9vXo17I46TfSs/dx7Puy+bI863/V1uz/o v3k2eHHaRPcITFNPSCvFV5MgpOP8SApL5AdBGMeNmwdhEhzMJ6141TqPwvnKn0Acht7gKWAA GOr0B53+CDX6KxRfBGdoOpuHaBWhySwKA9Dkl9tZaCrQ6jxcZoADPzgLAXbgDY8H/d6b7wNb AywLwDGaxomfNJgWd+ItVpPw8NTrngw7j79jyTlIWj9sX8NDQiTG4G+r1fpR5EAJYcdz09lE NBPGJmL5uOGwEDfpbvTJ8qQWR1dqG4j5bCy5/jxPzkCyaUhwzXC4mK9lzrTKieN0eifv6DsC v7jwy97hB/Bnc+u5b9+8CUECUTEKY+g/2VGIqgq6I4QVdEEIxVcF3WXMDjqlxMGsqGPtbFHG x53+m1ThRTbc0M+z4XKFFrByJ6DDxrafjyn0ayK47RCxHRgej07JXOVaIDvjIDX+s0fvpPu6 c1w2+0uiACwd1cAXfFA0PwWeTgH2JsX/fA6lC4GBLgzv1hY0wYQXBL3QUpb1pEwww1dJmf1G yuhVXSkTzHl9KRPpciJzWjZQQtlaZsRRsO38u5YlbCA4N5TDilp2QnerZYaFzGk5B6A2czUP jPqfWsbOVswGP+8EwbK2mgglBTUFf6Imwpy/VdPzd+IdrSknInBtOeneUlwpJyJFRk6u4K4j /11OjIwLTChclBOfqNpyIq6TlZOcOGtjLhz5H/Q0DrZ6MgPkvaCE5ycxWS+OXNL/vDgCdGF4 hmvLmQqyl9wNB/lZ6RzZj4Iz7zwKILduD4+e6NTaOwF7y2zMcZFVRowsCswSmd1xSswZ2ZkX 1hkO22m1NXd31vaOW9Nactta1rZzSkYN6aSmtQvL8sVSE5tNC7fpZNGEE5IWo8ls4vmTSaST bIuXkKS8UOaSnB3l+SI2Y0fTh69kPKYKxWdatmZLQ0PXdDzBVoVYUYACUrd/MsgUoAZoOhYT /MOUxcWZCV4yM49cObFA1pzYpjL+H3N0eOURQK0TAIBxCfoQJtF8tpgljWGv+6w78mCOGuKb bvWCi+hQrwp3CNZLl24DPy8PdV/JPfCh2++O3pRsG1C8ZrYNJoQSVP2H5cVnJJ9UwwZGNvsd ye13R0+GUH5pGUJrNAk/HS78jyH8bcDDqYGv2vdgw/jTWpgIta6f9d2xfuBu2zbr1rwNrAm5 cWrYQOHzOZoloXb3ZhueV7SaovHFlOTCRPC75U2Ifho/lgNh3AIZTKdxOQhRVSCC7olmxYhb 8Fs65X7TrF2134rm/C4HIUEViCv35LdkpJCiOoSU+82ydpV+wzlVzu9yEIKrQDjek98cCpWC 30KU+82zdtV+SzfndzkI4VeCMOESuk384y/xAawfMziI0tdJuDgIzi+y+X9/sF6K4fK4O+wc wR6QLwuy8Pyqkwwwz+Xr+UMMAyIdvZxPwmUSA44+7INjLfgWzUJ93geuUUem+4BDc6Yuz5vi omVhSMglVM1kE/pSe70ZpWdKMbp1Hyn0PFl/S+NPdUUDn1ljbj+0z9LjTaTDcR8KA65SQ6In CJ9ZQ2Gr/kU8W36A3GiezM7nX9DHMFqG8/u7BrIuqhhLGWJZIMfZowIknAv9swIk1NN/qQBJ qPNXCiC8brkBfUVm0VTMpQ6uXRHt1g79bZ2mFFcRNtYJbm5YxzHJtN3PJNPFmtJYu0w7uAwb wdlsPvGAo+DjoVk34FUNwKwTvqMeQHgvn31fX5ycbi+6vc7mWqd+T9r948230RPt9/bWm9OX p52NtS6PRr2t1fP2EM6z07butvvRk25Pv5botIfQ2ETnfhQu0xT+PImsGUpXp87JPLbbHO18 6lGpwS7dJ5lgUOrsnUEIaZ5Byu0yyvSrxyAIt4RBIwR+vRmEGQrDoGkrMGjftBjMLqRQWe6b QQohzTPIqX3qbfrVYxBqsgoGGWHXnEFGuGHQtBUYtG9aDLJsMNz9MwghzTMouH0KY/rVY1A4 ZQwaIdDrzSDMkBkGTVuBQfumxSDPBEMyum8GCYQ0zyD8GAatfvUYlC6tYJARcs0ZZIQaBk1b gUH7psWgyATDEftnEEKaZ9DJvG8x/eox6LhOCYNGCPh6MwgzJIZB01Zg0L5pMSgzwVAO2zeD GEKaZxC2Y8Og1a8eg/Dar4JBhqfXnEE4yTcMmrYCg/ZNi0EnGwy192oCQ0hzDMJZg72Kmn61 GIQJVqyieIzD680gzHBqGDRtBQbtmxaDKhsMBTXvRRJeNvLFysmLUee196rdHTXXVcj6FNuO J8MtpShXZAthkt9SCFoCQVrM5Y6UWwiTfZVCsFIITgU8elsIs3mUQohSCFcoJeTmnU2uRN0p u2DjYqZ2NqYoqrQBJ8TOxqTh1TaU8p2NSfyqbRhj1rlLB/6N7UK/TUHJbBGmYmiJ9P8fg9Vy c+6TvsmGzyyMotuhs8f/5uwxP7aEhMa8/zLnudVGXFBjZA5Dq42kMm/arJPEaiNHH4SFl7PE +xCtLsDwdubI5GGmL4UTnbt376b9wwn6PEvOENYtN34BUEsDBBQAAAAIAE9cNku842JheQIA AAoGAAAeAAAAcGF1c2VfcmVzdW1lX2ZkL21hdHJpeC50LjIzOTExjVTtbtowFP3fp7D4Rdcs vf6I7VTqJlTMhEZJldIvCSlKE7MiQamadEMbe/fZ0EBSs6qJREJyzzn3Hh8H4xPKTkD6jHJK A1ToMnle3L8UZTKbFmUblmKSypxRzEMNHiLsEJ0iONjgKPhSgmQhWjzpx3brWJfZ8Sz3i4Wf pdmDbnkoSuJuNBzcraLkbBCpW3VmCWidAAMAmhRlWraph/4Y6fki16eXSb8Xq28r4Ix5yDwt pr/1KcYcAHvI9/2/21Z2TIKh+Tx9ag+vBgMPVcUXcTRKYtXpeui8c5FcxP3rzkh5yMiBJXmd MtOgAZqMmHGUzRaFbtND1DwcdUJEQ50ygoUg8rWBYTRUjQZW9r5jHt+dR1eX9p+pidWliq9N 4Wfc6C6TFCZvuyMhRfOXR6vZrPIQpyGYReOuSZQHTVAOm8MYQkBgLl0MIxzNn54Xpc7KSirb oOyggQHVbF6t727i/kjtoQq3cZlN7zmzvz+yLClsbPAHIxMIjJ51mtvEtMbGZTXojckYmxOc k47hi7lUrwiDT/X3LZMlD0lKjIy9NIQ45e9lUwTBLpshkYL8L5oCQz0cBEtJKXdMs+O6Iemq 4d3azl1mt0s3kW9TIURtsao6vM62EYaQQsBrmXR7lWwT5C2YQr4GSxyS/evs9tzr36ruvu6X ODBka9Ud/dsZwo/vOwIMtvM6LTMI6y4fOmhMWLUdmt+B6vvhQggN0eSl1MuamsapQfSuRuo2 uel8V5UXdqmZYJJyJlwmSkzraf5zWuiKi94bVatuIGaHS+ts9zoxW2I0VKq7h0NypJdTM7rj lKn92qgNjK1HR0frep2jX9PyAYF9cvAPUEsDBBQAAAAIAFBcNku6Jp13kQAAAM4AAAAeAAAA cGF1c2VfcmVzdW1lX2ZkL21hdHJpeC50LjIzOTEyZc3BCsIwEATQe79ij5aWsukmbVoQEdKj 9SJeQ0siBhTBRO3nGxUE7R6XNzOMtcRblAWnigSBt0FfL+PNB31yPixwqg+DNDQy0VjMoeQp LAGTT45YQQ3nKOA8mLvz9uuJCcToJVWSlTKHzVrttdr2u77r1LxDxG07uTiYwt9Fu/qxVS0g y7K3twYeLhwBX5/kCVBLAwQUAAAACABQXDZLjywKVJMAAADOAAAAHgAAAHBhdXNlX3Jlc3Vt ZV9mZC9tYXRyaXgudC4yMzkxM2XNwQrCMBAE0Hu/Yo+WlrJJtmlaEBHao/UiXkNLIgYUwUTt 5xsVQewelzczjDWCGlQFCVmWFXgb9PUy3nzQJ+fDAqfqMCgjBKPaYg6cUlgCJp+cYAVxUlzC eTB35+3X85ERYvRKSMW4ymGzbve63fa7vuvaeUctOdjJxcEU/i7a1a8tUdaQZdnbWwMPF46A r0/yBFBLAwQUAAAACABPXDZLeo7vbZEAAADOAAAAHgAAAHBhdXNlX3Jlc3VtZV9mZC9tYXRy aXgudC4yMzkxNGXNwQrCMBAE0Hu/Yo+WlrLJpjEtiAjp0XoRr6ElEQOKYKL2840KgrrH5c0M Yy2JFlUlSEqOEFw0l/N4DdEcfYgznOb7QVk+MmoclsBFDgvA7J0jrBrBWd3AabA3H9zHEyPE 5BVJxbgqYb3SO6M3/bbvOv3fwRWCm3wazOHnkl1+WZI1FEXx8s7C3ccD4POTPQBQSwMEFAAA AAgAUFw2S0N9xHSRAAAAzgAAAB4AAABwYXVzZV9yZXN1bWVfZmQvbWF0cml4LnQuMjM5MTVl zc0KglAQBeB9TzHLRJH58WcUIgJdZptoK4o3ulAE3Vv5+FnRoprl8J1ziEpJStQ4kSyXApzx 7eXcX51vj9b5OY75vtOBhbgwGAEnASwAZ++cUFykKspw6oabdebjqSdGnLxKpsQawXpV7dpq 02ybuq7+O1JmMKOdBgP4uckuv2wuGYRh+PJmgLv1B8DnZ/YAUEsDBBQAAAAIAFBcNkvU6+jE jwAAAM4AAAAeAAAAcGF1c2VfcmVzdW1lX2ZkL21hdHJpeC50LjIzOTE2Zc3BCsIwEATQe79i j5aWspuEJBZEhPRovYjX0JKIAUUwUfv5hgqCusflzQxRy0WLuhFcaiEh+mRv1/Eekz2HmBY4 qeOgHY1ES481MFHCCrB45zg1nFASwmVwjxD9x3MixOx1riWma9huzMGaXb/vu878dyimwE8h D5bwc9muv6zOe1VVzd47eIZ0gvlTvABQSwMEFAAAAAgAUFw2S87/RcuQAAAAzgAAAB4AAABw YXVzZV9yZXN1bWVfZmQvbWF0cml4LnQuMjM5MTdljcEKwjAQRO/9ij1aWspuN7VpQURIj9aL eA0tiRhQBBO1n29UPKjvOLyZIWpZtCgLwTWxAG+DvpzHqw/66HyY4VTvB2mICRuLOZQihQVg 8u4xFSyRGeE0mJvz9uPjSBjJQfJcUilzWK/UTqtNv+27Tv1viKoBO7l4mMIP0V1+uZWoIMuy l28N3F04AD6T5AFQSwMEFAAAAAgAUFw2S/97MoCQAAAAzgAAAB4AAABwYXVzZV9yZXN1bWVf ZmQvbWF0cml4LnQuMjM5MThlzUELgkAQBeB7v2KOiSJv3VEnISLQY3aJrqK40kIRtFv587OC oJrj8L33lCo0F5CYtTAScsY3l3N3db45WufnGPOhlR4dhoVBRAkHtCTM3jmtYmZOM9Cp7W/W mY/XGIDJi85EJRLRZl3um3Jb7+qqKv87cmRkRjsNBvRzk119WVEphWH48qanu/UHwvMzewBQ SwMEFAAAAAgAdlg2S9+LX2smAwAAawgAAB4AAABwYXVzZV9yZXN1bWVfZmQvcGF1c2VfdGVz dC5jcHCVVG1P4kAQ/mx/xRxGbbFI5bz7IGLiCyo5A+bAXHJKmtJuZWNpm90tnGf47ze7W96F QxJgd+aZt2dmdjcgIY0JuNf1y8dbY5fGfpQFBM48zgkTR/3zORl/42VOX2IvCoNFjZYuyrKY crGEQ0FEeysymqwGEm8p4avikUeXskqTKPrAnA4IW04z9GMhsbDwKReh1RMejaHlFsFPYi68 WIBihgqKdyiW57wMiS8StlLCNpUyGr9ImUFjYQwwpIkH8NiLb4Pf9xgU8Tx86lrGu7EjVSPm hgF/qnShBu9QOrbxC+OqVrJggxKLEBmvGupm7DDCEZXSlJjazEKcbrIpdV9qaIyyBSRG34RU dOagJ6drw43brnceGg91t/3bBk7/kiSUFVoIX0Qfb4dmwWd8s2Ar35ofP8nwtwaeSKgpWUc7 6Yqq1kfe24Ku0lWGKQ1cASn+oTZM2KupTEIwpcyCd8Ts4DJwIhA38PhrNZeENIpQau5LIRop YcoSX97NduPWvbxvXf2wQQFsaD7e31vK2I8STmYsozCXzerVwDBlmHxo4ugRxmwo7PFTaHcu fnbq189xwQbXvXlsXnUarabrapNRn0YEzFJJsZHnr+qRe4YlqbowKT1NNvxqtu4umreWBT1G PF2dpnOAlOSk7kGlOnPEqCDzbd9H6LQleEZfZ+BMHEqzvA6VPyfSYbCSvw3SdBYGjYPpuHw6 iue//i9IxiNCUlOPRhGOHcdRrRivpf6m0Wy079ZyLxk2c2K1hBGRsRgceRkDwXnRDSmX1Q8I wgUGVrEhxedNLTmUMMlSGMAxlNQRi5HXCpSGwyEc4cfQ9tMZgloNtNHcfE1nSYMnw6XAM7fL w+fkw4eVn57ql/FMvmTFc4jJyJXLIx1OzkdpxvtuD33pvfqK5oDRZDWymA3QkxwqYR9FPIde Fobm9xMbDp6dA2tN2EIp56ugtzDOW7cvrdXoSA+FvaBgzwhb40wbKf36jCrbpoTHNWlVFvOa 9mZzXpU8Mb2gFNfzm4TjswVmFRSntFsFenhooXgt71Q5+VA/e6TIH+IP85bK7ZuAc+7Gxtj4 B1BLAwQUAAAACACwWzZLNLcx2g0LAABYMAAAGwAAAHBhdXNlX3Jlc3VtZV9mZC90b3AubG9n LnR4dO2aW29jNRDH31fa72CJB142xfdLj5C4bIFKUBCUJwRRSE5LRJtGTYpYxIfnPyfHx/ba e2MbngiXTlrPjM/P47HHPj/d393tP9ls9n/sHza9Cmx7P9/tF/v51ernD9huf79Y9mx2dcVm +z2b3bE9O/lou3jY9fN9v9szwelz+MH2d3c3u4+2/f3V8D9oL6DzBz5s9pzNBJst2exP9mH3 IZudDzpstmVSOaXYrGfLF8ubfvdsvYHXh+V+fbfZPX1yu1hvTtkPl59+f3n2PH7d9Ru4fvrk x916c80+/+7H8+fsy37zsN7055t9fzOzM3P29Mma5Pl2z1b91eLhZs+Wd5ur9fUp2++Wz273 w39z9HR9t/pYPdvufs2+7J/9er/YLH97+mT2Hp+nTwjEvP8DHZ4v9vv706dPGNut/+rZ6z5C yKHd4nZ7A9Avtq9ofv787OLy/Ivzs++p+X2/WM2v7u5vQb35ufz28tOv55fn35zNzy4+/ezr s+d/Z7/6/seLi/OLL8nSar1b/HrTr17dQWq13vwGXPD12lb9n8ubh1U/v35AvDRbvS/i3Yvd PMN8t+0RItv1aowsttw+UPCx6/u7hy3ievhydbO43jH+p2cfM/++PXifQT7E5KuboY/i/2B4 y88jBEMYh3Oxe7FZzpe3q/lvi83qpr8/ZfjCxKv/PHjcgfzu4bZfxVy1WP7OZKG0X9/290nt 8LX/c7u+71en5OCQCE8Zx7dgLRcmMOG9dUaLKEzNXt8mS6YHg0pap3mwb278upaHsTrhcKu8 VaaLfei6Q6+62LZDmke7Dp+GWvTRdZnvWlmcWEstNgwYD+vEvyaqvNKBc8m0lJwrI6KQE/XW e68VgkYp6QWfhAZRa5RwsFAZbBHVSnBdmx3RSEIDa0rzLvZhIiqFwF+dyYnWatFHQTQpJ6KO PxZR471x3gkIVgcn1CSkZpIbjkFFjFqtg7JyEhpEg/MaJhsGa6KAr9CyMjuiUYQGvePKdbEP KUaD0SFwnROt1aKPgmhSPkaMuoCwkNIzJx33zplJyIlqp5VxTGhuArdyFJpEheJaS+1aFmuk QQVe2Z2Q6iHaLPdKdLET2bQXzomgcqS1WvRRIk3KCal+LKQhWIMBs8xb/FBKTEKOVEnMHw9c Hs9s7CS0kFqJYTLK1BZrpEgG3Lja7sjGnAjPubaUCWMnElKnePDW5khrtdHHS0iTckIqHwup QJazlExZ8HDvuJuEIky5C0Fju+MQKs5Gock0GGmlFL62WDPVFhlSVXYjU4vH5T44BF0XO5GY WuWd9MXMr9Wij4JpUj4KU4SFxSwxeBw8t8a0S1KZTrkQZmiPpSYJDapSOi9hwjdt1tMfC7nl teURkBsAOW8F72I3Elf0XGEQcq61WvRRcE3KR+GKSWKC9mCACNMeS2SSigwQjKeowhBr/HUS WlwtV9xrK5s263j1Fq1ryyMgT4CCM8gqXezGxJXWIsGVz7nWatFHyTUpJ67i0bh6oZQzYQgT YYXwLkkFV+oDZcAgpHdJaHENeBiHGdu2WXP1QZva8ggoHCY0R2ruYjcyrga7JlvsqWq16KPg mpSPwVVis8a1JK5GQ8CzJ6ngaq3jnILJC0TTJDS3/pheDiBbNmuuePIhb9eWh108PTKCSnIp u9iNLjuewQwYKRd1UBc95shri9F9iXxSflvkVfnG31i+DYdbq/Kk6Y0lYfaIb3Qw1of/PjSk ErT+GNrrIl8K7ZOUhQa+yRAQGshSSKxuElqhYbBEGK9C02Y95RwKE9+yPJQjVOFJJy1tR2I3 0pTTQXPpi+1MrRZ9lOOflNP4P1oZI+HOOC7BwBmFetabJOVTzlpkJ9rQ4JHx0AfhFVwDZoY0 XDRt1lMO08jKlywnrnIApDg27l3sRsbVCgt/OddaLfoouCblo3CF4RCQken8AGU/StEk5VyR XKShBTp42gdOQoMrWnqjDTdNm3W8Bol9cm15BKQOgReMkF3sRsZVYz3RxZamVos+Cq5J+Shc vVFUTYFrwKMrPFSS8jygOKKQ8oDWNgg/CS2uxijFlRBtm3UeMJ7b2vIISA+AUHR50cVuZFyR 6FVZ1tRq0UfBNSknriY8FleFYyzM0SCBLjj8a3SSUkvFsaWUKKQlHSpYmYQGV8O1wJ+kbdl8 ub0Gb3ShYXkENNZ9hjvdxW7keUC74IsKvFaLPgqutbI8UY+2BUdRi9MCHGlRQUILvTFJys7e OCJFgj6VWPgSf7aooq5DLpWqZfHl9sIiBSFlvmx3hGMp6Gygk6wudiFjihXX6SK31mrRQ8G0 VuYn/tFygMLzUwJCXGFcpUOhnKSMKdIv8rtkCAAJOEloUTUyINgEb9qs1ywh8di15RGQI0AB pFHXjd3IueL3KhRleK02+ii5JuVj5FZlDQaS1mKcVCHIpNRJKrffHnNmKE+cEW4SWlwRlFpg zWrarLk6g5GtLY+AqO4bghQnxLEbGVcVqH3OtVaLPgquSfkoXFH/o6jCmkELJzfY6yUp54pl U9EeCwqYzWISGlxhEc2d1E2bNVfukXlryyOgMCw+OHRCEozdyLlahfHKudZq0UfBNSkfg6um zEoLN3qCExaPXWOSilqG57cchnbTaKkkQkLxSSgKmuaVB1Yd5DXddFcjR4IKvHZzYKf4MNdh DmfssU8Zco8aXBbbhFot+iiQJ+X/vFx8q3rwHa8T/21oIBod7WqZoisg7pRNUj7lJM44hpOv wCXaT0Jr/BFryOTWt23WJzQYUV1bPgykprrPIB4cjlJiN7LxdzhRE8X412rRRzH+k/JRykWN 6RykcHhyRbtUaTKpuErEk9JCorBhxY5lEhpcnTAW4cxN22ZdLhocl9aWR0CScj0275TiYzey ky+Cw4tUVqtFHwXXpPy28+qduFpNZ5heMjoLxvAKO0lFvAZsJYbiwwwqUWhyRXR4hyPVts26 rKFEVlmOXBUFHjhj8e5iN4rjDWfKJaJWiz4KrpPycbh6g2HjNGcNdql0FJqk4mYBGcMPV1R0 9yImocXVc0QBbvWaNut4pWTta8sjIKr7NM6LgKAbu1Fw5XR1n3Ot1aKPgmtSPgZXQ2fKlISw ueEBvVY6SUUeUCgUhtmKzXUmNLh61B/orvFtm3V+Fbguri2PgKjug7bDRO5iN7I8gN06ls6c a60WfRRck/JRuGKV0BYemMJWAZC5maSyXLTohKPbSJo9YhJaXBU39LYCJ0uYDHj7JElVweg0 ndTR7Y4x2CKqSRgBUe2HX+DMxHSxG3l+FZjJxbFRrRZ91PlV4dAwLxn9o3FVWpBtz+haH/W4 CEnK88BwCTWclTk8i56EFlcr6JLZNG1W8YrDGyQO5AG6XgWjSRgBOQJEqzmCKXYj40onqmV+ rdWij4JrUj7GsRGGE+6119iZ4Lwb45dJxbpFIUz5NQyPPQktrgH1vcIbEW2b9Y2NxXJdWx4B Ue2HhRD35LIbu5Hn1+ENieLYqFaLPgquk/JRXtwwWBBxwhEEVlBF7wApn6Ry3dLucGdoHZLn JLReMJLYaWHlDi2bNVfsyXAtUVseAQUKvOFORnSxGzlXTHVZ3NzWatFHwTUpv4ZrWdy9G+Ws SimQW+5wr+uRVHHsg/yI99CSFFsOB6WY9PSCoKUjc8MnoflOl8GTGmlaNqsTUIJiecPygZ3h tDZpXKNgLo/dKFKEoPPqHHmtNvookdfK8kQfq2T85fOs4W59vVncpLb0/Y7JZ3g/eNUjQ/o3 en33AeT4573HajASY+mL84vzH76iF/X/AVBLAwQUAAAACACOWzZLve4dE+kGAACtGwAAGwAA AHBhdXNlX3Jlc3VtZV9mZC90b3AudC4yMzc2NrVZaXPTMBD9zq/Q9APjQmh1y4IJTGldmiEk nTTcZTyuo0CGXBMbKOdvZ2XH9QXFCZC2iqPuW62enlZrh5C7VMHvHnM1lRyZSxN+NM7O3v4y +BAZPzZRvNNCr6sdOwTbV3KVXcSLxTTaX5rVOGlsVxQHifWdj/BKLo6SliRtmLSXtr2XXHYy f8mnpW0pU4wlH41tw8/h1EStyTyKVx/CeLKYRztvWghfqvF4bKQ2knCM9m8hJtDHYBWhW/u7 qI3wjXyiGhMs0cXqvdN72u3uotLL2l4GimNchlAh0WwWLBNMC7lE0xY6HfSH/sA7OPqWXD0f dIZeCz05OPVPB51nB0Pvm70+6PV7L5/0n5610B0CoUI8SbycyzAMTXUk5goUQH8UOTv7Jg73 p6O9aLG3XJnpIhgBBwO//xh8gDPk9fpeb4ic3gJFH8J3aDyZGrRYodFkZcJ4sfq8W3LNhYsW SzMvOQ6D8J2ltu8Pjvq97stvff+w2/deeId2EFZyIChBY7umDmuhr1HszxYj0z7zO8cD79E3 LDlvIeiNJl9MmxCJMcx3b2/ve30JhNJFPtfGOaMlGluIVXm7IFXeJJMonC4i47DqmtZGV5Rm REwnF5LbNopH4e3blhHZkA3lSrQywciSsXNOlPK6x+f0nMAPO8flH9tzH97I+iPF8Kfgc8Fm B6gCaTEKQ9m30mAuF9dRr4QoUC/sFPHvuAchFLlnUmuqZU3OdtJ1NR95vZeJ0OuLoiirLoqW FM2Wq0UMcnQyO1dfgF0LUawVEdk+gl3i1WIlmKaxXoGDNZhrIhpvwePOC+/oV+FfEuWCOztu aYBKEFpUgghUEgShrpabB/HLjJC7rg5PJG+qbEIZqyl7toGoCdV0W1Gj5+cN1UwYl83VTKTm RFbUnLvSuqRmWFFF3b9XMydBdSG4EHU1C0ozNTMs5LVqFoSmseZbxuaxzc6Ta8SMVS7m3H8l Bpc2VpMU9Tz5Ngz9yCqKNFSUIvx3isJ/TJMc32osKiV1Y1FpCir5naRc6hYlRYnrMvYPEiTF 1QRpPdclRYluLCnN1vLPdev+S0mJTFG5+8ocQP66qaIolrqmqHCD/EQJVdvmp9NzcU6baQmW nDTWEiVESPG7BEUpKx+3WnCt/l5NF4aNqitBNa6p6WI8DpqqCUJ1y2oi47UUuVBbnHQ1OV2E mZ7yAaqz4ERUgxinxy2XlG8exC+P29x1bfjmCZIKhf/LbUFQiwpS8f8ZqSYiBfQHq/Cdv1yF 8dQ5GBye+Gfe0D8GfF5/YyjY6/px6wLMNUQkc4vLV4droa/gtYTGoZq8Ds0wz9HFE7YRmlOl rtDFavMKja+FQ0VThEvMmg3LcQF3Re8IN0RLgmYf5tlmyW+NsluqOkQxseHNL3cxTSDwz0Da /VuCJL1ViBXCcrI0zmsG03hTRNQigoS4toWkKq+1FZhAXg7noEuwPba6PO2cev7ZKxgF5pow VgZItgbIZgBC8BrAGgKEuwbwZgBKiU0wc+OE7ybTkQ/HTPi+ne7r8TR4G7UPu5Cd/cOTTvcI TkLvYDDsHH0rdNpBbNdZ59HhSRdullNH8WS0jFftwiZ1R8kmhYcoUpVi4ATKfHt+vQXthbMg eu+AM/9ht3/4uIV+vB4Mn3R6aDD0CTxdWaec3dpqCJrdc4uqlOq2yl3b8j/aSqgSPq0msXEo nPKzYDK/i86GQIN3dD7fAW1bYqEtgZTE6FMwibmTTHf9UMgYM6YYflvoea9/ctB7lM6nPhmo 8daDyqS0WFcJ2SqWbDXJygNSKQ8OTwbwIMQOB72rkfnYngXvDbw7hEmbfCtlQu5Sk/Xw5GrO kZnHiKRTZsmUS8WQpKz4BIIWIy6HDHmCEbfmH3SHaOreVkHQliHgfh7MF9HUmKXzNf7oRyZs E5gbXM7tNf5eZ5MlWC7YlquR4gUvrQaur0ZuC6P9mjpcoy7HcNWAurWty5pTl0IU1ltQxy2W Yr6tkFM8o02EnNrCk6INVJdi4DlPA+pSW5eo5tSlEChjt6BOWCyDCnhL6lI8Z7iB6lJbyGgb qC7FKNpkw6a2LqHNqUshkJY2ps69iy0Wim61FXUZnkr5R9VltvCMu7HqMgxX+o/UZbZC86bU ZRDpii2oIxYrMHe3pA7wwAbclv1RdZmtxLqx6jKM6zahLrHlROvm1KUQtsWGde/SBCulKFP3 +uvzzrH3ogNHvRPtops30XP7CU7/4dMz29MGF9/f/ILTxEHJudasVkYcd3qds5OsjhDJdEQR JRjOVvMOqS8lzgZMv4BJyjH7BUxagiGopuxXNybaLfmUQJG5nMT+29Xiw9KpVNAPirYSg+3t 27cTezNCnybxO4Rtz42fUEsDBBQAAAAIAIpbNkuM31+r4lQAAKqiAgAbAAAAcGF1c2VfcmVz dW1lX2ZkL3RvcC50LjIzNzY33F3nbiNVFP7PU1j7C1BCbi+gpQcIJYtCaCLIuIwXC8e2bIfO u/PdcZnmcmbmWkJQso739vPdM6cP528Ki//ekF4bbzuDyWyZvGpe65T+ed5hr+TbOuY2beWp toYp3kl+Twa/Jq8+W81mk+XVPFmM0h/PLjo/7Pnu2XLVW4U/Ly8Hj8PL0TB81tkXvcEvmy9V +uWv+Cf98GH6k6c/B+nP38PPt9KPN+EnZ4ylv83DTyGtlOmvSfg5+GMwSZYX4+lytXgarMaz 6fLZjxcd9rsdjZIkGQnOse+r1ztSd37tLZad169eq2zXMt/pL3559fbrzz9/rXo0vws9GjFW 7OM46zw+9uZpp4uO415cdL68e3Hfvbt+78O/00/f3t3cX190vnjvy+6XdzffvHd//Xf4/N7t i9vvv3jx9VcXnUuOtWJB6YLZwA1A0spMjnV6g0GyXL767CpZDa4mwzeWszfmi2Qy64Ujveu+ +AxjYLDO9e2L69v7zqu3s87yafBzZzSeJJ3ZojMcL5LBarb447XC0EBFZzZPpoWBB73Bz+Fs X3TvPnxx+/n3f7/ofvD5i+vvrj8Ik8j8AJZx3xkF0r8qLzp/LVfdx9kwef5V9+aju+uP/2ZG qYsOvl2O/0yec24Yw37feOONf9ItF0eyNn+em8bZiRaO8aIjy+emBqVzs1wKKuCtYGx7EJNx 36jw82n623g6vPzdma5R4WAc8VCE9p1F0huGM3n2wK29/vyjB/HA8S+r/Csf2Nv4g29/VexB yHyLZzgv4EsKTBT+KEwluT12/lbr7PyNcsodOn5pef74heBeGldBdNhwFdAfXt9+n2K9Shcu XJkuSujO43wxWwGRr+7aSYt2mJh5ybTZTIyLcl1dK/aRrnXXWUqDzvUu4Uc3311/uG/1vycY K500G728Ba1leQUuXYE2xrH6S9jLEbKhy9MbbsnINv4QsutA2mrWFNLzB6HIeHZMk/GsnObi EJ6dUUU8M8lUezz3RywpU8Nzn+F51467LZ4t1+Ionr0t4ZlzFxHPvS2es9FLW3BMuvIKehs8 W6XqL2EvnrOhy9Nzxql4dtyICp4nfz72Apo1Dc1OCNUUzQAzu6TC2QlLZ89cG3CaA3h2Upb4 s3KWi/Z4HiQVMEhnqngesiGVPzulityxjx9pZ8W8qQ+mMp6F2gI6G768B81saQmb9bv68+8F czZsZWpDFjucEVUwz1c/B2wGPDMino1rLHB82SOD2So6b+aac8EOgdl6XxI2LJMRwNwbVFiL 06oK5l4iqMzZeS7Wa81ujIjInLnLwJwNX1qC1eUlqHQJHLJBXO4chi5N75k0VEB75nUF0ItV wDKnYdmDHk2xHITnDhXOXtQRNRTTZdacDaRdAc0QeUHU9mh2A1EmheQyQ3PWzlNZs5euxJp7 g5iihtmCORu9vAWlFRlNYCIVND0GMBkimLRxh8AkT4Cp8y0ZSeDiZCRBr/WKH8JS0MjPYlVQ ZcYInmLyM0GRdFZEEJB1v2zACPJdFbVmwMmodWZzKhnkWUTUcma3uM3GL2/CS0nGLRpXcDuc BOAKCnADB27BBSEfPSxo4MVMnBk6eL2tSKjZQGU2CGHPRWCDsq8ZK04l8mwwa+dogAoDmI0A kqHWRgSU2MIpG728BSmJ1tjQ1qsKnJLJiPxUxRCquf7eeYOMJc0kGUvhWaQOYUkXmROMUbAP mfZY4n5YJoTZx5x4X5GxZLbaewZEGRFLfPdMzYYv78Eq4jMVbR2rgmn4Wx0sOdOcN2HpD0II MqI8pwtpGBuLOwQpmGULkJLO+QgKdG+ky+yJM5FToHftfI+mc4QBXEnn4JvOXAjXQIMtY0rp Laay8cub4JpRMcUFr6qxvafhmC74h0FsYxb1wMg8Ck4BOo/iwgh96IEXOFJRizUQ7to/8HpD MSgTQ8kck9q1U56MKOXWa83gqHxMJjXcAiobvrwHrXx5Cf10CRLKf4M17JV3s6HL0xtOtDGG tq4qvw0Wf8xXsxTQJLMMhrGqOaPEF9w+GCKoracLcUJzGA/ZIVQ7VbDNKO2cjKAX9NygQhJY FqqoRivqo5dD8ypCajAarfmksV7GMDXKna0xm6G0DcHERjvJLrDbmGca2Tv3Ajsbujw9Z0R7 Y2hrq86g5aQ3fVlDN8Hj2zaGtRR4/jP9oGjAFtguGdgcuzPsELCFlOI8qnWFItLzgmqtvbQi woNB62F5KqX2XCGje9QrJJS3RfA67XeiRhNXZvkKjQbbG5RNUN6FNqq0CGvXjwbFVewrhLHL 8xtJlnUgpewx2SeLVLvXbwhFvETw4Ta+RAKEfZDEG+RqSNACygyvaPjZUKag4YM2wsfANTdl RGBcXsW11GStTHhbwjVc9jsfVARY82TnVs0mKO4ieJyJfnq0BfeqWs6T5Wzyaw3eDJlBtoMV UYyWQtBhxbkyFYEjG8n6kqfeiAh2Iz9SSZkeUuacQbt2RlPFaCn95hmSQVfHFKN3dshs+PIe lNblJax5pbGigWq4l1NmI5dn15zoCwptrakgerqc1NAJpZHNJWhE7bxDhrPxrgachZLiEJxt 2QyK6Arb3s7gh7ICBZc3g+7aqT6VSUq3NYNmd6YXE847M0M2fHkPcGmVlzDYwJk3WMJeOGcj V2b3ZNlZwSS/VymsY+RQnDc3ckhRw64PH5MiIxri6UHDmYLSUDSccWV1BED3dppUNpXlVUD3 maECGteyaOaAuTcmf96aYgujl1bgbHkFa/YMxdpFNnOEscvzK0X2K8AKWHXWP63GdTi00s2N wT89cEOGs+F0OENnUOoQnE1J3ODAVARvvXejQZkWNi9uZO0SMpyt26w1uzPDiHDmWzhno5e3 4CydQXq5h0GSvfVhAOebeuu/fNAPggYlzRTdAixgBzcHTcAausR5bAqAZHEmmE8LNgUPc2oE j5jXsjKVYLYKWzOSVNhqsXXXZ5jfxFspbRto8xXc9nc2hWyC8i6gV5QXsbHKKSPiBk2FoSvT O0+9OBqnUjUp/LH6eTYVb9iUGdMiATEUcNKUHb/7ILWhmhXgoKULzEKAEx6+REbwglkBJmcb IfXAs1H56YxF75GYxZAsYGirWBFVarjRHrGLJpHSVbsC22A7m6GyDcdEcRUg+zYgUNJZEA3c GLsyvyELGbB9VrXAP2tIGNr7xsHaPxGjARVETEWP1MaZlGNbs4EQy16ULzBTBP3PJcOtuJxN pXOJNLt2I7KRDJAtoZmNooYubJ0nheFLS7BkKBlgu2pQeHrs1UCTQdJbUzR1iGlZKqS9eTKa 8DgS6hCaNnHsGZqgtEYwubrBELQpTWVyPuasHVlaNYZvYkszyMaUVn0Gpmz00groD10DGlTA 9HIw6C7roMnxFuZWxV4nA8oZuoPXC0jthwAFg32JPSG1pL0cCb9thRpIa6oCqjcky5EIC9is NUNj1ND7rXmqMHxpCZ7MnmBD2UUrPy0XG1QhTi+o1MurFf5fp5KGv+n/KY7hrHYub5gehseA kFPTP9tmR/PE6j6ud7PpJBfHd3umbUpjjm8z0v6UYIf2d25Kwr52aIuxqQg95dAuz0ZB7dXh 7T0rsbcPb+7Kz0vmD6kSFk+AHFMnEkgWhrCyOUtPoxs0lalb6+nBDcZaww5t26lSuKzhJobM 6Xplpo4l72HqSBsiM3VvSlJCr9+PyNR3ydvZ6KUtINmVHC3rwP/PY+BR5VVxsyfmrDe/nL4k ZwIq1iqzVRp66QFMVSc0R8jDwd6QP0ro5daoCDKu6dnyIUuf0/+zdn2qA9gpvdHusisSE707 hSkbvbwFLcgWWWd4VWEaLZKkP5EAFRFSxjd3WYEf/koGlK2hgnMOR8chQCHEvWzih9G3PaBU r3JrXV5pytqRDUqIQd8wmAyNMT1WWxN/YfTSCjyZHWKx5yl6o8qCtxf5RLiage9Hp5Kj8lQw e3Z6i8HP3flisJq8+t7dB590v7q+736E/rludpAOVOyrrdjn4hGbKNRiem61O0I2dt0ruUhB 0DnaG+xsHzfTtN5Iy9v1zrMzSm8YuapOgtCZ2ttnx5bX7mi9hclOLW9soPWWBRtwZpmi9VYV F3WaNE1cuTZZ73wyI603jGXVlfdGtH0j4SVjVXnzNQmqCHmxptp9yEhg40LrjGT5aBNab7Mv /YEb2twwv2YEr4QDCvg42bHuShRCEbMg1syjdbS7rhppszj1NDLOHe3vCueepVeQ9q4hsVQB hx+03pKJfXmWtKuCUkjZyvOZTLvH29He3mcrz2erk+aGZXtfjSlO7K0qiQnrMlC03loU2LJP 1rSy1gl1tKPJ89SsIByNpxoTimo8TcMzs1gUbVtMrdrFOthSklV3NR52e8PhIpSYyz3xej59 4gkkOtlCPzx40n6LWf8JEtlkvFwV+vXSm1GdD4/GziJIcC97aam+V7+6+fju/oub2yDv9bo/ 96bDSbJ4nlF71B9iKPzVY2/5y/Mffkw/jya9l8vnX72Hc/jq/sXd9d3f+IyRbm4/epE2wD5g dcgPNOwjdP6fi85GbKmuDDUA96ysyw8ubGCICwuf37u7b79GBJ5v1wiMDMLEYZXdr2/f//zF B5+hLGN6lJ2w7B+PDQOcvExWi8n4cbx69e7zmy9u7rtYYxjir/Btd/C0eB7u5+ucBcSG77DP 35+HtkZ1sYeb25v77/+pjB2MgvUKKYY+RqV98LdGpM7PfJ/1t+U+KnMqhrO4WsJ8dBVUh6dl Tqsp6zIc5q6jlRpUvlxh2dqSDeJzPvbb3mPy5sMqVMF8mH4diILfGEOK6/QrzBP+7q6zVnvC aWK09M/CgJbnfFIXbPPPgQ/FsRCJWhzKUYV51HvQu0Nc/rG8Gia/jlFkMnxeJY9XU5xMUUO8 fbFGGj7CKnf9ASB+RHFETlqWaXnSqHfwsFEQJqB1mExXyzDO1evYewe/LcZJKOYJPQe5FCnM Ab58V9huTu0v/cGuHpPH8XQ0KyHHFAbLwinNSeQctlByGGg24DEBPBijwzpfJI/3s1Vv8uaa TkEYC/KW2OAmDLfGjS2OJaXNxnq2abif2ODYnFYpFm2VMuUz33fklX6akcHnQsrPEnVGh13M hFDQ8XS8+uNVwCCt6fdDeGjhGZJqsThZIAV7tD+mZoPCOOYoiAfzp1YYdvCqtMaws06WzxPD 7j1QK4pdkazUiBReUrNd0dbzJszUw6rSmpl6znlUZorEIRmJmcKPmrN8Pdu2S/+p7ENSi82i LYy/+aq781/Ga39ZAuHjj0sIVqvx9GXx7Ov7WXgI3CnUDd5cisvReB4G/6hZ1WAMbMXa0zha biATnDaj7uqPefIcAuoH3a++/vL6rvvFex/fwMA26vZ3XDH9bTIb/LJ8zsLn1Bq5+dj7tTee rD+H+Zebj1mL0XI8fP7Xr73J88Ae2I//hC+ngMwkmT6Hhpm2WeTn2kpk991v3vv85sO/8eH2 xVdfbz99eP1N+iG9++HT3fXn793ffHG9B6dOifwlSZnNL8limkzSCtjd5FfcyiAldXEyg1+O XhyfxzzqHjxM0dyk0EJbVWxrqSlkkJKUJK5xMJuukt9Xyy6+P7lgAWNP7k657XK3ixDFtoaa SykYNPMMoYvZbBVgmq4VCxyNXzavbY3BUVYgRel26DeycQvO00FD5yksB4bt7kH+sFeL3gA3 OHcrvvr+q4+++j9dCIEIV75388Ok//RyzxHc3733wfV/9RCO7NM4EZ7Ag9+GWyD1+k/D3vSX 2dU8vTurLuraZ1KaMPnuIY5gn9K2Vdm+vbn94JOqtpb1R0HkkoP+CifVmySbPy6D5Xr8K6le exhOqxr12gUcy9qXY4mywYo2+l17ctV27ssJNHCZkGsZCcgOuoDB//WNCy6QvKgL08vVmqMv Z0+LQbKTfdtIvJCeBGsr8QoYTVVFa3P75VbYTwtdtbApTU/t8mk6gP2k21v0r0azxWNvdTpy 5OByteekk63MWfeoC1sNNvetTtl87cbnNASTHrXdf9IQaAs9rfLNdn0V+FhZYnCFsUPJx/Es uNNg3b7/4OPr+6/yz9xw77Nn7v39951Xb6a9OVjkfDGGoL/u28F0nfUqXiuOrrfRkO6k5nFY GRdgP2tlPAzzbC0avCnUpQgiztpEnZ6bLHZSNutU1bqLbT3L2m6GPNAWAgs/35HhQbQtX+lO sVXwVdUQGGmzY8AIdy0G6XC0tkI6dmmLhOOFLkJqKuEEMlHJhJPMnJFwUtEJJ23TG50MXyZH 6Yb/otANMnOFbrx030o9PPm+CS0lmWxIBjoj2QzTZLIZZRuSbTz99SjVUGs4CtUQFFlllPIY 1VBkh0w1FEggUw16+Bmphsr0ZKp5bhpS7enQ4zMb2/AodEMl4grd3CXXRcoVxALJJPm+SWbJ 902iHvD5KCfhSKdSTsIKnxOZqEZVgZo3VBs62uraYmzQW561IbeUrPaDez1p1fGRjaldBMcH xvE5Z0VAYAatkg4SHnmOfNAIlq970OnfF/IEQrRBMyOQ1Hg+/7YYr5JXBTb29RJWj84HX0LB 63ycTJ/G0+QGprbJpbnU1+meZTqPLG4C1Q1KftNTPlA86znf+U2VK/tN19+W+yBfqTQPoY+z tfsg7nG3Nrl3bbLax+vSPCf7hOicusQfzFP22+qiQbKv/cTezHvsrimwnRh3TYERZHeNZVdt Y68ttvWGetdCcZE6xz3oz37vytbqudL12Np62hgaukKUWGsNXWnvmmnoypjmGz+tpMPDLGNI GYgMrK9Gg2eQxYzw3kKqmKGcO6M2puBXpYoZ0Ft0c+qd1KRRaz+KjIgMY15Tkw7vdqLSDk5I siatuTujSobECbJwDyNkLYvgmnZUZRpRSFHsV6jdYusp0xrx/mTKKUVWy7QWZ1TLtPbkW4dq PbXUsjXliPq0tjyKFURbzevp0xqhmmTCOUG2Omqnz0k4FFchE87rFg+7kyq1YTKK4dEgX6Su Sg3pnnzrkLJFvnWoY3RGk7ERnlGJZ1B3polKbaQlvsAcbeEcbCB9ttaqod6IBsA8pVgbLW0M Yd+gGk9OsVbHFGtj6Iq1ge2wwXGnTQhZ3OzQdhCj2+C019O2EvZRoti0FvYN3klcvghy/0Vw xY6eNUHZet9Xg+DQXo3h1D7KAyGRxuCBFnFwGY9Kl4Aw9tHoIuXC+MhYPiCCF/taSeWFlqsm j4TKmbzxhODSluF0qOHEm4iE1cUsQ9hG+9WYWhaIQ6sJQVGX819etl6PFE2UnT2ngwfU8udZ e3JJuinf4mo0eXpZaNBUdmqNbPL0imGtsraR/YRgsLI2SlS8sLBLUg1W4c3u5EPHG2ZIhz4I jZIuLkJra5X1xAdYNmcMUxUSJdoHkzhUuG/09IIxhwaxbNNkQ4fjcVzPeBHGvpABI49I7vhW UZ9WTkiypcNBqjyf5O4kI6tdIYmkCe9zCK+lXkOHYmB1r2FrsR2lOmgCVTbpSZkd78aK4gxz IU4hk9ltWWYvtq1x0PBj1T3otgK7M5ImiWRzxpDWHcT19vwOyZBl8JsDpnlrij1VbS6/FXbk JZI/x5hz8MdRvodkvih8D8y5Kq0zvgNdZuDNukiytck5oqn0+ElEkdFRx4EWAHV8LXFEdBRX oInExxcTS0JH7nUUOsUS0D3eWkh9SHnW/CgN7bZ55qK4U3wIc6neNlG6bcUukmwe9MjfjnAS UW4bUu1iUCXObfOi/uN+t5j4tw25gw2filjOOW6bFGSREAWRGnMKS7xt0kXxgHlEgOy5bfLY bVOKbIDyiujC3XcSsW+bJtqf9q0l+m3TiuZl27eYM9w27RpzRXuO22Y4OfrXG0VL69mzdkG8 bcZFsft6u/e2sWO3zSpyqIC39Y0Iu5OIfdscb4woEf22uebijzjDbXPNb5s4x23zNW6bV41i f703nqiFS5Raqm11jGDnxbzEhK5sXoKRF8O6GEZeyRA1RDTyoq2iOirR1tJCrfuY/Jf5bDxd ZQbXzOTW6+lGEcCwtXGaozSbv7V1C5MSaV2a9CihYT+KQmiZt+br44RGrDeZ0NLSXCjZnmOG eiO4ntOsa9n82/tVQlrjBejaSMMClrFmd7Tt591IvK0/BQV0G3gWeQSXCmbWrV0qGMQ1y89F VqGgPWYLG6dG/2J4GyMgCilA9ZNoQ94QNT0MbbUi+lXQ1p4v+leiGAM1IgptBU2YLVCP6hTD 8DpGZh/GsTXzaCWD5Y5MOy/otPPqnLSDEkSmnfc0W1KBdsToX+TBiRiWRoyjdK3oX/Qwnko5 mDGp3kyJOhzyfJTD4NTUPrTVNLGoQDla9C8Gd1E4Jhe8XjYtepD9MWirPZlwwp0vgBRSIKOm rqOtoBmUCoSjRv9ieB3DAoJxbN2EWmSmMqrBEW2FJhMP8flnJJ6y5Gcd3rfcRKmWHMkhVOEf xahpWl4BIO0VLZSxppnnCvOe1LXAp2Kk+kmOePFcJIEoRxIU22pquBraWlrIRmHbbYMJJLxb TdhA+3gCzCxbp/phEG2bxE+ho6OFExT2XSv6F1nvPEa6H8aRpmH0L/oasuyIp20T/ecs0b8S bLiJSHie6F+shujsLKzmbNG/klNjCwrrOV/0r0QZSvLTS7BGuSvop8lPL3jKaaarwgFFsQqj WlYTRZRgGEY5jCiGYYE0JqphGCVtqAlDaOtp1QHms9+SRWtDlZBEFpFOF8NAheITrWPgMIhV jZ5ZeH8tjT+n+yVbNlAFIYqWhbx7WdOygUx2ak66RN40NclSinNmx2J0RXV/oa1xjXid9tQg VChyvM61ay2hC0MMxUznOymZg8HIKFzN5Ave+ONczQqyZI6sE1rBm3S7rSVyQXXKp9PFkMSR TCDaczVXTenhB+zuhrliV6INKbdjtJgmi5d/XC56j0eZm3MxYnol4gBFvbgndKHbkBAxUudK VY5gn8jtixNss6g9FvPp7AnFdtfVkXhoa/Nt4eDd2v/8qcsBi1Mr2u0Vz31xBrtN2/VtKAgD K8tOQLwhQ9YGOBnSgh3eRhRCmY3QySVfy0OoEp9qU744hvTkk+GGJqIfOJlYqoLkRNv6gXVE UxEgrVGLSqAtMdxt36Ln6FHmCcXBo2TlYhy/L/JYH+EJ6EM2TaIQXB1xr3oGJ5mCRH0vMlNQ TJGhr4i25UMrJ3AFVIqKwhWUda25Air6kI9Gy5ZEjcUWdIuHLhYSz3SAeofUxGGJun3Nn5Mv 509H2YJRUcx1qBHE97AFdYwtGE8WFaQVrY7gNFewmi4qWEsXFaxvjjgsnMAUnIgjKqCmRGum 4CxdVKCWojhwMtF4gpft1hGNJXhDFxW8o4Ur7Vt0MMAdlRUU41HCPuCSdPVyAtHFkGUFVBlr frfCIZwWFhTnnsoWQplQKvjxLtCW9DvNGMIrwGIwhlCGtC1jCPUpyWcjiL7QQ2cTTVxQogXz DiuJJy8oSS4riLbE2hD7ll09Nlcc28UokyAVLnq9BEZ0oUfzKaVpiXEHjuA0Y1BOkxmDZuSn otItnkZYOIEt4O3wUdiCdqo1WzCczjKNrG8izJ1MNKZgiJnoB9YRjyVYRpYXUEJINbHIK6vI jjAolbTYmfRgongdlSNWyE6npHgbUQQ4SsQMXqhPLY6Ntp6c9YMYKGLWz/ypta9RUYtlYrIY nkbUPWlvk4fHTFds8mo/1hUrdZU0Ew72S46A18zESELGOJ7ti4CX/EgEPLJ5qZWF0FZSa4Ki rTljLC4qNJOjqDW1YF6OZqNFeDHpdHiUbEJFiZ/Wolq2nMNDLOQxsglHDqHWiK8lk03K8xWE wuiaWmsDbanZnRnZ5oOjBFMsikdfqz1vIeK+SK1SD0126GtlyXHTWrMzxk2jmDbZoa81NXt8 /kQOwdDa2igEM6xmaXl0IddCQVtDffsQ2rozhmDoGgKftqI2WzyUUpKNqeI8yawx9VJKatQl h2GdkYPbUcP8nI8xp6jVUNCW6DjN0Ws87a5+P0owF6X+icQ5VAkmxTGCeUEnmFfk7C3tzyp3 eEcmmGGsNsF600oBjeKQUV7YgHHUnlzJkphY6mGoL61EW0cml+HsjPzQcLpvHcXxa8sbk+Gk tzpKMG6i+NQNgmf3yYhcH5ERkbdLFu2NoCdIGnHGdx9idLqTw4j6MuKJ5DqUR45DMcRq1Euu g/WKTi5JFzmMPKfIYRRd5DCKmEkOcpFT6vCq+DgEwyvj66bUoWQSnWSa0Ul21kBdoxWdZNrU JlkqdXQH86NU03ECEA0eNlXB4+g1M4KsixmjyQYPY+wZ0yDxFgxy8rGxxDfC5mg2G43SrIvF 8jjZbBybB7L6+L7nmSnbPIqdHNm9Yxw9LN44fr7XfWF0SbZ5oD5akxcAoJ+l1qJHW0+3D7cO ijee0+0Cp0LiDYpmxTC94y7lEn1UxfRebOvIIfEWEj/5aNsGxFtGrEeDyWKEw1tU9Wpteres mvch+YEyNCgsUejLiXk+2YavVrP5cPbb9BLesdmvyeKPy/5Tvz85HtuCd6tFiW0Jb42pOrCH u/RUfjFIP/ELaH3Pn2GMzK8tZXEkuvJlqXHNhFOKkrFqqe+opSzopO8aXswovmu81yYf67Z2 T2dHzottHTl0xVJfjU05jUj+arwzhxbEQllTLN+1hSGc+tjEO3Zo4Sx7NrCczFbLy/Fy+ZQM j3IF6aMIrBCg9lTBTzKukI9u8cWedJO0VcTEmRMnEocDKEeXAY4sJk7OOl552ZhB5lcT7fbp Gi7lI+uJd/M03QDzL23X1htLDYP/Co8gUYjt3IzEAxdxkbhIIJ4QqsqyhYoeQO0C5d/j7WV3 Zyed+TLrPQ9HPadx4nHixPns2AVOeDxm/nq9Wf0GHcg5+BzIuVUuTldN3eMj0ghfGktevhs9 ysT3+M1ghOIsNz7aV7qt1iE77odfAZ8TzTLkpn+lwG7XUrRbnG/Wby5u/7z6ZVrnKrn4ykuV xmOw1aEV/AiifyiHunfESoJDHcr2ecHPd7+//c0PX331zlh2D5ylhnBEo+WRZvvbHOzPO8c0 ORzTKJejcQCaGPtpMu94S03e0pim1qNxZmlMJt1G+ss68tmnagDDWhscOO1NNaRuO+WFBbf9 qAawym+DCb89qFKAQatK4LPGA47Xtxb9/ubNaNnUYcfJBWysVKixB9XdHsSvnvuVFM4TVeEy NA05+OgQg6/OWxw46RD3Xzx2LLjpEFz0psGEnw4JwbECVQSPFTjg+Oqvq9XNZjJmoEpyiRmo UtJYi1JEtEjwd5w1doQljSThUnTDeACf2Td58Cm2YUygFbZaTHgV2TA2tBuw2rPhVlxDaiI4 4rcm6T7IX2z6zZ+bq9uni/WkVqXs8sqppspjrZL9nTQ8osODm2kedJADWtjG2vaf1GO5ONl7 GXyCNskLgAjXXKoHIlyzFhQRroUJRYRr6T+0x4Lwsz9L7tb3MTuOlmhRGI2qtSPS//Dc/+P6 9mY1bYtW8TlFa8qtUxTAoGot+Cmq/b6yvSScrFEFKw80efCyRxWsT9Nkws8i1X5McM+Go02q Cp+iGvodd9ub6P1mLnuABp8oEg2ZGh7WsFOmyq9mANZQ4ZudUr/T7kUSTjCuEpggp8GCF3ar 1PHYb8CD55N7pdKt0U9cuD63V8aLCiiDGVkPz9QH4/jqbjOpRxxd3sco59IASBQ4lJTxdxcq aFXskRh8TiQV8IH4mAGn40ilH2J85sDtLFLpRxifefA7iDQGOJ5R0bxpBwyvrla/rS/emGt0 5iiKKbioUCxhrEK89+vHYU4b5iE1DjNqou5FvJeG13GU+i8teybcDqTUDzbuuXA8klI/3rjn w/NQyjjkqLkfctw8QJCj5uTiPNRcdCHkqFlhp6GWRcezK+SoJXYvoc2DM+Sopf+Wsnlwhxy1 9l9eNw/+kKNW/P2z1ti9K9sF7+rnP2dMvFp8zqeqPOkDi6+rkhKMMKr2W1hPYvAy8RTM3zli wM3EU7CEzogDNxMvhgXu/Cce/Ew8Y0JQ5M7aLojCeUCQO+u6eESPWT8alyF3MeA5VqztgnDA B1fkLgY0R/eAB1/kzpioJwnCS5UYLcB/yIY7cmd8CBoPbW37fSs/3139YcFsN3/cb+7+Xm1u /vzjflKr2CU1h/WjLehhIitwDEJoLKa1jd2m3VgSLncm4yV3b8pjXnyuTsaMdqv4mBmvG1QM sePJ4qvsuF2koq1ftG6Xte14IvvM+936+mL132o68Nl6rj5HVwqNoyuEvZNZXgcnjJrx0yv1 X2OeZeEU8GwslG6Vf2bBK8rZeNDu5fzMg19oc4QLt4+5cIxnNjYympjW2i489GdiCWMowee8 KhxbUPk8JGGkEQX5rO1CC8wrltA4WIQSO8YSxlDBIqwDFnxjCY0J7t7RNg/OsYTGRUT9ttYW zBx+wLH9iJxHtXqk2rDfhGbQ05TRp4y+/bff9GMx9qPrIaRgCuAhC76HkGr3yrUfnQ8hCtQN yNiP3ocQBdygowCmBj9gGb03USgez0itH02NcyhMqBARjONZ237ngPuFiQisLnzAhP9Niagf FD/HFYmoPxD3LHcjYkJhcWvb/6rn6V4377u1zpNHDK71k1tv1NKULuFhD5EkdJ/HTzJw9Nga F/1O9CcuPF22xkb/BfGJDV+frTEC1hAZMeLstDVO4EJfkWL/Wto8zLqZrF+XxJLWT5TW9Wje zWSkGbbwKPbHgG0e/NxMkVJHbs8dA45uJuOg/53M5sHXzUSpH13dPDi7mShlNBAv0oJ0Bevb 2UC8SDl4BLRaP1RaXlrAx0RZ0BxB1rbfwF3f+gXiGQNgcbIBA46BeJFKP7awvnUNxDMe+qGF 9a1vIJ4xgSMLVBYgC4/3uItp9Sk+uALV0H5M9ZiRcvCIiuqQEEcXqC4IfXsSgpPy1H5/wzMD XspTa/fZ88yBn/KgxSHHPDgqjzJ+9mhHfulBkKBh8uu79R+rmduQZp8zSEudjmS9nnAWkSp8 DHHofzA/lIjT3YiDdG/EQ0a8rke8IAXFkBO/GxKHfiN7yIvjJYmDwpckpn5n8jCj1t16c3M3 mQ/OBhEXhxJTajmUGHAoMRXYocQnpIU8kIlPRrjIC1JlNLhxSgln7MTu86zBjltOOGMo+6xg P/1jRSPLI0t/hj1rAzigWFxe4Vo/KU+/up94rWHU8EPcyLE/ltnaePqiOPanXLM2rr4ojv3x ndbG2RfFsXSrlbXx9kVxCrgupf63Cc9m7nRYLCeXUk3WT85Td653X6oBDHNY6LAPuJhd5Lzg +dOTQJyiYznHbofQMwdesbGc+8HrZxb8ImM5g8XVx0w4xsVyIdixy4WXpNc3uojmgI+SWDqz 7xlNkl2Wv9rM8lfHNJqOxpmnyUT9NJx2vJUmb2VME+vROPM0WkI/Ta073pRavCkd0cRAfDQO QDOb7bFBEw/mlJpzOqbJx2tnnibn2Tkd01Ta8fZzk7efRzQlHMsAoJnVhQaN6I63qyZvV2Oa pEfjzNKkwrGfJu7X2y9N3n4Z05RjXQBoZnV7TFNpP6erJm+rMY0cz88sTU6B+2lon2H1usnb 9ZhGjmUA0MzuOw2agwyr6yZv6zFNOdaFeZqcI1wbZF+GfF+F5uoqhkUnZM5ae0a+dxq2kELD 3vyxWd9e/rU5tRi5jQhe419GdKhIboNmObUsinVSA1qRXJQHpDVg1ujRR7//1+bfqftBrj4R AbnGRrHkicqgRoEHAuRa0FKu1lbD2co8xaxwxlxry8vm7CkAZXLaNIrLtGmq42mTqWnTIvC0 aUXrqsUSzljj2nonNA+JtQVzMI1U7f7nS7t03fw5iSiXED2yJlg/uVF5Ml5wGc6eDIkKfAUv QdFaobEQpTPOHjHsFSgERoUfz94ffxqYavH8f01OHmUXvStUGnpHE3pXSGG9KxwqPHPM59Q7 FlzvGAQPx0fc5JRx9tE3rmN9C4MZ02F7ODVJLEJo0VBry+crQGm9w0VDrW3CEOfjCdvcryZn THye8hepDSULU0oWA65kkXAli3JOJYsRjtQu6CvWkZL9e3e5/mda06LPo4cSdWxLxglNSwGt mGVtmeFZS5LPOGspwYhmSWBE1vGsGRB7ufnNEiJOWpMlVZ9TLWlD4fSCecokyYTrXGbcoMwx nnH2csJNklyWmSTXf/91+ecflzNXuJLVZ/ZKGM9emlC7wvjEFcEnrqRzbpYl45tlAeOIjyfu zWaF3ASKS63BWCo17t7xgiZvApXxTbNGfNOs6ZybZi34plnB6OPGpjk5bRp89E2psVtO6JsK rm8acX3TfE59U7jMmbXVxfo2NWM1BBdFq4HHiqavz1gNcClPa5tgHashn1HHaqiwjtWgi1yt lYhQV2slzn0I86nlzG3I2Ll1zNQ0tx5zdKhpbv3UsK9pXqZqmltbLbCQmbhPyM+1xgfrThc6 ESpHrKL6y+i+rpPKqdOH4ec/qVx6x7aIiu2Od9oKZ8VCS0bDTq5yYZ9VLqL7VU7Tq1xShle5 lLBM2M/m3P1pQhcwlObV4SeFH0NxEX5k3gufox6I39rGYVupsPBjkgXC36Lqq/9OXO0RTBbV HHpa6BpchJ5ChFd84gALPQnmjx59uc+KT2CKwtHw0IpPhXyEX/Ne+HJ9KH1rK4O2OcBBYjVT 6RP+DtE+TepZOs2X/bhT4s7JZ4PJZb/BDJH0LdXYjM4Vt2NK6LRjBj7X08RewERskL83D7uW 6iL6kmQkepJhCowjiozv8KXGt/69u9ms32br/uUz7ZJxffX37eat5/HeMvz/3a0lYSy++1bW x68dznhl7Ki4//N68+/V3fpZkkcmWVpoktWEraGX0R0uHBWECF+GnL9wVE0uK0aJ4INJGV8r Gjun2PXCoaAh+DK684VDKxar9TK844VDQ+i5Tv+8uXdVLg2CSX43/OnapQGsDrcbc1a9NGSX s1BDPTgL86R6acDv80pd93n7ZFf9UpLeReaqYEqpx+y18T01jAq2tf39x8qCTi5XP//5cMkn x0Uq+vZzMKxHcKQyhZODI5U5HUOJpQ0l2ocOKcGQn9aHv7/arrop9FjZJ+ZHuZRmwFadcNMo 42E/KgEG/VXOGfajgof9qCQsnLc5e48tJ2dPfMJ/VFrhPxdHLjYakigM/2vEI4A08hnhf40R fraoEcww1J67X35dT05dLC6xyRqVx462OhEHpCnAtQc0McEzd9aIEu2IKFE0oqQ5czd//DM5 ccknob0m1fGOKVMTl/ESLJoZDuDSnOoZJy4rnF9GC5gttTlxf88edpVc0stozWE0dfWC0nDy eEhT4KQyWhXXOg1njARSJTgSSFXiEnepaoQv1qoZs/wHC8ThkoUWxBqMO3fRSiEED4w3WTf5 AMeQCYzX2gqK8VrbiN10Bp/9fNlabOzbsGBNzNawpxj7NnLlU41960TLsSJIWxHqkJDAvACt 737f5nT1++Zm9ftU+hEbQzwSDls/sZEz4fp6n34kvFa33GgzmvTH2oJ52qZl4pKGJAUGM6FM M+OTkMS4AYvbT3PjlZrE+JHlarvnxy1JiTEE24zWNi85vYyuoKdXCsJYOMRAQC/g0SkHWApo zurm0JNnmLgE/1g/h8E/YQostLaKCz1SF2B182Z1KlplY4KlB/ZjOkBVNmwsp59eMfOy0ysW LOpm/9Eo0GF9q8dtOYVE1Ad0GAmjmbKsbQyg4W5t0/kMd+s9oylxrW3lRVtf0gRrYQ5dW58t jpOtdhtUulfkrMmek4ezOoVBnACFSZM91w5Bg5kS9t98ur1eqOvgtzFdjPXCDttdieF48df2 4ufCQ8qEZWIbffX7v1xtri63kz9tqpfiAVdYP7VVOnGQSvqIQFGEMIUKJkqckELTONfhKC9w lhpHX998bI2FHlkaa0vdlUnSWW2pfYBTk/uxNT9mf+dQ1ZNmstawF0N+j4IkSpnT+iLZ+MTl cTLjkEYrLA4FCwVPiMPvOqFgtZcJZhzvEhpRGNPanrYzPEYZTW8N6rQ1aJXG1sCvbw2qsDVE 4bTV9CiG+b2BAid0b6AgsDIQWs99in1gc6CQk8fmQKGU3s2BgjIsDwpd6FRLHm55UI0bsCbf BDd++VCNHYG3B6K45F2R0SX41ktUupBbE48LzkCdcRo2LgIyEIfsYXUTk6IgA7EILG5eAJSH k3EG4twl7adhPaAGshV6su1NXHVRVEwi6duLnj4cjYqx7skjrsL6Ee6NijGiiHoKrW1Co2Ks bdbzAQ4kFY2ssLZgGcjB7MFgEcXgM3uRuRMsoghXsLK28DNma5vOOXex4HMX6ylzNx0VY72r z9Ql6ouKMQrGZy7BCR+sbTznzKWMZjSytmAR2MHMYVEx1nn1eIWeKAfqiopJhEfFWFvO8MRl OV8qKus94SqX8wkq9/fsYZddMhtZP0qdUTGJCpyTytoSmifT2p4xitB6FzQqxtomWmTsl4xb n6VgAeGDBXI6vk4FfPI7GHcWYqcaxMXYr5QOIHaagtipMvr8wNpKly/j6bNPRtmpgs9NB8N6 AO1U8+lAO9Wii/yKVPuulE/f3RcVQxpc/IukVJdGxZAKmjPY2kbpzN5tNCm+ZAkvgcdZwrf/ e0wzW9GgRVOpn0Z5n12dm9nVj2ns37PZ1cc0C0JmwpmiiTiAheUHzJwrmohD7AKtn7g5XzQR BzCZ44CfM0YTcYCTPVnbugji44AHtjBJWnAMeaB8TH3Q+NPQCNDHPqmErJ+SUaCPSdF8TYk5 YNFEq20j+3L7/JNhPmbC4hgOBvUA+Zjl9GhY5pgWnfvMaB3R/VfDGBFz8Xj3Zv3U1MCIskxc epjhp1OJheCIIj7nszfrHfdwsMRFwZSMpzuythnLP7JbHg65DGzUip3Zu1Hn0xlYpy7pDBLH UA8uPHnqwsMRzrNjbQV7dXHw0SdfdziC9sjBoB6XHY7ZYdOLZaQA6RXPRoxDytq/670YPXJh 2ZBvbNDVf5ObXwoubwA4UTOwaJhxhYYkDIcWcUKrjU+LwsdYT2A++BlmnIz1lDHkZYYbN2M9 ge+jZvjxM9aTwvGvnME4lRbzGVS5zB6vRq0fSa2AnSmVywlXOTSbd1MU3iqXwYy5TWbcVa6E 5RtAPoPKoQm5mvycQ+WKRFjlCvgcpcV8AVWuZJcYOS6lpXIypXKl4ipXA/ZWpCkKb5WrtNTo MmbcVa6Cz2ia3JxB5epik9T4OYfK1Qw/cONaFr3y4FojfFHQgKU6PhCQDyClC9YtAkepuDzQ Zo3xAI66kNfTzlpbPMyPtWAC39xdrdZ//WkZoTwTntn4FYt7241/egLzJAHcMXeDzqYwtz7J JcBQAh9cwXkSd5QQYdxRApjza/fNrknMbfyCQQC78X3TmBsD/SvNLetZEgqY+N/c350M9wqB lp0N5gHzCkk6GfEQisuSHghlTJvta2F4V8glu5L1U7UX3hUOjBp/woSWobS254xpEcZjWoSX xbQI4zEt1gPm3bJl4XCkMHjVtNHmzxIJLnCuCB2cJXX6LBGB4VwRMDutfezJMK4ImEXNBvOA b0XK6fCtSI3LAtNFFAPm9p/7/v2bm8m9LJILdCSRc+MeGyfusbZQ0DKf1hYMTxp+ucu1VWLG QPPh2D63VIkg9jkc3OtSKlF7FWw7vNsdVBLBkaySGIMX97zO1FO1LsUlYlxS4oZ2hCntSBkO GZcEJscYfrmPdiTtXqA2tpN25NC9PG1wN+3IjPlrh8P7aUeGk8VaW/Ax+gGvf5mcrif1I2eX 6G7JNXSioJLh9L5JSv8yefx2Hw0p/avkcXQnHSmy8OO9tKSAaYqPGfDTk5JxPSml28a6mtWT 4lJoNkkN2ukTl8r4hbEKBnQefrufntT+dXLlqCcVzOt7OLyrnlSwZu4hA756UhV2somG7rXy ZlZPlF28aqISOx3ZohH2qomC0cOH3+6nJ1q6F+obRz1R8F3O4fCeehID+Dz7kAFXPYkBTlxs bWURnBVDhOGsGDJWGcYk4gucx9ABpPkh5jFo2AtVcKHSrgSdzAqV6m6DM5hz9T5LEXl/Y7Lr xZBk0C/vHqBJC0NKCIYUmcqBAHBAPLLwIslxjLDkOJtpvv2CX7eC2662t7//8vPLRym9+9aP X9pEf/Txd/bXV999/dYnX3z16U/vvrV9Z/PuW62BzR6znv64ur3+Jb59Qa91YNv29599OiF2 TW9tbt7YPvDL5co2eiu19smWocuvvzVA+9tvvvzEcO9hB3nQgRAdlGi7mPnzXKKNHvuhYUcS Djra7kyXTzpztdncffB4RlExOvt7SJfkgO6tt7Yr5K1X/zwxIPooCR12VMKwo6s3f92uL7fQ 86sdxbztKB6JpOZBR9vz8/LJjfJqR0W2HZXh5MQw7OiXm/urn2/Xv0x+Wnn8tDLsiGnQ0c0f v63tn2/1dyRl0NH6YXX79y/ry1//Xt9vujr6v7nzbHqciAHwd34FbRg66tLCMAy99za0obeh 985vZ+ON4yh28q4TGsfd+fVJsiXbT2TtaqP099w2YrFnqNL27b1bZwOqu6/9+tMPriV25vGM jAZDlAxpfYk4UL35t83Fv/e5h1945O2XXnvu4bcfu/+Fh169/4WHb9/cZdt/uP+ll154+8XH X3/47VcefkFv334pYfu3B599+ZmX3n7s1bcffO7ltx987cGnHn6xoev2dkK3V8i334P4I0/d /+jb6WFLiaCBS7qO9Z+H50LbZHNNsgHwd0S4GjI/48GseiF/x4NZDZVIhlqEzzBUkP6OJ7wa or/lCa+GBP6OJ7waUvk7nvBqyOLveMKrofhbnvBqqJS/4wk3BOR/7gl//JkXX3rh5QdfevzZ Z9Y+4yWfJUt+xsvRZxxB+irca1MzhHyYXYMgwrkDfNWKx5RjIQxJFsZylqVuWbck3d4EzRBx nO+DcJChzWWpr2Z/YTSR7W+IJko5O5poemY03fujWfDar7/6/POb3/jtow/urY9Be+m897ln n3rq8Wfq07HZbcu7dXm3pN3PvvzSHzXDlc3DtTlVurYeqil/e0T720P1W9Ip09j4p/XJexPf hM2verWRhlhIFiY5/Fh897tfvnz/7fe/+ODtT9798oPPP/z27mvrD9e2QiTDxgZDNiKwm1/S +PDwK/WN7+3Hn33w7Yefuf+BpyqIYH4dSHmrVlapme+S/e8+/H6zuXn33tyFn37/9uarK7/9 8d3P7/3t+x/rP79/b0VW3fpyswk1hlWk/usPHy7/+x/tZWXhoIEdcWoX5tpvj396IxXdGpLN 5aHd5ZH5xWGkf/fmw3rz9d1kTKXfDbH/xg2bPUOTF7E5M/XdPJndo1J/HT4ykZQKxPKtMNyU 083QftzmXzyEhfcNEdpUyKxHd3+TXW+bTuPlN1m07ju1p54kDSEnSbaZ9/OW9395//MPv7v7 Wrj7WixmgFoqZsNcBTcb2/t1cJYjGRK0uaFlK3Vja0gHQ5oMKe6tQA1vEuGbbPT3eKse6RvW v/v+2x/e//7Tr75sPjOZCxRLJyntTs2GTPmIoZkVwTG3xsEQJkOuObeu/+GdAKgcxnpPftuY 1CJl0mOUN+JlI12ScMH9kx1s7j7OquUsGz67jFVh2+Br+7IMBvt2R3fvQYDqQtXCVmPPWsiy r1X/G2iwPRtJspQeofbydcvymTMFnBFJzgWV8dotR5KFpDeSLEWO3CIbtWla56ShZmfE0zSS 1p1m99SjfblJ/q8dLmDVJNhoEiRNF+yObuD/kM2lnhlKoVVsHpSs+MVsHgyVsD02M9LNj79J u+NzRbXqmwR8YucMWJN5QpVlPHOwFKiVbCECYMXNRsZzMkS8ZAjDIqIOMhAzUyBsNzKekyFG mvD83JukWOkrb/Lf5zMHnIK0KaMTwNbzBOlsSOQkpIURZPI8QzoZUqJDtFB9IpHRWSChJaml m2yM9YSWJOzUBelBNqAL0k02kl1CrCfuOoNK1iqqPZDeyDJQF6QH2XrUMyLJ6PsXYLx2y5Fk EuiNJDOUfkg3jYD18WRRypB2uBrSg6YSd0dXy3/0HnAC0gwtgdY1kG5KoXAppAdDhLyfQBNW GGFlEU3U+qbiSf6c/7zAqmSZSizzWSPUw7FumBRH3mxkPidDsshnAoUIK/V2EilstN3IfE6G FG3ic+Uuv/nRm0z6pl7qqgGfwnLxkNCdwwnL2ZCfMMSkjOw4OZyxnA1FOYQJDxmfB7DvwySp RXpFH0M8wSQJF9MOmAyyDFI6sMywkAVjUSkFZIaRrEXoHVjeypYeLDdZDjwjkiwpOOO1W44k q3h3JI2sG8tNw8+KZxCuzp2bZiHtja4A8P8Py3hGXaMpBcrFWN4YIpCEZZCWHzq9KbuzIPFv X57/vACrZBqjLHPZCzNRzVicHMJdNxuZy8kQOS5yWVw2fUcooAWMthuZy8kQC+9zWe2DNxns Tb/UU6GTWEauUa6mtg5vr8ZwgqLZUJRTWC5cYOfvApYnQ2pxCBMZcjyDYNyHSVKzsv9EjRGe YJKEg7AHJoNsAezBcpN1zq/g6I6Fj2MEG/ixB8vYMmDvAUeTdTsjkkyyrzZeu+VIMmN3JJl9 BZYHDZFz4qnIB1iWq7HcNL3rQ2+QNfsfZsvUShq8CstUAwRGF5ebmyG3vcUjH3uT2GsBFqYE 8sWKJr55/vMCqZLdMFxmcimmKrVgGlb/YsbNRmZyMlTEFpnMxFTPHTkEVK1tzErNkyEE3PvO x/vexApdkze/v9BRhNCTSDbywsra/E1IzueHLieQzIqgPrmbkZwMkc4KGHonBsAwBWIfJEmN ef+KjQGeQJKEBbpA0mQtepA8yKrkKrMzlDCbISRrGZQeJDfZ0oXkQdYtzolkrteP1+5IJAtE dySLcz+SNxoEwuvjSYh2gGS6GslNM6Q3ukT6L4+i9yCZByTjugLGoKSsFyN5MGS5gPGm3byX OLLzU28yy5s627XIqmTZ+UiijARQD1vg2hJM7OB1I49XJ0OBvpwog5c6EoLoLuy23chQzoYi 9hLlL3/aQPfNH/8eb4ueJnNRMiKM5nMiczpJArITZBYLC558zmROhhD4kCdWH0OI4oCceJLU UlV3jPLEkyRMSj08GWSZupLlJlvyO7dxOMX8nTtrifWM/zVZ5Z7iZ5M1oHMiaWXf4fHaHYmk W38kg6KfzE2jlDPiWVzWk5nba0t3dBkR/n9klkZmW0XmQUn58hqGNDLjPplroZVJ3nkTd2dw Z80psf6u0F7YtQCsZN4ZjuBZQI0NtFKG2GWoQWTOJEMBdqS+DIg6mAPWcSPjORtymfB865PV ZXnz27/H2SInB/6IPIjYo7m8ddYHZ33fEAGcLGUYoMHk8vGoEYQcMsUHpngYpuGqpIbpTWcM 8sSUJEzcM1y1lS3WQ+dBlg9mExgoC/uMJllLuGfgr8kq9Mwf2MpanBNJS+nJeO2ORNJXRNLL ilLGoBHmZ8SzCKyn80aToWvuy1bW5f9HZx3obOvy5kFJo1xM58GQg+/RGepQGDFML/g/fvgm TTXY6ecFUGWz5dikOYOiRSKqX0YSjLBA5clQFFyuZBSNTQLJ4VLNbDcylZOhYpKryzUpbtMt 0C/0loD5JJYNGKLKNZ+Xsawp111OmsOqmcnn42EjjFmqFxuYFFfysg+TpEYJy2OUJ5gkYWbr gckgK6A9WG6ynqdrqQcCxwwjWUulq5wxyBqWHnA02QLnRNLTwN947Y5EMrhn0lyTLUD9WG4a LuvjySDlAMt4NZYHTcQuLDfZ8P8flq0lzesG/gYl5csrzDYvZ7DzQCvefJ/M3vAX16wRXq+p 9NK+BWilQ7gcS5wDuR6tDKkuGmL4AqInQ4FHis0eCFWVC1L4uJERnQ1FQnStqpPzd28S/l0u Fz2dPhfyUsPizfEZp3eGCDBOcjqK6OT48dgRlNn4VWmv5KCS6JLU0HVPbQz1RJckTNJFl0GW sau40WSDM1fUWWw+zytriVIPpwdZ7eN0k42zImlp9Hq8dkci6dIzA7HJxop5c1sNL2fEsyit 5/RGk6E/ugzx/5vczK0lhn0Vp5tSXF52HgzJ/jfWf1znK3AtsX401V2NawZZ3/C/X9i1QKts 244AmgAdhpUaUKVuGOIM0MlQ0DKgzRxgk08GCsl2IwM6GVLQCdCPf/JBfVf4e1xVstNdJ8ri AtgczmDOhvTkzDkppcjk8ImY6WxiAW6eQuAgINrHSVKzVEQaQzzhJAv3pX1N1qQHzIOsQ3qj Hm+SOUiyFlkPmJusdKV4TdbKOZH0XHXeXrsjkQzsqjo3WV6RQDcNlTPiGe7rwdw0++YlDrIF 498F8yVdtdtTFpu6aueklizs3NEtuumqhdRVm40UXdPnClf0ucKJPtfdQQkojrbyPvT4i7um 3Jne1Mu7Tq8rUtu+2q/z5JFsqEhHQ2qTRfyPJm7q8bxAfFsX7endbsKu0BG7ee92MhJG63q3 m1pRXNe7PagxEK65py/t3d4etPT0uC/3bidDaP9RPrmIp3RqpD23f5Plf5u+HWmxRJvhuCot bkpsF1eVmyGxvQVYX64jYPj0NAT2+Zukm1oGv/n9bNdiqphMqx7LiokxnGpmjyYsjBILWfFk yIiXsuKqRqVATVIYQNm3GzkrToZ8f47cXZtCTZ0Gp3+Ptx6nE2P1IA0uzeecGCdDoSenY3gI x+TzibAVPmyEIKxZEDkZaGqE2FeTPFYzRnlK57Kw90zvarIoPYlxkyXUlJJJEaBYmNiVtaJn wK/JsvYM+DVZwXJOJCUVpMdrdySSqj01+iZr1J8YNw0HOyOeHoctJVd3+jXN6HrtaLIF9f+H 5m33paxC86DExhejuTQ0U2opqSAye5Nq8RR30w+efvX7WmdOP8w5layq2BEqC4c6UKm3sXIx C12g8mTIaLlWYVa8xg0RlJV9u7FM5dKoXPaKyQT6w0O1nHy+hx7lJIkL8DDe3/zMJE6GwuBk c5+Z0eTniVAV9kN+0MAPBofI/JjUBFK5fozsxI8sHF0kHmRRe6ZeNFmiZBeHakiBGTmyFkNP F8lW1nqqm01Wzouk4v6VHK/dkUiql+5ImvZPWW4aflY8A3g9iZumd33ODbKFy/+OxAqNxKu6 SJoSG15K4mZIdC9J9mcrnaTORcjjWsh315m9810LtEq2VfAIj41LKbQZ0ovgMJrXjpMhOzK4 h0KkUSNUoijZdiPzOBlywonHn94nNf/9e1z1cnJQT4hCRUGbwxnMyVBoOZUiFwKQyeETMSus hzjhltgVxVTx3FcTSEXMMcQTTrJw9PSSNFmUnl6SJksEGSRSkGRhDlfWiugAc5Nl7ekLbrJC dE4kpeyrjdfuSCRVez7imqxR/4pFTcMRz4inh60Gc9MM7Zmx3GQL/g/BjGdUL5oS++VgHgyJ pxSZ9Yd6CjSdBSsOY1vMWPG0sPcktLBVMY7ly6EMwVj5XCKYkcoCnydDxr5YxWAowJsqhogV jO1G5nMy5Lw/+cIrnumG6svf6XSAnCS1KjMwYnM9kzobcj9ZzNAAm1w/Eb0yW1uOZOCLFIvU PryvJpCm+YzBnviShBF75txuZb1nfYwmS8qZLATEC11qWYupp5ixlS09fWlNtv5/TiQ13b7j tTsSSYOe9TG2stFfzGgaruWMeAZrJrWWq0k9aBbo+hxssv/D2ctKrVq+qpihrf338mlyW0MB +9PkoNUzSGrFeTyHJ2qxFTb/9O18zwKwknlEWqY0oxZ0LVRJW7z+X6NAmTPZ0GIPIYNBIdd6 Z0SY0biRKZ0N2d4aGS9U9Ppm8SL7W5wNP0VnBcF6jmTN5UznZIiQjhqSCNaCey6fiBrxrEC6 7SRWcElMSWqprWMM8sSULFy66DzIMvZMYt7KCh68kIuXWFjWIWtZzxyMrWz0FDiabJU+J5KS LsD22h2LpFjP5LitbPT3ljQNJTojngeTwulOvrq3ZKvpXXl0ky3/v0nMyi2PXtVb0pTYLl5U rhkSKWlROakc+irNGUOvv7VS2yufFvYuUisdQ+kYoslAfDOlmMgBOFRniE6GypIhBGSg+k9O IQg4/r1F9OA1Z68t9ibJ3TAsRl0/k/zvdNrVTqKaQJQLcXM9ozoZCoqjhtAo3IpPrufx/GSo wKzkYfW5JCuhniqoWS321cZgzwHDQ9atPdPlmix2NWlvZcsBWjDcZV47zVpkPfOYmywz9MCk yZZyRiRFfP8Q47U7EknlrpIHt6R7RcmjaUQ5I56eP/rgzugoeQyawV2vKdyS7v/f8hkq59Si ByW2i5u0myHZ/xr1z58d2rRJxsP/VnNqruCmOka4tG+BV8m6Kh+BtChTUbSqoUDu4AuQngyZ xeIS+hRoTLXCC8Sh40bOo5OhoL3RwQeGnkeuIfi7HC4OJwGtVMwIobk9A/TOkCDgqcFCJAqf 3D4eOcE5Vrw+jVRCcHH9SpX53Icx0BNWkjB3TTZossJdlY5BVkkOaqjIXOarPmQtg66a9CDb t75Rk/WgcyIZiW/jtTsSySI9a6oOsgpratKDBsIZ8VSMWF+THjTJuqOr/8dvOFFtgMZVgNa/ adqG6gzQdS1iqtmi7E0z++RNMv+6ZpuzHQusSpYNjy2gb2rFN7MRSAuIEs2KHMmQFz7SZhJY ryoKoCv6diPDORkqgmnqBtaPopodi715/cXuCjifRHOoCipoczqjORlC8VNodqWik9PH4yY0 n30Q9TlkoEKSluVJapz6NcYwT0BJwtJXOm2y0TVcOMiqHxShuaDAvDUia5n3LNLcZD2oBx7a GKvnRDK3hY7XbjmSCl1LaDRZXNEDuNUouD6eSu7r0TxosvbMqGuywv+/yc5qA5p5Va92U2K9 eLJzMySG6QtObFi2WKbZZkNZWh+qf852LNAq2VY/ljmHYRQAq9kHFVCDWXkjGbJCy4vPFWQZ WuIMOHC7keGcDLnLPpy9+mk1eSa78XJvQ/Hk95pg1PN1kuZzZnMyVNBOsRmCsEw+nwhbiTgk ShmGtYIpFomyURNI72VjlCeiJGHs6ipuskTUw+ZBlkEPWGIsSnOWZK3oKkEPsmJdQ1iDrIqe E0kj31Mbr92RSDp11TUG2TX92VuNAmfEs7isZ/NGU6FvKscgi/z/W6lZvX3p2LoBQv+76hqD ISm6X4Kuw2VYPyvf5Okc2Pz+ml9upkAv7VtAVjqAHltGX0A8GBjrfW4IoTwDdDLkizUSDC0C VFWZgArDdiMDOhkK8f1VNMDer3/4TX+Xw0Xi9HdPgQEKSnN7mdE+MJJOLkGnaAUmt49HTnA2 SYw3DyQVFPQ09SCp5WHKMdATWZJw5zDhIMsOPYweZEUOaqUBKjSfdJC1lHrWOmqy1rVI2la2 8DmRdN8/xHjtjkQy+qbbDbKF+xcIHTQU8Ix4KoKsbtXeakYXowdZsn95gdBLWrXbKbOWnlbt JixkHc2h81btbKSsamu9tFW7HVQdV7ZqNz1TWtmq3fScetqNl1u1s6Gwjl7VJhv/1Zc5HG3V jruh4Qzk6lbtUdixp8193qqdjATjmlbtUa0ArWnV3qkZr7mnL2vV3h5UgXvitNyqnQ2V/2iW 8CKe0qlh0JW3/yhL8h+tVGAnbv8YvPAVI3+jEpcLM+TRkJOnSRpWi8qv7DVnfP3+r3U0MP+0 mCNONg1YjyTFpOAENTtkBEBwtms5p3bJEGosVi0oogyrfxYgAtxu5KQ4GSIqKSmWOiPD6/uA 3XyJn3xFvSIYAs2ieZtz4WRI6OSE5gBSmbw9ETCZDfMJ1sRHqbBb+ornpKZp6vwY3ymDS8LW se7nKOt8db1ilA04eL92I8GF3C1rdSyWP8qWju9h3ckWOiOSDqmqOF675Ug6dnyj7U62e8rc qEGK6+PpjGVlvWKn2ZELj7Ii/7dacj2zMnzcrakl75QubT3ZGSp5sXyQb2ttdXcCDNtui1p1 5eW9C8xKR0DwI2wWtkLolcjMJE46Y3M2RLj8fdkEuBkzZGJTgu1GZnM2tN958vx3m8G+W/9W j09XLBzV0BG0+Z0pnQ3ZyckYrMI++X0qdLMvExWqjySXCCqJLUmN0tK/Y6QntmRhvPo9eyfb R+kmKwerM6O4wUIVNGsZ91C6yfrV0wV2soXOiSSnh2C8dkciyR3fpLiTZe2ndNNQOCOebLqy YrHTjKvnIu5ky/+t7STuRthe9zWUbkqmfimlm6HwtDqz0Jtv1lwS99rlAKTuhz8qzBZ2LRJr sm+ItszoVs/brOfJwl7YccboZIhMF/PngsZDi5wOFrcbmdHJkADtj/pRHeNU2vx9+9/jsQqd ZLQEhBeN5ndmdDLkJCdbAyGUJ79PhC5sxmje5H+mRJrWE05qufd7jHQiy07YAa+e5jXKongH o5vsrDWwiOvCSFXWYrm6NXCUFe+hSJNVgTMi6XnlgfHaHYmkw9Vzw3eyDt2MbhohdEY8C66t Ku80uxg9yAbI/635pJ4Z1jNT8BUjf6MSXtoauDMUNjG68pkJB2bxjkXbxY/o+VrxWNq3wKx0 BKJjmXQoKsLmvV/dCgH7jNLJkMnyN0/JsKo5cpRgwu3GMqWxpTWQqhy1JZtq9evvcphZT0I6 wICQrbmdIZ0NOZ2c1SzoMbl9InKCM0hLfSKFUMRT+pfVEh/HQE9oycJx9cI9o6zS1R2CO1k7 hApw8MIs3KxVrp7VPMoaX71Iz07W9ZxI5mr8eO2ORNKl55VkKxvYD+lBI7CcEc/QWA/ppll6 yh1NttD/r9yB1IrPK1baGJRM2OPicsdgSKDw3jqh173pe73Mvw4zfsmk/l7at0CrZJtLLONZ gT3Ya2rMAUWFWBbwPBlS9+VCB5OV4YXfCHcbGc/JkHOkphPlH+Hv8jbsZAIdyBAsGs3nzOZk qLCeLEUjE00+Hw+bAsohUTY9x/X4rnkyblYLz0UOptTIloSxoyVwlCXsSqCbbDl4KScOtDJj SdZi7UqgB1mhq5vWdrIR50RSU3DGa3ckkoY9Rf2tbOmdOjdquPEZ8QyG9WzeaPayeZAt+n/r OKlnxtt0bhWbByXjC7u3R0OF9rq3b6b6Ek87Otdf5FgzTPq8biztW+TVZN1I6AidkYsYai1x FAZgB12g82RIgJf7to04vMYIpIjjdiPTORsKT10n9EL9A3HX/vfH99WtvZ86nNSCJ6HMoBqh sHFV5+ODkyE7sfgourhyoeqhqm2G/U9Ey332Lm71CayKoprSvKSWJ2aPwZ1QkoQLdkG5yXYs eLSVdRA7qJSiKs2XUstaiD2V562s94wPNlkSOyOSzul0xmu3HEnnjnWwR1mR3gWPRg2FchBP VkC4Ip4acNCnHVdDedC0jrWxR1mnf3muXA+UpY2rlFVQHpSELq88y3am2n7lmWXTlWxpeQng SiajurG0bwFZ6QDOfoTLLKiAEHVmsxaPqHGQTJpkKGK5qEHARa2GqbgiStuYZc2TIQPc6wZ8 r/rs7/Df5K1BxElAG5Yw063PGdDJEJ5aOxSFPGrgkMRCZ33ayRAxH2LFN1gBUrE0BTepcXqW xyhPWMnC3jPtoMkKX72o8yirgBkowEZLZdKsZV1Z8yBr1DM02GQd5ZxI5qU3x2t3JJKhV08L H2UL9vZp7zQC1sfTQWHlinSjJmLXO0mTjf8hoPWcisagxHB5RWMwJMb7gDb5sL7nXzedAEEM i2vO9yywKlnWwCNkVgUFqbwVLAW4bi+QeTLkUJYHBQHYN+XmMnBqu5HJnAzF/qDg438+r3+H m2GnkVxEmbFwczYjORk6XcjQKsE6OXs8XgYwe/2OTWk0ANHTIsRJDdOL2BjeCSRJmDp6AEdZ 7ugB3MkWPyiKFlOdL5uWtcSvXmd/lFXpetUeZA39nEjmesN47Y5E0v3qrwIcZUNWIHnQKHhO PEs5/MYTuRrJG00H60LyIIv8f/vGk3pm1ui6brbGoGROFyN5MFQcD3oAWeiZcS2J+ouQ6q6a OLJWQC3vXubWdBQDtyN4dtWiWLCeFxdH5ljA82QILY6MBoq3r6Y2D5btRsZzMkRlr9z8KD/o f6/D7CfXCy3kqFCwbNxeyJ0nQyKnQG3oTja5fSJySrNX8rLJ+BjDKWV8SS0vgDIGesJLEvaO 1Zx3stFV3Bhkw/EALCZK8y/pz1pFoQfUG1kHsh6UDLIIckYkHWNfbbx2y5F00quXJBllmVeM Bg4aArE+ni4R60E9aKpdvUzJKGv8P5yy4dVXZluxxtGoZOXChTRGQ4X3QH3fproB46IS9Tav P1c00WzHIqcmq0JWlsFs4BgYtewrClw4YgbmZIhlqTTCqGFWrN5KQqQK240M5mRIiPcqzd9u Kuu33n25owp8Esiu4aSkzd0M5GzI+cQCzk5osOfuiYiZHk7PUNgMXAkX05TvJTVPT/sY4Akj Wbh01UgH2ej4Eu1RtjAdvHwjI82HrJKWAnQBucl2LIs2yiLrGZFUSrfEeO2WI6lk3ZFU7v4S 7Z1GKWfEUxzyAs7SMQQ4aCpfvTbJKGv/9qqg53dmj6fsAFd3Zu+Eredre+ed2clIMKzpYr2s M3t30CKrOrNHvWK6qjN7q2dA0RGp5c7sZKjnS7RHWdT/6MWNT+QD5U5ylnF+Dk9OTL8I4M1V vzbx2t2i9a90LOMjof/u04+/fPfzKfqbn7/afuroEE1Nhlx7ruH8bk9GgvTvzUWa1SIX5yKD oWKwZKj+aj7hcHRMRxf42/OOZjbk4rxjMIQKy4Ym1zLtJ1Xicu37n3/13Yc3l91n1vTZlWUZ dSsbV8oK19vg+80t+PW3X73/xbvffXbzi48/+vbLzzzw1LMPPnn7tW88/sxL197/wAv1j6de ePraBx976qG3Gstuv7Zan5krvj00X3loVdzK2pWytnNJr5YtcUL2Drz24Qfuf+iRa29+4N0P rv3o088/vPaDD797/9tPv/7+q28THMSVt4bkyoNuRgs/+u77d7+/GSugvvv+7S+++uDDe198 +/FHHnzshd/BqH4c1L3ffvDhj/d+8e5nH9a/b0a2DaNvv7beMX/MYxkx+oxXHV4h+NoPf66f QR9/+9UPX98MtyTZ+/ZlbVNyu+222wb5Dz+49qdPv/+k3nt1zzV/AVBLAQI/ABQAAAAAAAli OUsAAAAAAAAAAAAAAAAQACQAAAAAAAAAEAAAAAAAAABwYXVzZV9yZXN1bWVfZmQvCgAgAAAA AAABABgAYN3r8N410wFg3evw3jXTAWcy4H9+M9MBUEsBAj8AFAAAAAgAdlw2SydxkoAVCAAA ARwAAB4AJAAAAAAAAAAgAAAALgAAAHBhdXNlX3Jlc3VtZV9mZC9tYXRyaXgubG9nLnR4dAoA IAAAAAAAAQAYALpqjMd9M9MBkRyMx30z0wHZG4LHfTPTAVBLAQI/ABQAAAAIAFNcNksNX6Z9 ggYAABQYAAAeACQAAAAAAAAAIAAAAH8IAABwYXVzZV9yZXN1bWVfZmQvbWF0cml4LnQuMjM5 MDgKACAAAAAAAAEAGAAAo3egfTPTAQC+QBt+M9MBvG/BK34z0wFQSwECPwAUAAAACABQXDZL eWpO12RHAADrPQIAHgAkAAAAAAAAACAAAAA9DwAAcGF1c2VfcmVzdW1lX2ZkL21hdHJpeC50 LjIzOTA5CgAgAAAAAAABABgAgIVLnH0z0wGA22wffjPTAb3OxCt+M9MBUEsBAj8AFAAAAAgA UFw2SwIss8gCCQAASyoAAB4AJAAAAAAAAAAgAAAA3VYAAHBhdXNlX3Jlc3VtZV9mZC9tYXRy aXgudC4yMzkxMAoAIAAAAAAAAQAYAICFS5x9M9MBALlN130z0wGmVt0rfjPTAVBLAQI/ABQA AAAIAE9cNku842JheQIAAAoGAAAeACQAAAAAAAAAIAAAABtgAABwYXVzZV9yZXN1bWVfZmQv bWF0cml4LnQuMjM5MTEKACAAAAAAAAEAGAAA77KbfTPTAQBA4dp9M9MBp5/1K34z0wFQSwEC PwAUAAAACABQXDZLuiadd5EAAADOAAAAHgAkAAAAAAAAACAAAADQYgAAcGF1c2VfcmVzdW1l X2ZkL21hdHJpeC50LjIzOTEyCgAgAAAAAAABABgAgIVLnH0z0wEAbRLcfTPTAcrT+Ct+M9MB UEsBAj8AFAAAAAgAUFw2S48sClSTAAAAzgAAAB4AJAAAAAAAAAAgAAAAnWMAAHBhdXNlX3Jl c3VtZV9mZC9tYXRyaXgudC4yMzkxMwoAIAAAAAAAAQAYAICFS5x9M9MBgAOr3H0z0wEB5Psr fjPTAVBLAQI/ABQAAAAIAE9cNkt6ju9tkQAAAM4AAAAeACQAAAAAAAAAIAAAAGxkAABwYXVz ZV9yZXN1bWVfZmQvbWF0cml4LnQuMjM5MTQKACAAAAAAAAEAGAAA77KbfTPTAQAAlo59M9MB +oX/K34z0wFQSwECPwAUAAAACABQXDZLQ33EdJEAAADOAAAAHgAkAAAAAAAAACAAAAA5ZQAA cGF1c2VfcmVzdW1lX2ZkL21hdHJpeC50LjIzOTE1CgAgAAAAAAABABgAgIVLnH0z0wEAAJaO fTPTAXEgAix+M9MBUEsBAj8AFAAAAAgAUFw2S9Tr6MSPAAAAzgAAAB4AJAAAAAAAAAAgAAAA BmYAAHBhdXNlX3Jlc3VtZV9mZC9tYXRyaXgudC4yMzkxNgoAIAAAAAAAAQAYAICFS5x9M9MB AACWjn0z0wH+uAQsfjPTAVBLAQI/ABQAAAAIAFBcNkvO/0XLkAAAAM4AAAAeACQAAAAAAAAA IAAAANFmAABwYXVzZV9yZXN1bWVfZmQvbWF0cml4LnQuMjM5MTcKACAAAAAAAAEAGACAhUuc fTPTAQAAlo59M9MBfOwHLH4z0wFQSwECPwAUAAAACABQXDZL/3sygJAAAADOAAAAHgAkAAAA AAAAACAAAACdZwAAcGF1c2VfcmVzdW1lX2ZkL21hdHJpeC50LjIzOTE4CgAgAAAAAAABABgA gIVLnH0z0wEAAJaOfTPTAcLVCix+M9MBUEsBAj8AFAAAAAgAdlg2S9+LX2smAwAAawgAAB4A JAAAAAAAAAAgAAAAaWgAAHBhdXNlX3Jlc3VtZV9mZC9wYXVzZV90ZXN0LmNwcAoAIAAAAAAA AQAYAACwZU95M9MBACUYYH0z0wE25g5HfjPTAVBLAQI/ABQAAAAIALBbNks0tzHaDQsAAFgw AAAbACQAAAAAAAAAIAAAAMtrAABwYXVzZV9yZXN1bWVfZmQvdG9wLmxvZy50eHQKACAAAAAA AAEAGAA1kYjpfDPTAS9DiOl8M9MBVX1+6Xwz0wFQSwECPwAUAAAACACOWzZLve4dE+kGAACt GwAAGwAkAAAAAAAAACAAAAARdwAAcGF1c2VfcmVzdW1lX2ZkL3RvcC50LjIzNzY2CgAgAAAA AAABABgAgIdVw3wz0wEAu1f+fDPTAfuE4id9M9MBUEsBAj8AFAAAAAgAils2S4zfX6viVAAA qqICABsAJAAAAAAAAAAgAAAAM34AAHBhdXNlX3Jlc3VtZV9mZC90b3AudC4yMzc2NwoAIAAA AAAAAQAYAIDTkL58M9MBAELrAX0z0wFVfeYnfTPTAVBLBQYAAAAAEQARAFkHAABO0wAAAAA= --------------B9E611723D3D0896E6F5D838 Content-Type: text/plain; charset=UTF-8; name="pause_test.cpp" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="pause_test.cpp" I2RlZmluZSBfREVCVUcKI2luY2x1ZGUgPGFzc2VydC5oPgojaW5jbHVkZSA8c3lzL3NpZ25h bGZkLmg+CiNpbmNsdWRlIDxzaWduYWwuaD4KI2luY2x1ZGUgPHVuaXN0ZC5oPgojaW5jbHVk ZSA8c3RkbGliLmg+CiNpbmNsdWRlIDxzdGRpby5oPgojaW5jbHVkZSA8c3lzL3R5cGVzLmg+ CiNpbmNsdWRlIDxzeXMvd2FpdC5oPgojaW5jbHVkZSA8cG9sbC5oPgojaW5jbHVkZSA8c3lz L3RpbWVyZmQuaD4KI2luY2x1ZGUgPGZjbnRsLmg+ICAgICAgICAgICAgICAvKiBPYnRhaW4g T18qIGNvbnN0YW50IGRlZmluaXRpb25zICovCiNpbmNsdWRlIDx2ZWN0b3I+CiNpbmNsdWRl IDxzdGRpby5oPgojaW5jbHVkZSA8c3RkbGliLmg+CiNpbmNsdWRlIDxzdHJpbmcuaD4KCmlu dAptYWluKGludCBhcmdjLCBjaGFyICphcmd2W10pCnsKCWludCB3cl9mZHNbMl0gPSB7IC0x LCAtMSB9OwoJaW50IHJkX2Zkc1syXSA9IHsgLTEsIC0xIH07CglpbnQgc3RhdHVzOwoKCWlu dAoJcmVzID0gcGlwZShyZF9mZHMpOwoJYXNzZXJ0KHJlcyAhPSAtMSk7CgoJcmVzID0gcGlw ZSh3cl9mZHMpOwoJYXNzZXJ0KHJlcyAhPSAtMSk7CgoJZmNudGwod3JfZmRzWzBdLCBGX1NF VFBJUEVfU1osIHNpemVvZihpbnQpKTsKCWZjbnRsKHdyX2Zkc1sxXSwgRl9TRVRQSVBFX1Na LCBzaXplb2YoaW50KSk7CglmY250bChyZF9mZHNbMF0sIEZfU0VUUElQRV9TWiwgc2l6ZW9m KGludCkpOwoJZmNudGwocmRfZmRzWzFdLCBGX1NFVFBJUEVfU1osIHNpemVvZihpbnQpKTsK CglpbnQgY291bnQgPSBhdG9pKGFyZ3ZbMV0pOwoJaW50IGRlbGF5ID0gYXRvaShhcmd2WzJd KTsKCglwaWRfdCBwcGlkID0gZm9yaygpOwoJaWYgKHBwaWQpIHsKCgkJc2lnc2V0X3QgbWFz azsKCgkJc2lnZmlsbHNldCgmbWFzayk7CgkJc2lncHJvY21hc2soU0lHX0JMT0NLLCAmbWFz aywgTlVMTCk7CgoJCWNsb3NlKHdyX2Zkc1swXSk7CgkJY2xvc2UocmRfZmRzWzFdKTsKCgkJ ZnByaW50ZihzdGRlcnIsICIlczogU1RBUlRFRFxuIiwgX19GVU5DVElPTl9fKTsKCgkJd2hp bGUgKC0tY291bnQpIHsKCgkJCWlmICh3YWl0cGlkKHBwaWQsICZzdGF0dXMsIFdOT0hBTkcp KSBicmVhazsKCgkJCWludCBjbWQgPSBjb3VudCAlIDI7CgoJCQlpZiAod3JpdGUod3JfZmRz WzFdLCAmY21kLCBzaXplb2YoY21kKSkgPCAwKSBicmVhazsKCQkJcHJpbnRmKCIlczogc2Vu dCAlZFxuIiwgX19GVU5DVElPTl9fLCBjbWQpOwoKCQkJaWYgKHJlYWQocmRfZmRzWzBdLCAm Y21kLCBzaXplb2YoY21kKSkgPCAwKSBicmVhazsKCQkJcHJpbnRmKCIlczogYWNrICVkXG4i LCBfX0ZVTkNUSU9OX18sIGNtZCk7CgoJCQl1c2xlZXAoZGVsYXkgKiAxMDAwKTsKCQl9CgoJ CWZwcmludGYoc3RkZXJyLCAiJXM6IEZJTklTSEVEXG4iLCBfX0ZVTkNUSU9OX18pOwoKCQl3 YWl0KCZzdGF0dXMpOwoKCQlyZXR1cm4gMDsKCgl9IGVsc2UgewoKCQkvLwoJCS8vIHRlc3Qg MTAgMTAwMCBwZXJmIHN0YXQgLWNtZC1mZCAxIC0tY21kLWFjay1mZCAyIC12dnYgLi4uLgoK CQkvLyB3cl9mZHNbMF0gPT0gY21kLWZkCgkJY2xvc2Uod3JfZmRzWzFdKTsKCQkvLyByZF9m ZHNbMV0gPT0gY21kLWFjay1mZAoJCWNsb3NlKHJkX2Zkc1swXSk7CgoJCXN0ZDo6dmVjdG9y PGNoYXIqPiBuZXdfYXJndjsKCQluZXdfYXJndi5wdXNoX2JhY2soYXJndlszXSk7IC8vIHBl cmZzdGF0CgkJbmV3X2FyZ3YucHVzaF9iYWNrKGFyZ3ZbNF0pOyAvLyBzdGF0CgoJCXN0ZDo6 dmVjdG9yPGNoYXI+IGJ1ZmYoNjQsICdcMCcpOwoJCW5ld19hcmd2LnB1c2hfYmFjaygiLS1j bWQtZmQiKTsKCQlzbnByaW50ZigmYnVmZlswXSwgNjQsICIlZCIsIHdyX2Zkc1swXSk7CgkJ bmV3X2FyZ3YucHVzaF9iYWNrKCZidWZmWzBdKTsKCgkJc3RkOjp2ZWN0b3I8Y2hhcj4gYnVm ZjIoNjQsICdcMCcpOwoJCW5ld19hcmd2LnB1c2hfYmFjaygiLS1jbWQtYWNrLWZkIik7CgkJ c25wcmludGYoJmJ1ZmYyWzBdLCA2NCwgIiVkIiwgcmRfZmRzWzFdKTsKCQluZXdfYXJndi5w dXNoX2JhY2soJmJ1ZmYyWzBdKTsKCgkJaW50IGkgPSA1OwoJCWZvciAoOyBhcmd2W2ldOyBp KyspCgkJCW5ld19hcmd2LnB1c2hfYmFjayhhcmd2W2ldKTsKCgkJbmV3X2FyZ3YucHVzaF9i YWNrKE5VTEwpOwoKCQlleGVjdihhcmd2WzNdLCAmbmV3X2FyZ3ZbMF0pOwoJfQp9Cg== --------------B9E611723D3D0896E6F5D838--