From mboxrd@z Thu Jan 1 00:00:00 1970 From: kbuild test robot Subject: Re: [PATCH v3 5/5] media: platform: Add jpeg dec/enc feature Date: Tue, 24 Sep 2019 18:11:37 +0800 Message-ID: <201909241810.hNjUJoEs%lkp@intel.com> References: <20190924074303.22713-6-xia.jiang@mediatek.com> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="u7wedkesix5licz2" Return-path: Content-Disposition: inline In-Reply-To: <20190924074303.22713-6-xia.jiang@mediatek.com> Sender: linux-kernel-owner@vger.kernel.org Cc: kbuild-all@01.org, Hans Verkuil , Mauro Carvalho Chehab , Rob Herring , Matthias Brugger , Rick Chang , linux-media@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mediatek@lists.infradead.org, Marek Szyprowski , Tomasz Figa , srv_heupstream@mediatek.com, Xia Jiang List-Id: devicetree@vger.kernel.org --u7wedkesix5licz2 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Xia, Thank you for the patch! Perhaps something to improve: [auto build test WARNING on linuxtv-media/master] [cannot apply to v5.3 next-20190920] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982] url: https://github.com/0day-ci/linux/commits/Xia-Jiang/Add-support-for-mt2701-JPEG-ENC-support/20190924-161234 base: git://linuxtv.org/media_tree.git master config: sparc64-allmodconfig (attached as .config) compiler: sparc64-linux-gcc (GCC) 7.4.0 reproduce: wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree GCC_VERSION=7.4.0 make.cross ARCH=sparc64 If you fix the issue, kindly add following tag Reported-by: kbuild test robot All warnings (new ones prefixed by >>): drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c: In function 'mtk_jpeg_querycap': >> drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c:139:2: warning: this 'else' clause does not guard... [-Wmisleading-indentation] else ^~~~ drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c:141:3: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'else' snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", ^~~~~~~~ In file included from include/linux/clk.h:13:0, from drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c:9: drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c: In function 'mtk_jpeg_try_fmt_mplane': include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ >> drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ >> drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:829:48: note: in definition of macro '__is_constexpr' (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) ^ >> include/linux/kernel.h:835:25: note: in expansion of macro '__no_side_effects' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ >> drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:837:27: note: in definition of macro '__cmp' #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) ^ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ >> drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:837:40: note: in definition of macro '__cmp' #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) ^ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ >> drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:840:10: note: in definition of macro '__cmp_once' typeof(x) unique_x = (x); \ ^ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ >> drivers/media//platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:840:25: note: in definition of macro '__cmp_once' typeof(x) unique_x = (x); \ ^ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ -- drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c: In function 'mtk_jpeg_querycap': drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:139:2: warning: this 'else' clause does not guard... [-Wmisleading-indentation] else ^~~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:141:3: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'else' snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s", ^~~~~~~~ In file included from include/linux/clk.h:13:0, from drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:9: drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c: In function 'mtk_jpeg_try_fmt_mplane': include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:829:48: note: in definition of macro '__is_constexpr' (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) ^ >> include/linux/kernel.h:835:25: note: in expansion of macro '__no_side_effects' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:837:27: note: in definition of macro '__cmp' #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) ^ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:837:40: note: in definition of macro '__cmp' #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) ^ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:840:10: note: in definition of macro '__cmp_once' typeof(x) unique_x = (x); \ ^ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:840:25: note: in definition of macro '__cmp_once' typeof(x) unique_x = (x); \ ^ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:338:21: note: in expansion of macro 'clamp' pix_mp->height = clamp(pix_mp->height, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:341:20: note: in expansion of macro 'clamp' pix_mp->width = clamp(pix_mp->width, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:341:20: note: in expansion of macro 'clamp' pix_mp->width = clamp(pix_mp->width, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:829:48: note: in definition of macro '__is_constexpr' (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) ^ >> include/linux/kernel.h:835:25: note: in expansion of macro '__no_side_effects' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:28: note: in expansion of macro 'min' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ include/linux/kernel.h:835:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:845:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:861:19: note: in expansion of macro '__careful_cmp' #define max(x, y) __careful_cmp(x, y, >) ^~~~~~~~~~~~~ >> include/linux/kernel.h:898:45: note: in expansion of macro 'max' #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^~~ drivers/media/platform/mtk-jpeg/mtk_jpeg_core.c:341:20: note: in expansion of macro 'clamp' pix_mp->width = clamp(pix_mp->width, ^~~~~ include/linux/kernel.h:821:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:837:27: note: in definition of macro '__cmp' #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) ^ include/linux/kernel.h:854:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ vim +/min +898 include/linux/kernel.h 526211bc58c4b3 Ingo Molnar 2009-03-05 807 ^1da177e4c3f41 Linus Torvalds 2005-04-16 808 /* 3c8ba0d61d04ce Kees Cook 2018-03-30 809 * min()/max()/clamp() macros must accomplish three things: 3c8ba0d61d04ce Kees Cook 2018-03-30 810 * 3c8ba0d61d04ce Kees Cook 2018-03-30 811 * - avoid multiple evaluations of the arguments (so side-effects like 3c8ba0d61d04ce Kees Cook 2018-03-30 812 * "x++" happen only once) when non-constant. 3c8ba0d61d04ce Kees Cook 2018-03-30 813 * - perform strict type-checking (to generate warnings instead of 3c8ba0d61d04ce Kees Cook 2018-03-30 814 * nasty runtime surprises). See the "unnecessary" pointer comparison 3c8ba0d61d04ce Kees Cook 2018-03-30 815 * in __typecheck(). 3c8ba0d61d04ce Kees Cook 2018-03-30 816 * - retain result as a constant expressions when called with only 3c8ba0d61d04ce Kees Cook 2018-03-30 817 * constant expressions (to avoid tripping VLA warnings in stack 3c8ba0d61d04ce Kees Cook 2018-03-30 818 * allocation usage). 3c8ba0d61d04ce Kees Cook 2018-03-30 819 */ 3c8ba0d61d04ce Kees Cook 2018-03-30 820 #define __typecheck(x, y) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 @821 (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) 3c8ba0d61d04ce Kees Cook 2018-03-30 822 3c8ba0d61d04ce Kees Cook 2018-03-30 823 /* 3c8ba0d61d04ce Kees Cook 2018-03-30 824 * This returns a constant expression while determining if an argument is 3c8ba0d61d04ce Kees Cook 2018-03-30 825 * a constant expression, most importantly without evaluating the argument. 3c8ba0d61d04ce Kees Cook 2018-03-30 826 * Glory to Martin Uecker ^1da177e4c3f41 Linus Torvalds 2005-04-16 827 */ 3c8ba0d61d04ce Kees Cook 2018-03-30 828 #define __is_constexpr(x) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 829 (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) 3c8ba0d61d04ce Kees Cook 2018-03-30 830 3c8ba0d61d04ce Kees Cook 2018-03-30 831 #define __no_side_effects(x, y) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 832 (__is_constexpr(x) && __is_constexpr(y)) 3c8ba0d61d04ce Kees Cook 2018-03-30 833 3c8ba0d61d04ce Kees Cook 2018-03-30 834 #define __safe_cmp(x, y) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 @835 (__typecheck(x, y) && __no_side_effects(x, y)) 3c8ba0d61d04ce Kees Cook 2018-03-30 836 3c8ba0d61d04ce Kees Cook 2018-03-30 837 #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) 3c8ba0d61d04ce Kees Cook 2018-03-30 838 e9092d0d979611 Linus Torvalds 2018-04-09 839 #define __cmp_once(x, y, unique_x, unique_y, op) ({ \ e9092d0d979611 Linus Torvalds 2018-04-09 840 typeof(x) unique_x = (x); \ e9092d0d979611 Linus Torvalds 2018-04-09 841 typeof(y) unique_y = (y); \ e9092d0d979611 Linus Torvalds 2018-04-09 842 __cmp(unique_x, unique_y, op); }) 3c8ba0d61d04ce Kees Cook 2018-03-30 843 3c8ba0d61d04ce Kees Cook 2018-03-30 844 #define __careful_cmp(x, y, op) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 845 __builtin_choose_expr(__safe_cmp(x, y), \ e9092d0d979611 Linus Torvalds 2018-04-09 846 __cmp(x, y, op), \ e9092d0d979611 Linus Torvalds 2018-04-09 847 __cmp_once(x, y, __UNIQUE_ID(__x), __UNIQUE_ID(__y), op)) e8c97af0c1f23d Randy Dunlap 2017-10-13 848 e8c97af0c1f23d Randy Dunlap 2017-10-13 849 /** e8c97af0c1f23d Randy Dunlap 2017-10-13 850 * min - return minimum of two values of the same or compatible types e8c97af0c1f23d Randy Dunlap 2017-10-13 851 * @x: first value e8c97af0c1f23d Randy Dunlap 2017-10-13 852 * @y: second value e8c97af0c1f23d Randy Dunlap 2017-10-13 853 */ 3c8ba0d61d04ce Kees Cook 2018-03-30 854 #define min(x, y) __careful_cmp(x, y, <) e8c97af0c1f23d Randy Dunlap 2017-10-13 855 e8c97af0c1f23d Randy Dunlap 2017-10-13 856 /** e8c97af0c1f23d Randy Dunlap 2017-10-13 857 * max - return maximum of two values of the same or compatible types e8c97af0c1f23d Randy Dunlap 2017-10-13 858 * @x: first value e8c97af0c1f23d Randy Dunlap 2017-10-13 859 * @y: second value e8c97af0c1f23d Randy Dunlap 2017-10-13 860 */ 3c8ba0d61d04ce Kees Cook 2018-03-30 861 #define max(x, y) __careful_cmp(x, y, >) bdf4bbaaee3d4b Harvey Harrison 2008-04-30 862 e8c97af0c1f23d Randy Dunlap 2017-10-13 863 /** e8c97af0c1f23d Randy Dunlap 2017-10-13 864 * min3 - return minimum of three values e8c97af0c1f23d Randy Dunlap 2017-10-13 865 * @x: first value e8c97af0c1f23d Randy Dunlap 2017-10-13 866 * @y: second value e8c97af0c1f23d Randy Dunlap 2017-10-13 867 * @z: third value e8c97af0c1f23d Randy Dunlap 2017-10-13 868 */ 2e1d06e1c05af9 Michal Nazarewicz 2014-10-09 869 #define min3(x, y, z) min((typeof(x))min(x, y), z) e8c97af0c1f23d Randy Dunlap 2017-10-13 870 e8c97af0c1f23d Randy Dunlap 2017-10-13 871 /** e8c97af0c1f23d Randy Dunlap 2017-10-13 872 * max3 - return maximum of three values e8c97af0c1f23d Randy Dunlap 2017-10-13 873 * @x: first value e8c97af0c1f23d Randy Dunlap 2017-10-13 874 * @y: second value e8c97af0c1f23d Randy Dunlap 2017-10-13 875 * @z: third value e8c97af0c1f23d Randy Dunlap 2017-10-13 876 */ 2e1d06e1c05af9 Michal Nazarewicz 2014-10-09 877 #define max3(x, y, z) max((typeof(x))max(x, y), z) f27c85c56b32c4 Hagen Paul Pfeifer 2010-10-26 878 c8bf1336824ebd Martin K. Petersen 2010-09-10 879 /** c8bf1336824ebd Martin K. Petersen 2010-09-10 880 * min_not_zero - return the minimum that is _not_ zero, unless both are zero c8bf1336824ebd Martin K. Petersen 2010-09-10 881 * @x: value1 c8bf1336824ebd Martin K. Petersen 2010-09-10 882 * @y: value2 c8bf1336824ebd Martin K. Petersen 2010-09-10 883 */ c8bf1336824ebd Martin K. Petersen 2010-09-10 884 #define min_not_zero(x, y) ({ \ c8bf1336824ebd Martin K. Petersen 2010-09-10 885 typeof(x) __x = (x); \ c8bf1336824ebd Martin K. Petersen 2010-09-10 886 typeof(y) __y = (y); \ c8bf1336824ebd Martin K. Petersen 2010-09-10 887 __x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); }) c8bf1336824ebd Martin K. Petersen 2010-09-10 888 bdf4bbaaee3d4b Harvey Harrison 2008-04-30 889 /** bdf4bbaaee3d4b Harvey Harrison 2008-04-30 890 * clamp - return a value clamped to a given range with strict typechecking bdf4bbaaee3d4b Harvey Harrison 2008-04-30 891 * @val: current value 2e1d06e1c05af9 Michal Nazarewicz 2014-10-09 892 * @lo: lowest allowable value 2e1d06e1c05af9 Michal Nazarewicz 2014-10-09 893 * @hi: highest allowable value bdf4bbaaee3d4b Harvey Harrison 2008-04-30 894 * e8c97af0c1f23d Randy Dunlap 2017-10-13 895 * This macro does strict typechecking of @lo/@hi to make sure they are of the e8c97af0c1f23d Randy Dunlap 2017-10-13 896 * same type as @val. See the unnecessary pointer comparisons. bdf4bbaaee3d4b Harvey Harrison 2008-04-30 897 */ 2e1d06e1c05af9 Michal Nazarewicz 2014-10-09 @898 #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) ^1da177e4c3f41 Linus Torvalds 2005-04-16 899 :::::: The code at line 898 was first introduced by commit :::::: 2e1d06e1c05af9dbe8a3bfddeefbf041ca637fff include/linux/kernel.h: rewrite min3, max3 and clamp using min and max :::::: TO: Michal Nazarewicz :::::: CC: Linus Torvalds --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation --u7wedkesix5licz2 Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICJrhiV0AAy5jb25maWcAjFxbc+M2sn7Pr1BNXpKqk4kvM052T/kBJEEKEUlwAFCy/cJS PJqJK7blleScnX9/usEbbqSnamtjft1o3Bp9AzQ//vDjgrye9k/b08P99vHx2+Lr7nl32J52 nxdfHh53/7tI+KLkakETpt4Dc/7w/PrfX48v28P91YfFx/eX789+Odx/WKx2h+fd4yLeP395 +PoKAh72zz/8+AP870cAn15A1uHfi67dL48o5Zev9/eLn7I4/nnx2/sP78+AN+ZlyrImjhsm G6Bcf+sh+GjWVEjGy+vfzj6cnQ28OSmzgXRmiFgS2RBZNBlXfBTUETZElE1BbiPa1CUrmWIk Z3c0MRh5KZWoY8WFHFEmPjUbLlaA6LllerkeF8fd6fVlnAFKbGi5bojImpwVTF1fXoySi4rl tFFUqlHykpKECgdcUVHSPEzLeUzyfuLv3vVwVLM8aSTJlQEmNCV1rpoll6okBb1+99Pz/nn3 88AgN6QaRctbuWZV7AH431jlI15xyW6a4lNNaxpGvSax4FI2BS24uG2IUiRejsRa0pxF4zep Qe+MNSJrCksaL1sCiiZ57rCPqN4h2LHF8fXP47fjafc07lBGSypYrDdULvnG3uJK0DTnmyYl UlHODD00msVLVtnNEl4QVtqYZEWIqVkyKnAqtza163Ekw6TLJKemEvaDKCTDNsY2VURIamPm iBMa1VmKkn5c7J4/L/ZfnOUZFhLXOAYNW0lei5g2CVHEl6lYQZu1tw09WQuga1oq2e+Genja HY6hDVEsXjW8pLAZxo6XvFne4YkpeKmH3WvCXVNBHzxh8eLhuHjen/AI2q0YLJvZpkXTOs+n mhiaxrJlI6jUUxTWinlTGNReUFpUCkSVVr89vuZ5XSoibs3uXa7A0Pr2MYfm/ULGVf2r2h7/ XpxgOIstDO142p6Oi+39/f71+fTw/NVZWmjQkFjLYGVmjm/NhHLIuIWBkUQygdHwmMIJBmZj n1xKs74ciYrIlVRESRsCdczJrSNIE24CGOP28PvFkcz6GExdwiSJcm3Rh637jkUbzBSsB5M8 J4ppzdOLLuJ6IQOqCxvUAG0cCHw09AY01JiFtDh0GwfCZfLlwMrl+XgEDEpJKVh6msVRzkzP gLSUlLxW11cffLDJKUmvz69silTuGdBd8DjCtTBX0V4F2+9ErLww/AZbtX9cP7mI1haTsfVx cuTMOQpNwTqzVF2f/2biuDsFuTHpF+NxYaVagQdMqSvjst1Gef/X7vMrRCSLL7vt6fWwO457 WUNAUVR6Lwy31IJRDeZMye4gfhxXJCBw0KNM8LoyNL8iGW0lUDGi4A/jzPl0nPKIQWTRq7ZF W8F/jCOZr7reDeerv5uNYIpGJF55FBkvTbkpYaIJUuJUNhF4pg1LlOHAwZKE2Vu0Yon0QJEU xANTOB935gp1+LLOqMqNEAFUQVLTtKBiYUcdxZOQ0DWLqQcDt211+iFTkXpgVPmYdq7Gcefx aiBZ3hMDMPDUYCsNDQO1Ks04E4It8xtmIiwAJ2h+l1RZ37D88aricBTQjUEQa8xY7w0ES4o7 6gGeHLY1oeBxYqLM/XMpzfrC2HS047biwSLrIFgYMvQ3KUBOG1QY8alImuzOjKYAiAC4sJD8 zlQUAG7uHDp3vj9YgT+vwJtDlN+kXOh95aIgZWw5a5dNwh8BT+hGtToyrVlyfmWtGfCAH4hp hV4EbD4xFc9SItdbOLIKcGkMlcAQDwehQM/oxV/tZoVgHI+Hp22E6cbvQ+Rj2VX3uykLwwFb J4DmKRg6U/EiAtEpBmBG57WiN84nKLchpeLWJFhWkjw11EqP0wR0xGkCcmkZRsIMNYGwohZW REGSNZO0XyZjAUBIRIRg5iaskOW2kD7SWGs8oHoJ8MAotrZ1wd8YBP+ARJLkG3IrG9P9oyro OMeaeBHRJDGPrVZL1PRmCMP73UMQpDTrAvo0XXEVn5996COeLq+vdocv+8PT9vl+t6D/7J4h ZiLg+mKMmiAYHt1nsC9tGUM9Dg70O7vpBa6Lto/ejxp9ybyOPFOMWOc+9dEwVxKzcaKaSOf0 gxmQOYlCxx4k2Ww8zEawQwGevgtHzcEADb0bxmyNgKPHiynqkogEcilLles0zWkbRehlJGDb nalidASZINY0rNOvaKFdEZZLWMriPrYdHWfKcussaIulvYiVAtlVj5756kNkJuuYjMbO55Vh kHWOCcvTRYjvtof7v9rK0q/3uox07OtMzefdlxZ6ZzXWnn6FJqYBq2G6bliACA9EmTBSOl0S ZQTYEFzHKz3LRtZVxYVdYFmBx/MJWsySRVSUegnRYEoWmSZUVyI0o3MYISJpg4o24xLUDAww nu9J+jA3KROgB/GyLlcTfFoTgmxFUTtj7mYi+xMJTd3DnykMLSFFWFOwfR/CzWtY+YgOSX11 2N/vjsf9YXH69tLmVX5gLQvDvZd67CD/7F9XVlJ/fnYWOE9AuPh4dm3n/5c2qyMlLOYaxNhR 0FJgdjyOrK9dLDeUZUvlE8BEs0hADNSmr84KF+S2M7pxkya++tvLQInIb1MjmJU0Rntk6AxX VV5nXQrWZ/6L9LD7z+vu+f7b4ni/fbSSfdQJMCCf7NOASJPxNVbcRGOHxSbZTTMHIubvAbjP trHtVEQV5OUbMNuwUMEtDDZBl6fD5u9vwsuEwniS728BNOhmrb3z97fSqlQrFiosWctrL1GQ o1+YMRG26MMqTND7KU+QzflNsAyTMRXui6twi8+Hh38s1681HMZ3ieK0Bj65pAtq0MyqTECh x0jnsiniUVZZm0lAyRMqu/T+owNWpGy4WmLihIBrC3WtFKKCLpueJHseHHYQ3AWWH+54STm4 aIGlhf7Edn6BoqXIMck2ejachmFzCzhdSeuxlV3MR1JOaWUzI2IbEkAxnfN5N2RFdRk3jHZ3 E+fjfYpFzUzPUFginBALB5CsUa+TAKkdsYMnuisVLxM+gerQHqtY5xfm+HpL3BbSjZltPrXH p6EpRDcMA0Rv8/z2gRV2ObiZqAEpu20KUCkzutLORBbKhQpjCeMigfCKNhHnuYdev4MQ57h/ 3F2fTt/k2f/86wp82GG/P13/+nn3z6/Hz9vzd+OZmXO5+tBGr8fF/gWv4Y6Ln6qYLXan+/c/ G6c1qs2oGb5iiDYNpC6bHOYvbYhXtATnD0m8c7rBtUEvvr8DEO8pzOhxYmh2QG4FrvruacD1 /IqH4313G6m7CtgjY7iQ8Q3D5VHVpDmRyxFSJIEsE6JIeX520dSxEvlIjKK4YReGBaLl2uZI mKwgFPhNUqPQySGozPHi5Ma0dZPDtm4TMRR+OO3ucT9/+bx7gcaQDPWLZvh6AdNwcmzehvGG ddfxyACPKekQxHXAH3VRNZB/WHoNbh8OwopC/ikhobevIGtXxEpQ5WK6e6+zFp1it4oK462f DtSXnAfiNTCH+sKnUUuIqd0UWNAMEvIyaeN9vEjQFxWV2wv0G7BJ4wBCS9R2ENdNGzlj8jZJ LHnDyjVEkJCGuR5nGICuXMdFdRMvM4dnQ8Cm4WFoL/r6298AU5fWfhcvzxOD37BM7V25XjPY JkXxMry/3jInCH9jAqb3Z2UlkJo8ccE0scMlHgy03VjqxRTFyGh4Uufg2rGKgNUlrKM4UugN 5F2uDvAkwcq0ZBmJbd+LUwdY1hIshXX7r5ejI7utdKarvZPX4vIiQKrwIsXwSmlqKLzAFLhG 1CqMoQc2qxxDtpXFfP3Ln9vj7vPi77Zs8nLYf3mwswBk6l4PGGcFQR1/quZD85uV0c8IHRwj JCJ4cc2limMMUrx6wBt2a5ixagqs85nHXtfFJFaGxkcc3Xa7+98FYDk3t7gj1WUQblsMxCGa B3J3LmQw2u+aSxF3bFhzCQT5PR/LvK5lHzEGKVa9z8Dlkpw7AzVIFxcfZofbcX28+g6uy9+/ R9bH84vZaaOhWF6/O/6FUYpNxYMhwNx68+wJfenf7Xqg39xN9i3bi9QcfIJ5kRHh6TE/VxCO SQZn7VNtebD+riKSWRC0XqOMFxuKZoKpwJ0HZgSJD4NB4krZtTWfBtPY2PQ+YtQmXNi0TeTM o7tsYnhpTcv41mNvik9u91gGMo2RiYYmIyGk5RUZcsNqezg94OleKIhDzUJwn80MeYHheSBi KY18Z4rQxJDrlWSaTqnkN9NkFstpIknSGarOI8DhTXMIJmNmds5uQlPiMg3OtACvEiQoIliI UJA4CMuEyxABX2RAYLpyopWClTBQWUeBJvjcAabV3Px+FZJYQ8sNuOaQ2DwpQk0QdovxWXB6 kKSJ8ApiHB+AVwT8WIhA02AHmEZc/R6iGIdsII2JlqPgloXxchU8IsUnOxPqMAyCzIsnhHVO 3b5S4+MjAuMUQTvG20QygYhG54nfAsTVbQTmYXxk0cFRahRh4KPpLYRzO48k5xZ7fCBmjWw8 3vadNpHluaUppV5SWUHAgG7XtMZ2LZkoSM/iRhSG6dPRQdsYThrflKbtExtJiymi3pUJmu4X Q0f9MDHRbE5tZJriNhabcFMPHx8y6I2m/93dv562fz7u9APbhb7vOhlbHrEyLRSGt15sGSLB h53/6euQBPOUvkKJkXL/uuab042MBauUoSQtXIBxM8qDIBIlmmoxNY82Od897Q/fFsX2eft1 9xRMXYf62jgkfa2hL7ornSolXlrYvRrFqICWzlVTV8u7gXjAjL1H0hr+rxgez8xw+J22hx1H 1Ph0/XQqq+2XOjhM8/nY0FcO2UGlWuOhb0CcRhFeyFh2vAVaHXDykBAGjkUQlw1yrqxxr3qW kNOTJBGNcq/uVtLYll6N9OKB+9Bt2pubjmM+aQtRuyttM+gLshXtZXwg/HPZ9WVWTMCuGfPO KUQeNpYKWAz7YVVsPT8Cp+J4rAEyAwYE8fZOXg8P0+5ssXeVVea7i2qjKH93mUJuaXzL7lJ8 QPqbOFj1yoobe1bnSga2iQqBxku/Wm/vBfHJzcii6yMa9xP1VBB8y6tTfENHqMDk1Xm8meEL KIgwlwURrl3HgkGl0PLTuL1/Hmtfk1ZhtADKUW6FGLgScKGQCcDQnSdPMAc7t0CQOphcRWgY aKkTvd4Sl7vT/+0Pf+Ndhmed4FStqGEW228IfIhR4cN4yP4Cc2ocHI3YTVQurQ/vMdpNKgr7 q+Fpaue0GiV5ZtQ0NaSfB9kQZioitW6LNA7xH4S4OTOTBE1orYczoLYKKJUVT7fyK31d+WSu /oreekBAblLpJ3LW0z0DdBaOWarBqtZPxETa6HAHAbGM9b4SaCmLQO8ZdbW5F4ZORx85m6Yl dRzEfOo40NZURFzSACXOiZQssShVWbnfTbKMfTDiXPmoIKJyjkDFnB1gVYYxAC3qG5fQqLrE mpDPHxIRCVA8b5GLbnLOVfFACTHPrXDFCgnO9zwEGg8A5S06Qb5ing2o1orZw6+T8ExTXnvA uCrmsJBIlrYCNlRWPjIcUJviHg0N6kPjDkxTgqB/BhoVVyEYJxyABdmEYIRAP8BTcMMAoGj4 Mwtk7AMpYoaLGtC4DuMb6GLDeRIgLeGvECwn8NsoJwF8TTMiA3i5DoD4vE7Hfj4pD3W6piUP wLfUVIwBZjn4Kc5Co0ni8KziJAugUWSY8T76EjgWLybr21y/O+ye9+9MUUXy0SpHwim5MtQA vjojqX/sZPN15gtyAe4Q2rex6AqahCT2ebnyDsyVf2Kupo/MlX9msMuCVe7AmakLbdPJk3Xl oyjCMhkakUz5SHNlvWBGtEwgOdLJgLqtqEMM9mVZV41YdqhHwo1nLCcOsY6wAOrCviEewDcE +na37YdmV02+6UYYoEEsGFtm2SkQAYK/m8QXTnbUiPaoUlXnK9NbvwkkKvpCBfx2YYfCwJGy 3HL0AxSwYpFgCQS/Y6un/geqhx2Gg5DInnYH70esnuRQ0NmRumjVcjIdKSUFy2+7QYTadgyu g7cltz+XCojv6e1vMWcYcp7NkblMDTK+4C5LnS5YqP4RThsAuDAIgqg21AWKan87E+ygcRTD JPlqY1KxUC0naPhINJ0iui+VLWL/+mSaqjVygq713xGtcDSKgz+IqzAlM0s5JkHGaqIJuP6c KToxDIKPwcjEgqeqmqAsLy8uJ0hMxBOUMVwM00ETIsb1D13CDLIspgZUVZNjlaSkUyQ21Uh5 c1eBw2vCgz5MkJc0r8wEzD9aWV5D2GwrVElsgfAd2jOE3REj5m4GYu6kEfOmi6CgCRPUHxAc RAlmRJAkaKcgEAfNu7m15HXOxIf0Y9MAbGd0I96ZD4Oi8M0fvhd4MjHLCsK3/r22F1dozu7H dg5Ylu3jNwu2jSMCPg+ujo3ohbQhZ1/9AB8xHv2BsZeFufZbQ1wRt8c/qLsCLdYurDNXfUth YUvrAZReQBZ5QECYrlBYSJuxOzOTzrSUpzIqrEhJXfkuBJin8HSThHEYvY+3atJW1ty5GbTQ Kb4ZVFwHDTe6+H1c3O+f/nx43n1ePO3xjuQYChhuVOvbglK1Ks6Q2/Nj9XnaHr7uTlNdKSIy zF71v50Qltmx6B8Jyrp4g6uPzOa55mdhcPW+fJ7xjaEnMq7mOZb5G/S3B4EFU/3zsnk2/Cnu PEM45BoZZoZiG5JA2xJ/BvjGWpTpm0Mo08nI0WDibigYYMJCH5VvjHrwPW+sy+CIZvmgwzcY XEMT4hFWoTTE8l2qC9l3IeWbPJBKSyW0r7YO99P2dP/XjB1R+BumJBE6+wx30jLh70vn6N2P w2dZ8lqqSfXveCANoOXURvY8ZRndKjq1KiNXmza+yeV45TDXzFaNTHMK3XFV9SxdR/OzDHT9 9lLPGLSWgcblPF3Ot0eP//a6TUexI8v8/gTuBHwWQcpsXntZtZ7XlvxCzfeS0zJTy3mWN9cD yxrz9Dd0rC234O8H57jKdCqvH1jskCpA168d5ji6G59ZluWtnMjeR56VetP2uCGrzzHvJToe SvKp4KTniN+yPTpznmVw49cAi8LLq7c4dF30DS79W/M5llnv0bHg6+I5hvry4tr8gdVcfasX wyo7U2u/8WdO1xcfrxw0YhhzNKzy+AeKdXBson0aOhqap5DADrfPmU2bk4e0aalILQOzHjr1 56BJkwQQNitzjjBHm54iEJl9w9tR9S/I3S01bar+bO8FvtmY8wCiBSH9wQ2U+E/ttG/WwEIv Toft8/Flfzjhg/HT/n7/uHjcbz8v/tw+bp/v8XL9+PqCdOMfx9Pi2uKVci4+B0KdTBBI6+mC tEkCWYbxrqo2TufYP3VzhyuEu3AbH8pjj8mHUu4ifJ16kiK/IWJel8nSRaSHFD6PmbG0UPmp D0T1Qsjl9FqA1g3K8LvRpphpU7RtWJnQG1uDti8vjw/32hgt/to9vvhtrdpVN9o0Vt6W0q70 1cn+93fU9FO8ShNE32R8sIoBrVfw8TaTCOBdWQtxq3jVl2WcBm1Fw0d11WVCuH01YBcz3CYh 6bo+j0JczGOcGHRbXyzx38IikvmlR69Ki6BdS4a9ApxVbsGwxbv0ZhnGrRDYJIhquNEJUJXK XUKYfchN7eKaRfSLVi3ZytOtFqEk1mJwM3hnMG6i3E+tzPIpiV3exqaEBhayT0z9tRJk40KQ B9f/z9mVNbeNJOm/wuiHje4Hb/MQKenBD0ABIMvEJRRIQv2C4Np0WzGy7JXk7pl/v5VVODKr EnLHTsS0zO/LOlD3kZVpHkA4uG5bfL0GUzWkifFTRqXjNzpv17v/2vyz/j324w3tUkM/3nBd jU6LtB+TAEM/dtCuH9PIaYelHBfNVKJ9pyUX45upjrWZ6lmIiA9yczXBwQA5QcEhxgS1SycI yLfVR54QyKYyyTUiTNcThKr8GJlTwo6ZSGNycMAsNzps+O66YfrWZqpzbZghBqfLjzFYIjdq 3qiHvdWB2Plx00+tUSyeLq//oPtpwdwcLbbbKggPqbFVhDLxs4j8btndnpOe1l3rZ7F7SdIR /l2JtQvpRUWuMinZqw4kbRy6HazjNAE3oIfaDwZU7bUrQpK6RczNfNmuWCbICryVxAye4REu p+ANizuHI4ihmzFEeEcDiFM1n/wxDfKpz6jiMr1nyWiqwCBvLU/5UynO3lSE5OQc4c6ZetiP TXhVSo8Gre6dGDX4bG/SwEwIGb1MdaMuohaElszmbCBXE/BUmDqpREueOBLGews0mdXxQzpL brvzx3+RB8l9xHycTigUiJ7ewK82CsGIwwdBXoAYotOKs1qiRiUJ1ODwK4NJOXhwy76DnQwB 7+A5228g7+dgiu0e+uIWYlMkWptVpMiPlugTAuDUcA0P+b/iX3p81HHSfbXBaUpBnZEfeimJ h40eMZYMBFZ+ASYlmhiAZGURUCSslpubKw7T1e12IXrGC7+GlxgUxeamDSDdcDE+CiZj0ZaM l5k/eHrdX271DkjlRUHV0ToWBrRusPdtIZghQBGjbxb46gB6xtvC6L+446mwEpmvguUIvBEU xtY4j3iJrTq5SuU9NZnXeJLJ6j1P7NUfb36C5ieJ26vra568ExP50PVyu5qveFJ9CBaL+Zon 9aJApnjuNnXs1M6Itdsj3qkjIiOEXR+NMXTrJffxQorPgvSPJe49QbrHERzboCzTmMKyjKLS +dnGucDPlZol+vY0KJEySLkrSDY3ehdT4km7A/xXUj2R74QvrUGjhM4zsOqk94qY3RUlT9BN EWayIpQpWVZjFsqcHM1j8hAxqW01AUZPdlHFZ2f7VkgYPLmc4lj5wsESdGfGSTgLUhnHMbTE 9RWHtXna/cOYI5ZQ/tiGKJJ0L00Q5TUPPc+5adp5zj5CNouHux+XHxc99//ePTYmi4dOuhXh nRdFu6tDBkyU8FEyufVgWWHrUD1qru2Y1CpH18OAKmGyoBImeB3fpQwaJj4oQuWDcc1I1gH/ DVs2s5Hy7iwNrv/GTPFEVcWUzh2fotqHPCF2xT724TuujIQxrebB8EadZ0TAxc1FvdsxxVdK JnSv4+1Lp4ctU0qDnblh4divGZM7dl05Lin1N70p0X/4m0KKJuOwemGVFOalsv+GpPuE9798 //zw+Vv7+fzy+kunF/94fnl5+NwdztPuKFLnFZYGvEPhDq6FPfb3CDM4Xfl4cvIxe6fZgR3g GufvUP+BgUlMHUsmCxrdMDkAUyweymjM2O92NG2GKJwLeYObIymw+0OY2MDOO9bhalnskf8o RAn38WWHG2UbliHFiHDn9GQkjGVljhBBLiOWkaWK+TDE1kBfIAHRQNZgALrtoKvgfALgYIsL L92tGnzoR5DJyhv+AFdBVqZMxF7WAHSV72zWYlex0kYs3cow6D7kxYWrd2lzXabKR+kRSY96 rc5Ey+k9WaY277m4HGYFU1AyYUrJajH7b3xtAhTTEZjIvdx0hD9TdAQ7XpghXeIHaZFA1R7l ChxdFOARDe3X9IwfGBNEHNb/E2mbYxLblkN4RAy+jHguWDij72dxRO5q2eVYxliwZxk4uSQb TrB+edQ7ORhYvjIgfZiGiWNDWhwJE+cxth187F9xe4hzsmAN4HDylOB2hOb5BI3O9BTS6wHR O9eCyvgre4Pq7s68D87x5flOuSsfUwL0dQIoWqzg+B0UcAh1V9UoPPxqVRY5iM6EkwOBHVrB r7aIM7BR1NpzftTKKuxXqEqM5y385q7BfGffB9IwHY8jvPfqZjcKbpbUfUv9cIR3vqMKCqi6 ioPMM10GUZprMHu8TI0xzF4vL6/e0r/c1/T5B+zMq6LUW7pcOlcKXkQOgc09DBUdZFUQmTLp jJp9/NfldVadPz18G9RakEJuQPbK8EsPClkAzhuO9MVMVaAxvgIjAd2hb9D893I9e+oy++ny 18PHi2/CNttLvATdlERVNSzvYjBvjYe2e915WvAVlEQNi+8YXFfRiN0HGS7PNzM6NCE8WOgf 9FoLgBCfRQGwPfVFoX/NIhtv5BYASB692I+NB6nUg4gaIwAiSAUorcALZjxMAhfUtwsqnaSx n8y28qAPQf6H3s0H+crJ0SG/Qk+MS7ticnI0AelNRlCDoU6WE9KBxfX1nIFaiQ/kRpiPXCYS /iYRhTM/i2Uc7CEXsSsLR2jz+ZwF/cz0BJ+dOFM6jUzIgMMlmyNfus/qxAcI2gj2xwC6iC+f Nj6oioROKwjUizvculUpZw/gwebz+ePFad07uVosGqfMRblcL4jdaCaaIfqDCiejv4ETQS3g F6IPqgjApdPiGcmunDw8E2Hgo6a0PfRgmxX5QOdDaGcGm5TWWg5xRcOMHsPohu/z4G42jrAJ TT2zJbDUIEIWamti21OHzeOSRqYB/b2te2HRU1a9kGFFVtOYdjJyAEUCYFNl+qd3uGZEIhrG t9SNwDYW0Y5niE8BuGQdVqjWpvzjj8vrt2+vXyYnLLhNzmu8qoICEU4Z15Qn5/VQAEKGNWkw CLR+DlxzzVggxDaYMJFh72WYqLAnt55QEd6dWPQQVDWHwcxK1n6I2l2xcF7spffZhgmFKtkg Qb1beV9gmNTLv4FXJ1nFLGMriWOY0jM4VBKbqe2maVgmq45+sYpsOV81Xs2Weirw0YRpBFGd LvyGsRIelh5iEVSRix93eCAPu2y6QOvVvi18jJwkfSwOQeu9F1BjXrO504MM2QvYvFVK4iFx srsNK89EL84rfNHbI4762gjnRp0sLbD1ioF1Np1Vs8cmXrTYHvfkifU96L1V1Gw3NMOUGMzo kZa47TrF5jUsbrMGoq5iDaTKe09Iog4oki1cOaCmYq82FsaJOjjv8GVheonTAhxrgXt4PY8r RkjEerfaO09ri/zACYGdaf2JxlshWCOLt1HIiIE90c7FuxExfhYYObBqGYwi8Nh89BGDEtU/ 4jQ9pIFe50ti2IIIgdn8xtzgV2wpdGfGXHDfDuJQLlUU+K7SBvpEHbRhGC6bqOM1GTqV1yM6 lftSdz08GzucIGeiDlnvJUc6Db+7r0Lp94gxb4i92g1EJcA2JvSJlGcHM5r/ROr9L18fnl5e ny+P7ZfXXzzBLFY7JjxdBwywV2c4HtWbgyRbIhpWy+UHhswLa+aXoTqbeFMl22ZpNk2q2rPB OVZAPUmBq+opTobK05EZyHKaysr0DU5PCtPs7pR5Po9IDYKyqDfoUgmhpkvCCLyR9TpKp0lb r777TFIH3VOnxjjBHd0ynGQWoMna/OwiNG4D398MM0iyl/iiw/522mkHyrzEtnY6dFu6Z8S3 pfu7N63twq4Z10Ci83L4xUlAYOfkQCbO9iUud0ZrzkNAqUZvHdxoexaGe3JOPR4VJeQtBShl bSVcvRMwx0uXDgBb1T5IVxyA7tywahelYjx+Oz/PkofLIzhb/fr1x1P/IOdXLfpbt/7AT9J1 BHWVXN9ezwMnWplRAIb2BT4UADDBe54OoE6WTNB8fXXFQKzkasVAtOJG2Isgk6IqjNMYHmZC kHVjj/gJWtSrDwOzkfo1qurlQv91S7pD/VhU7TcVi03JMq2oKZn2ZkEmllVyqvI1C3Jp3q7N RTw6nP1H7a+PpOQu8ch9lW+qrkeo2+0I3KZSC9HbqjDLKGxAGMx1926b2iaTzoWl4TNFLdPB ctLsEAbQmF6mVqGTQKYFubKyXozGE3WrWjtxPtq5GkU3Bu4P30segJ6raTgNg55KvML1zkch BAhQ8QAPYB3QbTDwsafUXyMq4Ygq4k6wQzzPgSPuaVcM3NueRKkYrE//kfDoppNRqjDfVGZO cbRR6XxkW9bOR7bhidZDppzagm3D3qksv1TMw3gwAW5t2ZszEaeC60NIaqE1NzIuSAwhA6D3 zDTPrSyOFNAbLQcIyJ0RajV8UxKTjNqVw5QEjgE/fnt6ff72+Hh5RkdN9tzz/OkCXsK11AWJ vfivjU25iyCKic9VjBqPVhNUTJwe/DRVXCxJrf8LMx8pLEjLM508EJ03OyczDZw0NFS8AVEK HVetijPpBA7gCDKg1W7SqneHPILj7jhjctKzXoOIW70b34udLCdgW2bdsPXy8OfT6fxsisza IVBsBUUntzed2rh0+kEVXDcNh7mi4EyuLmOx4VGnVt/M5eAHhm+OQ1ONnz59//bwRL8LHJAb 7+lOJ+vQ1mKJ2wd1V62t6idJfkhiSPTl74fXj1/4boIHg1N3dQ0OjZxIp6MYY6DnaO49i/1t 3LG1QuKjAR3Mziddht99PD9/mv3P88OnP/Fi8h60TMf4zM+2QBZoLaL7RbFzwVq6iO4WcKse e5KF2skQHWKW0eZ6eTumK2+W89sl/i74AHjmYZ1gor1JUEpyzNcBba3k9XLh48ZicG8+cjV3 6W4Ur5q2bsx6WXlptVEGn7Ylu+2Bc87thmgPmauS13PguyH34QxSb4XdAJlaq87fHz6BDyDb Trz2hT59fd0wCekdasPgIL+54eX10Lb0maoxzAq34Incjc5UHz52i6ZZ4fp4OFjnip3Bo/+w cGtM/o9nbbpg6qzEHbZH2swYth2XjDXY8EyJr0y9OzRxJ7LKjCOt8CDTQQM6eXj++jcMQmA/ AxtBSE6mc+FF4gCZNWWkI8IugcxpYZ8Iyv0Y6mBUAZwvZ2m9QrVerDk55NpvqBL3M/pQxtMo 3EYib0IdBWuZ0wQ3hZrrwEqSXfRwSVjFykXN/ZYNoFdPWYEVNQwX2NMYK2Gc0qKjbr3UIivj Kt4SR0D2dxuIW/QmpQPJ9qfDVCoziNDDsUfaAcukJ3haeFCWYa2ePvHqzo9QCLQMhIFF7YLK tqKElKemErMMsqbxsL9QvnMNrqe9EwO48tDbGokdOkjYxIG/bVsUxEG0u+XTf3LrnGbI+TbH yjHwC+7hJD41MWBW73lCySrhmUPYeERWR+SHaTaKQtiVnEMVCYcG1TUHhyLbrJpmoBxfi9/P zy9UUcj6j4duKzM9ItREU24k66qhONR8qVIuD7pFgAuStyj7nNa4rTIu3t4tJiNoD7nZsugN NHbP6onBYUuRp/fvWR98/Yeb8jjof84ya3V1FmjRGmwRPdqDg/T8H6+EwnSvBwe3qE3OfUiv Z9F4W1PLvc6vtkLLV0n5KolocKWSCI0IKqO0aStF6eTSuJZya9R6KwSnaUb9sJ9IqiD7vSqy 35PH84te2X15+M5olkFjTSSN8kMcxcIZ+gDXs647Inbhjd4p+IQo8AlDT+ZF5xFr9OzaMaGe ++7BS5Tmee+znWA6IeiIbeMii+vqnuYBBrswyPftSUb1rl28yS7fZK/eZG/eTnfzJr1a+iUn FwzGyV0xmJMb4kVoEAIFAKLZP9RoFil3pANcL2gCHz3U0mm7VZA5QOEAQajsu75xGTfdYq0/ wfP376C42YHgbNBKnT/qOcJt1gVMK03vOM1pl2DgMPP6kgU9d56Y099f1e/n/76Zm/9xImmc v2cJqG1T2e+XHF0kfJLgc1rvPLAGEKa3MThzneBKvWI2jvoIDb5UD0lKbH8bXKyXcxE5xZLH tSGcaU+t13MHI9pxFqCbxBFrA72juterZadiTItsj+BfvnLCpUFdUa3UnzUI02rU5fHzO9jY no19bh3VtKItJJOJ9XrhJG2wFu5Psa9fRLkXbJoBz6hMGQ9we6qkdRtG3J1QGa/XZst1eeMU eyZ25XK1X643TnWqerl2+qVKvZ5Z7jxI/9/F9G+9ea6D1F4DYsePHRtXxnk7sIvlDY7OzKRL u3KyJ0IPL/96Vzy9E1BZU6fapiQKscV2T6y1Xr1Oz94vrny0fn81to6fVzxp5XqjZrVO6Byc x8CwYFd3tiKd0baT6E/y2OBe5fbEsoGJdlvhM7chj7EQcJSzC7KMvmfgBfTKQjgrreDU+t+E g4bmCVq38f/7d73cOj8+Xh5nIDP7bEfn8diT1piJJ9LfkUomAUv4A4UhgwxuqtM6YLhCD2fL CbzL7xTV7a/9sHpvjr0nDni3GmYYESQxl/E6iznxLKiOccoxKhVtWorVsmm4cG+yYLdhov70 huHqumlyZtyxRdLkgWLwrd5cTrWJRO8LZCIY5phsFnN6aT1+QsOhekRLUuGuc23LCI4yZ5tF 3TS3eZRkXIT5Qdy6s5AhPvxxdX01RbgDqCF0X4lzKaAPMI3JxmdIPs7lOjTtcCrFCTJR7Hfp GbrhymInlVzPrxgGdtZcPdR7rkjjbcX1MlVnq2Wri5rralms8Hss1Hgk14uQQr9dvT28fKRD hfItl4wVq/9DlAgGxh4AMw1Iqn2RmxuJt0i7hWHcgr0lG5njrfnPRXdyyw1FSC4Ma2a+UOXQ /0xhpaVOc/Zf9u9yptdMs6/Wby67aDFi9LPv4JnnsF8bJsWfR+xly12IdaDRY7kyPrn03h9f k2s+UCW48SaNG/D+Qu3uEERE2QBIaNytSpwgcG7DioMagv7rbl8PoQ+0p7Std7oSd+Bu2Vm7 GIEwDrunaMu5y8GDeXLO1xPgyYlLLaSe7gHe3ZdxRc76dmEm9JS3wfYwohqNPXg/UCRwPKr5 UBFQD/Q1eP4joK70zAP3RfiBANF9HmSSpGfsUuPfGbnfKJJeZ4kIgeJCGqAlrPEAnemeUPea CXBMQZU7e+CrA7RYj7nH3DO4UdZ5C4wIc8cvec67u+rTOeRhWfp40NzcXN9ufEKvc6/8FPLC fMaAh+mevgntAD176ToNsYkel2mttqjVpyDe3HtJ8voqIrtsnR8ZDW8Ny34Vp7HZl4c/v7x7 vPylf/p3hSZYW0ZuTPqjGCzxodqHtmw2BmPhntekLlxQ4xefHRiW+KiuA+kbng6MFH5824GJ rJccuPLAmPjLQqC4IbVuYadFmVgrbDxmAMuTB+6J69werLF70g4scrwVH8GN34rgtlspWATI sltMDkdrf+jdBXOU1gc9ZNgKTI+mBbZwhFFQaLaKpKPeZ88bpeuCDxtVIWpT8OvnTT7HQXpQ 7TmwufFBsrNFYJf9xYbjvE2v6WvwJllER7cL9nB3laLGIqH0ydE5C+DGGy6eqJW6Q37ER8Xd Q3kyboxYq8jT8eEbuDKrlGkTVvfzmMW+Vgagzq54qIUjcT8Bgox7dIMnQVhJoRxpouwKALFm aBFjtJYFnbaIGT/iHp8OY9MeNRFxaQzLV/8+S8W50osf8LKwSo/zJSrkIFov100blUXNgvRG EBNkpRMdsuzeXOCNfX4X5DUe6O2hWSb1ohsPGGoLelsCrS9qmWROdRpI7xnRkZeuqtvVUl3N EWa2uK3C5rT0Qi4t1AHet8SVfZE5Lm7KVqZo6WDu/UShd3hkP2xgWF7R50tlpG5v5ssAG0GR Kl3qrd7KRfBg2NdGrZn1miHC3YI8ku5xk+Itfnu2y8RmtUbzRKQWmxuiFwJucrAmHSzFJCiL iXLV6fSglCpXo25Q/6mJfTer5dWqKInxxhBUR6paoRyWxzLI8aQhlt2KyrTXOIZloK8IZ3Fd n0vULkZw7YFpvA2wu6AOzoJmc3Pti9+uRLNh0Ka58mEZ1e3N7a6M8Yd1XBwv5manO3RK55OG 7w6vF3OnVVvM1cAfQb1BUYdsuLEyJVZf/n1+mUl4cPPj6+Xp9WX28uX8fPmEnJs8PjxdZp/0 SPDwHf45lmoNNyM4r/+PyLgxhY4FhLHDhzUjAUazz7Ok3Aazz73ixadvfz8ZHyx2bTX79fny vz8eni86V0vxGzJjYTQD4WKjTPsI5dOrXqHp3YHeKT5fHs+vOuNjS3JE4J7eHt72nBIyYeBj UVK0n7z08sFujZyYd99eXp04RlKAFhmT7qT8N73ahGuBb88z9ao/aZadn85/XqB2Zr+KQmW/ oTPoIcNMZtG0a5QkO2dOo1H1N0qvD7mN89MdarD293Bo0sZVVYCKioD1wP149BCLXeEMC0Gq 275zpNoPF1MweZ+wC8IgD9qAPDsl890oqbdzEr+axBuMx8v5/xj7kibHcSTrvxJmc5kxm/5K JLVQhzpAJCUhg1sQlMSICy0qM7oqrXMpy8yarvr3Hxzg4g44VX3IRe9hI1YH4HD//qaFybeH 9Ot70+vNJfxPHz+8wZ//9023JlzRgHuXnz5++efXh69fzDbAbEHQqgoSbacFp56+0ATYWu1Q FNRyU83IPEApzdHAJ+zzxvzumTB30sSCzCTGZvmjLH0cgjOCl4Gn13GmrRWbly5ERovbCvUI qzp+rG52WE2ld8PTZAbVCldhWrQf+95Pv/zx6z8//okretooeMY3UBmMatDx+DPSyEapM7rW KC7R8R7x6ng8VKBM6jHedckURU/VW6xT6ZSPzUdkyZYcoU9ELoNNFzFEke7WXIykSLdrBm8b CRZimAhqQ65MMR4x+Lluoy2zhXtn3h4xPUslQbhiEqqlZIoj2zjYhSweBkxFGJxJp1Txbh1s mGzTJFzpyu6rnOnvE1tmN+ZTrrdHZkwpaZSYGCJP9quMq622KbRI6ONXKeIw6biW1Xv5bbJa LXatsdvDtmq8P/R6PJA9MZ/XCAlzSNugDzM7M/KrtxlgZDBz5qDO6DaFGUrx8OOv3/XqrgWJ f/3vw4/X39/+9yFJ/6EFpf/xR6TCO9VzY7GWqeGGw/SEVaYVfiw+JnFiksXXHeYbpv2CgydG tZq8Uzd4Xp1O5DmyQZWx0wRamqQy2lGs+u60ijmN9ttBbwZZWJq/OUYJtYjn8qAEH8FtX0CN 1ECsrFiqqacc5lts5+ucKrrZt7bzUmBwspO2kFGus1YDnervTofIBmKYNcscyi5cJDpdtxUe tlnoBB27VHTr9ZjszGBxEjrX2FCUgXToPRnCI+pXvaBvFSwmEiYfIZMdSXQAYMYHX3LNYG0I GV4dQzSZMs/7cvHcF+rnDVIHGoPYvYZV7EfHPIQt9IL+sxcTDDTYZ8Tw0or6uBiKvXeLvf/b Yu//vtj7u8Xe3yn2/j8q9n7tFBsAd6dmu4C0w8XtGQNMRVs7A1/94AZj07cMyFN55ha0uF4K N3VzZahHkAs3SYHnSzvX6aRDfG+mN9FmSdALIBgx/Msj8On1DAqZH6qOYdxd+UQwNaBFCxYN 4fvNw/4TUdnBse7xoU0V+UiBlingedWTZH2iaP5yVOfEHYUWZFpUE316S/SExpMmlie8TlET eGd/hx+TXg4BvY2BD8rrrXCYULuV/NwcfAh7LZEHfFppfuK5k/6yFUwOfSZoGJZHdxVNiy4K 9oFb40f7IJhHmbo+pa27nsvaWzxLSSwwjKAgL/+tQFO707ss3PqXL+YZYY01Z2dCwWuRpG3c RbTN3CVCPRebKIn1NBMuMrCJGO75QWnKbDyDpbCDDZdW6I3ofF3ghIKBY0Js10shyFONoU7d mUQj07sLF6evYQz8pKUm3Rn0aHVr3DL0gNjigpyYt0kBWEhWRQSycykkMi7y03zwlKWSVevW xHHByxIINfUxWZo90iTab/50Z2Co0P1u7cC3dBfs3b5gC+/0gksJLoOdDlpw4kJdxHavQIt8 OEIdLhXaNUxihatzlitZcSN8lOrGe2p0bGxVZ88i2IT4KNji3pgecNvyHmw74sYbmtgs4AD0 TSrcSUejZz0Kbz6cFUxYkV+EJ9c6+6lJKmiJtyhBT0pQ6YCri+mhcYLeYv/744/fdGt8+Yc6 Hh++vP74+H9vs1VJtEeAJAQxi2Ig4yYm032xsDbo0RHcFIVZNwwsi85BkuwqHMi+3KbYU0Xu i01Gg3o3BTWSBFvcBWyhzFNV5muUzPFxv4HmEx2oofdu1b3/4/uPr58f9LzIVZve0OvpshBO Pk+KPM2yeXdOzocCb6s1whfABEPH1NDU5GzDpK5XcB+BQwhnaz0y7uQ14leOAG0uUNp3+8bV AUoXgHsKqTIHbRLhVQ5+NzEgykWuNwe55G4DX6XbFFfZ6rVsPpz9T+u5Nh0pJ3oHgBSpizRC gTHho4e3Ve1irW45H6zjLX4sbFD3pM2CzmnaBEYsuHXB55p6cTGoXsUbB3JP4SbQKyaAXVhy aMSCtD8awj18m0E3N+8U0KCeerFBy6xNGFSW70QUuqh7nGdQPXroSLOoFh3IiDeoPdnzqgfm B3ISaFAwr042UBZNEwdxzzYH8Owimf7+5lY1j26SelhtYy8B6QYbjQE4qHumW3sjzCA3WR6q WWWzltU/vn759Jc7ypyhZfr3ikrYtjWZOrft435IVbduZF+jDUBvebLRj0tM8zIY7iYv5//5 +unTL6/v//Xw08Ont19f3zM6qHahcs7uTZLePpU59cdTS6G3trLM8MgsUnNAtPKQwEf8QGvy KiZFOioYNQI9KeboPH3GDlZbx/ntrigDOhx1eicP04VRYZ4ltJLRb0pRu6SeOSQT84jlyTHM 8GK1EKU4ZU0PP8j5qRPOOBTyjT5C+hI0hyVR906NPSQ9hlqwXZASEU1zFzBnKWvsakejRvOL IKoUtTpXFGzP0jwtverNdlWSVy2QCK32EelV8URQo1btByZmb/Rv8AiEhRQNgR9oMHagapHQ yHQLoIGXrKE1z/QnjPbY0RshVOu0IOjQEuTiBLE2KUhLHXNBnPBoCB4ltRzUH7Gle2gLxyfM UBOmHhWBQcHo5CX7Aq+OZ2TQpHLUi/TGUTqPqwE7auka92HAanpKDBC0Clq0QH/rYHqtoxhm kkRzz3AM7oTCqD3dRkLTofbCHy+KKCDa31QnY8Bw5mMwfOY2YMxp2sCQVzEDRrzvjNh0K2Lv ebMsewii/frhv48fv73d9J//8e+njrLJjBXwzy7SV2S3MMG6OkIGJg5AZ7RS0DNmBYh7hRpj WwubgyH/cdqV2NRg5pqBhuWWzg6gHDf/zJ4uWnJ9cd2tHVG3l66PxjbD6qAjYg6AwI+7SI3j poUATXUp00ZvFcvFEKJMq8UMRNLKawY92vUnN4cBIysHkcNrFbQ+iYR6AwOgxQ+aZW38zeYR 1pWoaST9m8Rx/D25Pp5O2GeBzlBhDTUQO6tSVY49xgHzXxtojroSMi5+NAL3gW2j/0Mso7YH zyRrI6k/WvsbjCe5b1AHpvEZ4niJ1IVm+qvpgk2lFPG/cCXquYPqLSlKmXvOjK8N2iipS6n3 9fBMe8ZEQ70A29+9loQDH1xtfJB42xmwBH/SiFXFfvXnn0s4npXHlKWexLnwWkrH2zKHoEKu S2I1GvD+bW3uYIP0ANIBDhC52xzcjQtJoaz0AVeOGmGwEqYlqgYb/xs5A0OPCra3O2x8j1zf I8NFsrmbaXMv0+Zepo2faSkTMGtAa2wAzSsv3V0lG8WwMm13O/CZTUIYNMQatBjlGmPimgRU dPIFli+QFE5GnsVsQPWeJ9O9z/FOP6Imae8+kIRo4YoTLIzMx/6Et3muMHd2cjtnC5+g58kK OQySR6Qr6u24jD3qFgtkBgFtB+t/jMGfS+LpSMNnLG8ZZDqrHt/p//j28Zc/QINxMK4mvr3/ 7eOPt/c//vjGeX7ZYGWijdFfHQ10EbwwFus4Al5tc4RqxIEnwOuK4y4TPLYftEyojqFPOK8A RlSUrXxa8nlftDty2DTh1zjOtqstR8GZjXnzec/BPQnFe7P3gjh2mklRyLWNR/WnvNLCREiX XRqkxmYJRhrcdMEY95IeCD7WUyLiRz8O2K1tM70DLZjPUIVKoDH2EVb251jHpDQXgj5gHIMM Z6P9VSW7iKsvJwBf324gdKgyGxX9DwfQJMGCJz/yCtP/AquF1Ufw4Nu9GoqSDb4Hm9EYmbi8 Vg25JG2f63PlySs2F5GKusX7xgEwhnCOZEtxaohchBM5ZViMz9ogCjo+ZC4Ss43Hd1C5TCrX B/cUvs3wDk3v38n1uP3dV4XUy6086f0TnnSt5nurMj7tQrzgtAmFPeIUaRyAexb89TUIO+S8 1TZFWSRExtbLgCPa6+R6vTVlEOrqForjXCJNUH8N+U/SGyQ9y6GDaPFk3tixgZuE/3jooxUR 1HKyzOcB/ZXRn7h58oVucGmqBpfS/O7LQxyvVmwMu1XDI+KAnQboH9bSNbgNy/IM+5oeONhq 3uPxEV8BlYz1JssOO8wjXdB0u8j93Z9vxPazUZyjCepppyFmtw+nAt/Cmp9QGOFijD7Ls2qz gr641nk4v7wMAbMOzEFpG3aiDkl6pEGc76JNBM//cXjBtqVnptvuZPIuS4Xu36QSSLSrvKAO MNquhgkAv1LG+HUBP5w6nmgwYXM0S9+E5fLpQs0CjwjJDJfbagJgtVqrGtBiX6QT1gcnJmjE BF1zGG0yhBtFBIbApR5R4vYEf4pUCfoQOhfjcLojyhINcHvLPS9/c44d2B7H56Cl61R+SDPN nOmqveSSGIsNgxW+WRwAvZbns8RuI30mP/vihkb/ABHdHYuV5MXIjOkxoWU4Pe4Ffc9sQ6TF HrzeoXKuOyRnDbdMfYyt2Zg4aMbRCW3Cra8R0skmcU+fxuqiWuZpHuJrbt3h6ao0Is6HowSz 4gK3ZvPozkI6R5rf3rxnUf0Pg0UeZtbKxoPV4/NZ3B75cr1QK/WIOopGizPPPNdkGXjHQGOC vMgEs0hHYj0bkPrJEdgANFOWg5+kKMn9MwSERSVhIDJzzKied+CeCR+tz6Tuc2BqXItpRU3u d/A3Xt7JViGfXqMiUXF9F8T80nyqqhOulNOVl55AcRIEN9TWZ9ltzmnY0xnc6PMeMwerV2sq UJ1lEHWBjTunWCqnXjVCfoCkfqQIXbo1EtFf/TnJ8bMTg5FZcw51PTrhsqXp6Yy64LkOFsSY 80XcMsk2lozDDfZ7gCnqxzMjqWfUGbP5id+UnQ7khztANYQ/UnYkPBVUzU8vAV90tZCsFZ6y DehmpQEv3JoUf71yExckEc2T33hSOxbB6hF/PeqC7wq+X49KF/MG7bpdw/aP9NbiSrtlAUfJ 2OLWtcb3K3Ungm3smH14xJ0QfnnKS4CBJKqwvwU9F2I1V/3LjVclsGlqu7AviHL5jAteUin0 h4uywiYw806PU3wPYQHaJAZ0bCsC5FrNHINZ0//YYHDebQzDWwnOO3W7Sx9vjG4m/jCZEF+M jyqO16gW4Tc+cbe/dco5xl50JOfFrZNHRZciLeWG8Tt8djQi9hLWtQ2q2S5caxrF0A2yW0f8 XG2ypM5gCpXo7XCS5fAayLn/9bnhF5/4M/YABL+CFe6xx0zkJV+uUrS0VCMwB1ZxFIf8HKn/ C5ad0BSjQjzWrh0uBvwajf+DGjU9WabJNlVZYYdO5ZH4p6t7UdfDfogEMrg4mGNxSjg9HGeH P9+ogw6KGwXoVywuI3G0J66ErEJwR2+OXHNVAzDYZkClCR8dRSSbXp0sZV9e9U4Gye16l5lk 6dK5T/VI3BCde7Ja6FgVvz2oRfKYtYOjE+yJTOjV/4zK+5yBz4ije/06JDPoPU/Rn3IRkePR p5xu1e1vdxc8oGRGGzBnqXsicoMuSadnQpoDVph4Agt5Tl5Zyi87cLNtTFzNQROxIyv7ANDD yhGkrgetGwYicjXFUpuDft6Ua7NdrflhORzqzkHjINrjuzr43VaVB/Q13lGMoLmWa29yMGnv sHEQ7ilqdH6b4XkbKm8cbPcL5S3hlRaaRc50AW7Eld/lgosrXKjhNxdUiQLuelEmRvRZGjAq y57Y2UJVuWiOucDHqNRSIriNbFPC9kWSwrPkkqJOl5sC+u9twSMndLuS5mMxmh0uq4QTzjmV ZB+uooD/XiK4SEVsuerfwZ7va3DG782Cqkj2QYJ9N2W1TOjTIx1vH+CzZ4OsF1YaVSWgOYBd Vis9V5PrNQB0FFcXYkqiNYswSqAtYDdIRT2LqSw/Wm8ibmj/QC+9AQ6a60+VoqlZylPHtLBe Yhpy4GthWT/FK3yAYOG8TvQ+0IOLTC8CMNYd3E4r7fmpUi41eYtzcF3FYLbGg7GG6wgV+Dx9 AKmd3AmMpVe7S3KZDo1XmLp+LjJsbBKMQpKZUgNP9GTkhG3lJQKekEkS4DpoPpAbwAFHolxa XPF7mlJe+BI/l1WtsIt46AddTvfVM7b46W12vmDXacNvNigOJkdrzc4aggi6/WnB3aOW0evz M/RykhQQKCS5HUEFuGKxQ//om7PEdx8T5JxQAa43bHok48tylPBNvpALN/u7v23IzDGhkUGn zcWAHy5qcIPDbkFQKFn64fxQonzmS+RfRQ6f4XqHHOyIic5tpIHIc93cS0fpw7mhO8MCHOJX n8c0xaMvO5K5An66jxwfsUit5wPi6aoSaQPeedFaOmN6p9NoIblxnHlYz3dXsq83IDG2axHQ RQVLGgx+KSWpDEvI9iCIjf0h4b64dDy6nMnAO9ayMQVV1WQL2Q2aw3nWZY0TYrj4oCCTD3fS Zghyj26QouqIwGhB2B8WUrpZ2XMDB9Sz21o62HCR4qDOJaaeI8zRNAXwM+ob6M1NPSDXUnTb yBOovFvC2muU8kH/XPT1oXBHhBtWqow3XJQ6qN1HHRy0jVdRR7HJc5cDGtsOLhjvGLBPnk+l bnoPh2HqVsl4+0lDJzIRqfMJw80LBWHS9mKnNWzBQx9skzgImLDrmAG3OwoeZZc5dS2TOnc/ 1Fq07G7imeI52FZog1UQJA7RtRQYzul4MFidHAJs2/enzg1vzoV8zGrjLMBtwDBwvEHh0twG CSd1MGregkqN2yWe/BRGNRoHNNsaBxyd8hLUaMpQpM2CFX6oBwoSusPJxElw1H0h4LCynPTQ C5sT0eUeKvJRxfv9hjwiI9dtdU1/9AcF3doB9cKi5eGMgkeZk50iYEVdO6HMJOq4Y6/rSrQF CVeRaC3Nv8pDBxnsERHI+JEkCnqKfKrKzwnlJj+a2CuBIYxNDQczuuHwv+0444G1xH98//jh 7eGiDpN1KBAz3t4+vH0wpveAKd9+/Pvrt389iA+vv/94++a/FtCBrJLToJH7GROJwFdUgDyK G9l/AFZnJ6EuTtSmzeMAm2WdwZCCcKhJ9h0A6j9EXB6LCbNysOuWiH0f7GLhs0mamOtmlukz LNJjokwYwl7bLPNAFAfJMGmx32IF7xFXzX63WrF4zOJ6LO82bpWNzJ5lTvk2XDE1U8IMGzOZ wDx98OEiUbs4YsI3Wta11q74KlGXgzLnfMbQ0J0glAMPQsVmiz3mGbgMd+GKYgdrl5GGawo9 A1w6ima1XgHCOI4p/JiEwd5JFMr2Ii6N279Nmbs4jIJV740IIB9FXkimwp/0zH674Y0PMGdV +UH1wrgJOqfDQEXV58obHbI+e+VQMmsa0Xthr/mW61fJeR9yuHhKggAV40bOfOBVUK5nsv6W Ilkdwsx6hQU5LNS/4zAgimNnb8dMEsBWxiGwp+59tgf+xsiyogSYqRpepFgvxwCc/4NwSdZY g83koEwH3TySom8emfJs7GtLvEpZlGiXDQHBGXFyFnrnk9NC7R/7841kphG3pjDKlERzhzap sg7cZAyOOabNquGZ7emQN57+J8jmcfRKOpRA1XrH24gcZ5OIJt8HuxWf0/YxJ9no370iZwoD SGakAfM/GFDvpeuA60YeDKfMTLPZhNbF+NSj9WQZrNjdvU4nWHE1dkvKaItn3gHwa4v27CKj jx+wczGjxehC9haIoqLdbZPNyrH1izPidCax+v46stqFmO6VOlBA708zZQL2xoWU4ae6oSHY 6puD6LicSwrNL+tuRn+juxnZbvOX+1X01sGk4wHn5/7kQ6UP5bWPnZ1i6H2qosj51pRO+u5r 8XXkPqCfoHt1Moe4VzNDKK9gA+4XbyCWCklNXKBiOBU7hzY9pjbnDWnmdBsUCtilrjPncScY mOgrRLJIHh2SGSyOaqOQTUWesOGwjj6OrG8hOUwcALiakS02aDQSTg0DHLoJhEsJAAGWNqoW +6waGWuaJrkQz6sj+VQxoFOYXB4kdmBjf3tFvrkdVyPr/XZDgGi/BsBsXz7++xP8fPgJ/gch H9K3X/749Vdw8Do6lv8vN/mlbNEMO73F+E8yQOnciGexAXAGi0bTa0FCFc5vE6uqzXZN/3XJ RUPiG/4Aj4yHLSxZosYA4MlHb5XqYtzs3a8bE8evmhk+Ko6AU1S0TM6vWBbrye31DRg0mm9T KkXe1Nrf8G68uJGrTIfoyytxlzHQNX4tMGL4amPA8LDUG7wi834b6xY4A4tauxLHWw/vRPTI QocEeecl1Raph5XwtCb3YJiqfcys2guwlZjwqW6le0aVVHQ5rzdrT/YDzAtE1Tw0QO4RBmCy bGg9baDP1zzt+aYCses63BM8HTk9R2jBGdtDGBFa0glNuKDKUasfYfwlE+rPWhbXlX1mYDBB At2PSWmkFpOcAthvmRXPYFhlHa+UdstjVmTE1Thes863HVqmWwXoVhAAz2uxhmhjGYhUNCB/ rkKqyD+CTEjGUSfAFxdwyvFnyEcMvXBOSqvICRFsMr6v6V2FPc6bqrZpw27FbStINFdbxZxD xeRuz0I7JiXNwP4lRb3UBN6H+BpqgJQPpQ60CyPhQwc3YhxnfloupLfRblpQrguB6OI2AHSS GEHSG0bQGQpjJl5rD1/C4XYDKvHZEITuuu7iI/2lhB0xPhlt2lsc45D6pzMULOZ8FUC6ksJD 5qRl0MRDvU+dwKUNXIMdsOkf/R5rnDSKWYMBpNMbILTqjal8/MIC54mtFyQ3aj7N/rbBaSaE wdMoThpf/d/yINyQYx/47ca1GMkJQLITzqliyS2nTWd/uwlbjCZsjvNnxzkpMbmPv+PlOcXq XnCS9ZJS8xrwOwiam4+43QAnbO4KsxK/Z3pqyyO5Zx0AI8h5i30jnhNfBNDi8QYXTkePV7ow emOmuKNke9p6IwoU8Jy/Hwa7kRtvHwvRPYBFnk9v378/HL59ff3wy6sW8zzXdjcJxopkuF6t ClzdM+qcLGDGKtxa3wTxLEj+be5TYvg08Zzm+G2I/kVtnYyI82AEULtro9ixcQBy62SQDvtB 002mB4l6xgeRouzIAUy0WhHVxqNo6JVQqhLsiA/eNGss3G7C0AkE+VFTDRPcEyMluqBY+SIH rRvRzb4mc1EfnBsO/V1wV4U2KFmWQafS8p1324O4o3jM8gNLiTbeNscQH/9zLLPtmEMVOsj6 3ZpPIklCYvuTpE56IGbS4y7EGvw4t6Qh1x6IckbWtQDFavx21yowHKq8pSfopbFNRCLDkDwK mVfEYIVUKX4bo3+BjR5ihUPL4Y7B7ymY+YtUxsQUMk3zjG6rCpPbZ/JT96bahfKgMleTZob4 DNDDb6/fPlg3cp6/cRPlfExc12IWNTesDE6FSoOKa3FsZPvi4sZ3+FF0Lg5Sdkk1TQx+226x 1qcFdfW/wy00FIRMJUOytfAxhd/mlVe0F9I/+po4Xx2RaY0YPM/9/sePRY9BsqwvaCybn1Zq /0yx41HvA4qcmK+1DBjLIgaxLKxqPfdkjwUxBmaYQrSN7AbGlPHy/e3bJ5h/JxPP350i9kV1 URmTzYj3tRL4Ls1hVdJkWdl3PwercH0/zPPPu21Mg7yrnpmssysLWsPuqO5TW/ep24NthMfs 2fFCNiJ69kAdAqH1ZoNFTofZc0z7iB3vTvhTG6zwTTghdjwRBluOSPJa7YhO80SZN76gl7iN NwydP/KFy+o9sYoyEVSnjMCmN2Zcam0itutgyzPxOuAq1PZUrshFHIXRAhFxhF4Sd9GGa5sC y1wzWjcBdjQ3Eaq8qr6+NcTe5sSW2a3FM9NEVHVWgtjK5VUXEhxBsFVd5elRwpMEsPnJRVZt dRM3wRVGmd4NnrI48lLyza4zM7HYBAusSTN/nJ5L1lzLFmHfVpfkzFdWtzAqQE+qz7gC6CUO VKK49mofTT2y8xNaCuGnnqvwOjFCvdBDiAnaH55TDoZnRfrfuuZILbqJGhSm7pK9Kg4XNsho q5yhQCp4NNfZHJuBAStiOMfnlrNVGdxZ4NdSKF/TkpLN9VglcJDCZ8vmprJGYv16i4q6zjOT kcsckmJDnHtYOHkW2IWMBeE7HW1WghvurwWOLe1V6fEpvIwc7Vr7YVPjMiWYSSqyjsuc0hw6 jRoReK+hu9scYSailEOxPvaEJtUBG0Ge8NMRG32Y4QYrqhG4L1jmIvXkX+CHohNnbgVEwlFK ptlNUo3giWwLvAjPyZkXh4sErV2XDPEDkonUMnMjK64M4H4yJ/vpuexgKrpquMwMdRD4bfDM geII/703meofDPNyzsrzhWu/9LDnWkMUWVJxhW4veutyasSx47qO2qywAs5EgBB2Ydu9qwXX CQHujXsRlqFn06gZ8kfdU7T0wxWiViYuOQ9iSD7bumu89aEFnTM0pdnfVkEsyRJBDFvPlKzJ uydEnVp80oCIsyhv5BUB4h4P+gfLeBqUA2enT11bSVWsvY+CCdSK0+jLZhBuf+usaSV+VYt5 kapdjB21U3IXY/uEHre/x9FZkeFJ21J+KWKjdxXBnYRBI6YvsJkrlu7baLdQHxd4ntolsuGT OFzCYIV9eHhkuFApoI5dlVkvkzKOsBBMAj3HSVucAuzXgPJtq2rX5LofYLGGBn6x6i3vGm/g QvxNFuvlPFKxX2EFYMLBsokt7mPyLIpaneVSybKsXchRD60cHy/4nCelkCAdnPctNMloU4cl T1WVyoWMz3o1zGqek7kMwUgUT9LXRphSW/W82wYLhbmUL0tV99gewyBcGOsZWRIps9BUZrrq bzFxtOwHWOxEehcXBPFSZL2T2yw2SFGoIFgvcFl+hDthWS8FcERSUu9Ft73kfasWyizLrJML 9VE87oKFLq/3i1pkLBfmrCxt+2O76VYLc3QhT9XCXGX+38jTeSFp8/+bXGjaFvzsRdGmW/7g S3II1kvNcG8WvaWteQO12Pw3vbsPFrr/rdjvujscNkztckF4h4t4zihcV0VdKdkuDJ+iU33e LC5bBbleoB05iHbxwnJitNTtzLVYsFqU7/BGzeWjYpmT7R0yM7LjMm8nk0U6LRLoN8HqTvaN HWvLAVL3zt4rBLx518LR3yR0qsBD2SL9Tihi8darivxOPWShXCZfnsHEjLyXdquFkWS9uWAt WzeQnVeW0xDq+U4NmP/LNlySWlq1jpcGsW5CszIuzGqaDler7o60YEMsTLaWXBgallxYkQay l0v1UhNHCJhpih4fr5HVU+YZ2QcQTi1PV6oNyFaTcsVxMUN6zEYo+pyWUs16ob00ddS7mWhZ +FJdvN0stUettpvVbmFufcnabRgudKIXZ5tOBMIql4dG9tfjZqHYTXUuBul5IX35pMiTpuHM T2KzIBaLY/DZ2vVVSc4iLal3HsHaS8aitHkJQ2pzYBr5UpUCDEiYwz+XNlsN3QkdecKyh0KQ d3HDjUbUrXQttORcefhQVfRXXYmCuNscroWKeL8OvJPqiYQXyMtx7YH0Qmy4WkpU/ejFg0P2 ne4rfC1bdh8NlePRdtGDPBe+thDx2q+fUx0KH4MX81qOzrwyGirNkipd4EyluEwCM8dy0YQW ixo4+cpCl4KzdL0cD7THdu27PQsONymjSjxtHzA9Vgg/uedM0EfzQ+mLYOXl0mSnSw6tv9Ae jV7rl7/YTAphEN+pk64O9YCrM684F3vr6Xa6RE8E20h3gOLCcDGxaD/At2KhlYFhG7J5jMFL AduvTfM3VSuaZ7Cxx/UQu0nl+zdw24jnrOTa+7VEV6RxeunyiJuPDMxPSJZiZiRZKJ2JV6NJ IejmlcBcHiB3meO1XP/vILyqUVUyTFN6FmyEXz3NNdzqDrEwNRp6u7lP75ZoY9PCDAum8htx BRWy5a6qxYbdOB3OXFNI98TDQKRuDEKq3SLFwUGOK7SRGBFXijJ4mMI1jMLvOWz4IPCQ0EWi lYesXWTjI5tRXeE8KnzIn6oH0FXAtjJoYfUicIaN5llXP9RwPQqFf5EIvYxXWAXHgvpvaobe wnplIXeCA5pIcmVnUS0+MChRCbPQ4OCBCawhUFTxIjQJF1rUXIZVrj9c1MRzvP1EkNW4dOxF OcYvTtXC2T2tnhHpS7XZxAyerxkwKy7B6jFgmGMRDw7sB508ruEnR36cDov1T/Tb67fX92A+ wFMcBKMHU0+4Yr3UwRdc24hS5cb8hcIhxwAcpmcfOB2bdQJvbOgZ7g/SOgucFT5L2e31utVi y1nj87EFUKcGRzHhZotbUm8xS51LK8qUKJAYQ4Atbb/kOckF8U+UPL/ArRga5WBtxz4ay+m1 Yies7QeMgm4grPX4RmbE+hPWSateKmxTVWJnT64qVNmfFFJes6ZSm+pCPOBaVBFBo7yAJSls 5+KaoHTzVMvk5gEi9R6RZtciK8jvRwtYt/Bv3z6+fmKs9tjaz0STPyfEsKEl4hDLiQjUGdQN eBLIUuM/mXQ9HO4I7fDIc9SlPCKIKhwmso64fEcMXsowXphjoANPlo0x5Kl+XnNso7uqLLJ7 QbKuzcqUGBjBeYtS9/qqaRfqRhjNvP5KjYniEOoMz7dk87RQgVmbJe0y36iFCj4kRRhHG4HN bpGEbzzetGEcd3yannFDTOrJoj7LbKHx4BKX2HWl6aqltpXpAqFHusdQP91mWJRfv/wDIjx8 t+PDWHjxdAuH+M47coz6cydha2zxlTB6oIvW4x5P6aEvsUHngfB10wZCbwkjapkT4354WfgY 9MKcnME6xDxcAieEXqGpZ9kZf5FE32Im8J0OQoU/VDV8vvppn7W46U8TFp6LGvI8N/Wwn2Ce SHjNOy6K1OXqEOUdnvkHzJjyPBE/mmOB5FFe/UpXSVJ2NQMHW6lAyKYCtUvfiUh0djxW1X63 07PgIWtSkfsZDobZPPzUaKlSS0lSyxkNCHzsHDcIlO9acbrH/x0H3dxOs+4kjQMdxCVtYK8f BJtwtXJHxLHbdlt/BIGZbTZ/uJQQLDPY7arVQkRQ5TIlWpo1phD+rNH4kyQI2bq72wpwR2ZT h14Ejc3jI3IHCLg8yWu25AkY7xXgrl6eZKIlEH86V3oPrfwywir8EkQbJjyxQjsGv2aHC18D llqqueqW+5+b+kNdY8u1L/NDJuB4RRE5kWH7sddNEr4jaLmRk7bJrbKbmysobhMTm3ppgFfB ZfvIYcNboEmMNiheXvPa/8C6Jore52syOgCdZX7rfTlxXU/LupCgeZPm5CwHUFhUnWdiFhdg 0t3o27KMap23+UANj+bNx8BRu5MXFrktoKdPB7qJNjmneNGxmcKhRnV0Qz8mqj8U2AaPFcoA NwEIWdbG5uQCO0Q9tAynkcOdr9MbLde1+QQZx0N6W1tkLFuGDdaGmonJ96zHOKNuJozdRo5w baKiKLiDznDWPZfYbDUopErrPMuIXvZR3sP75X3vtAnDoj28EtZidb8mZ24zim9uVNKE5PSv Hu1o4f36YkHGaPASzvWTC0/zDJ5dFd7Nton+U+N7XwCkcq/wLOoBzr3SAIIyrWOMCFP+Mx7M lpdr1bokk9pVFxvU2bpnplRtFL3U4XqZce7uXJZ8lq6zwUTWAOj1Mn8mc9+IOM87J7hCo9iq 6E7N6R+k2BcsYcI8GiKHs7qyjAq8rk80PUv7CrvGYrrB9M6MPpvRoDVjbO3l/vHpx8ffP739 qUsCmSe/ffydLYFevw/2JEsnmedZiX1eDIk6+tEzSuwmj3DeJusIK7SMRJ2I/WYdLBF/MoQs YcnyCWJXGcA0uxu+yLukzlPcUndrCMc/Z3kNQuSlddrFapiTvER+qg6y9UH9iWPTQGbTKd3h j++oWYap6UGnrPHfvn7/8fD+65cf375++gQ9ynv5ZBKXwQZLNhO4jRiwc8Ei3W22HhYTa4Cm Fqy3NwpKosNlEEXuQzVSS9mtKVSa62QnLeuLRneqC8WVVJvNfuOBW/JG1WL7rdMfr9g+4wBY BcR5WP71/cfb54dfdIUPFfzw3591zX/66+Ht8y9vH8DW6k9DqH/oDft73U/+x2kDs/A6ldh1 bt6MLXEDgzmr9kDBBOYZf9ilmZKn0hjVoVO6Q/oeJpwA1qv8X0vR8c4WuOxIVmwDncKV09H9 8pqJxRqhkeW7LKHWraC/FM5AloWeQWpvanz3st7FToM/ZoUd0wjL6wQ/gjDjnwoVBmq3VN/A YLtt6PTmynnqZbCbM7/oob1Q38yuG+BGSufr1Lkv9LyRZ26PLtrMDQqy03HNgTsHvJRbLXeG Nyd7Ldg8XYzdSgL7R2QY7Y8Uh7flovVKPLyodqp2cGZAsbzeu03QJOZ41QzN7E+9iH7RexlN /GTnw9fBwjE7D6aygpc/F7fjpHnpdNxaOFdWCOxzqlBpSlUdqvZ4eXnpKyrtw/cKeOJ2ddq9 leWz8zDITD01vDWHK4bhG6sfv9nFZ/hANAfRjxte0oEXpTJzut9REQFkcXWh/eXiFI6ZDww0 2o5y5hEwB0HPq2YcljsOt8+xSEG9skWo9ZK0VIBoaVeRvWV6Y2F6dFR7Vm0AGuJQDN1T1PKh eP0OnSyZ113vxTHEskc7JHewHIofTRioKcBof0SsP9uwRAa20D7Q3YYefQDeSfOvdaBGueEk nQXp8brFndOyGezPiojJA9U/+ajrRsOAlxY2lfkzhUff3xT0j5FNa43Lj4PfnPsYixUydU5R B7wgpyYAkhnAVKTzItq8NDLnTt7HAqxny9QjwLL/Mc86j6CLICB6jdP/HqWLOiV45xypaigv dqs+z2sHreN4HfQNNt07fQJxrTGA7Ff5n2S9Juj/JckCcXQJZx21GF1HTWXpXW7vVy48Y5VP vVJOspWdQh2wEHov5+bWSqaHQtA+WGFnsAamrrIA0t8ahQzUqycnzboToZu57wXLoF55uNN3 Daso2XofpJIg1sLtyimVOru/9YB18/HO8gEzs3jRhjsvp7pJfYS+OTWoc0Y6QkzFqxYac+2A VNd1gLYu5Eslpjd10ukcbXZqBHkCMqHhqlfHXLh1NXFUp85QnrxiUL1dy+XxCKfvDtN1zgTP 3CxqtDPOHSnkCEEGc4c23Ocqof+hXtSAetEVxFQ5wEXdnwZmWsbqb19/fH3/9dOwnjmrl/5D Tg/MaKyq+iASa6zc+ew824bdiulZdP61nQ3OC7lOqJ714lvA4W7bVGTtKyT9ZTRiQXsVTidm 6ozPX/UPcmBi1Z6URDvm7+OW2sCfPr59wWpQkAAco8xJ1thugP5BLcBoYEzEP0mB0LrPgLPX R3NeSlIdKaM+wTKeUIq4YUWZCvHr25e3b68/vn7zjw7aWhfx6/t/MQVs9ZS4AZt6xsX8Xzze p8QRC+We9AT6hMSwOo626xV1GuNEsQNoPuz0yjfFG05upnINDg9Hoj811YU0jywLbKgGhYcD n+NFR6NqIZCS/h+fBSGsvOoVaSyK0YhF08CEF6kPHoogjld+IqmIQdPkUjNxRlUGL1KR1GGk VrEfpXkRgR9eoyGHlkxYJcsT3s5NeFvgB+YjPOpM+KmDZq4ffnA97QWH7bRfFhCXfXTPocPh ywLen9bL1ManjOgccHU/StoeYY50nFu1kRu8fpGeOnJu37RYvZBSqcKlZGqeOGRNjr0gzF+v dyNLwfvDaZ0wzTTcPPmElotYMNwwnQbwHYMX2HrzVE7jxHTNjDMgYoaQ9dN6FTAjUy4lZYgd Q+gSxVt8H4+JPUuA75+A6fkQo1vKY49NKRFivxRjvxiDmReeErVeMSkZkdQstdTaDuXVYYlX acFWj8bjNVMJunzkTcyEn/v6yMwiFl8YC5qE+X2BhXhZkV2ZmQ+oJha7SDCzwkju1szomMno Hnk3WWbumEluSM4sN7nPbHIv7i6+R+7vkPt7ye7vlWh/p+53+3s1uL9Xg/t7Nbjf3iXvRr1b +Xtu+Z7Z+7W0VGR13oWrhYoAbrtQD4ZbaDTNRWKhNJoj3rQ8bqHFDLdczl24XM5ddIfb7Ja5 eLnOdvFCK6tzx5TSbHFZFPyYx1tOyDC7XR4+rkOm6geKa5XhXH7NFHqgFmOd2ZnGUEUdcNXX yl5WaZbjJzsjN+1SvVjTAX+eMs01sVrGuUerPGWmGRybadOZ7hRT5ahk28NdOmDmIkRz/R7n HY07vOLtw8fX9u1fD79//PL+xzdGYT2Tej8GKie+aL4A9kVFzskxpTd9khEC4bBmxXySOVlj OoXBmX5UtHHACayAh0wHgnwDpiGKdrvj5k/A92w6ujxsOnGwY8sfBzGPbwJm6Oh8I5PvfJe/ 1HBeVJGSU/tJTlfrXc7VlSG4CckQeO4HYQROX12gPwrV1uB+LpeFbH/eBJPKY3V0RJgximye zLmisyP1A8OZCrbCbLBhX+ugxnLmalYQefv89dtfD59ff//97cMDhPB7u4m3W49uvz8T3L0A saBzE25Bei1in2fqkHrH0TzDcTxWNLZPfpOif6ywBXYLuzflVm/FvWOwqHfJYF8M30TtJpCB NiA5DLVw4QLk9Ye92m7hn1Ww4puAuRe2dENvCQx4zm9uEWTl1oz3ysG27SHeqp2HZuULsfpj 0doaKXV6hz21p6A5gVuoneGulvRFUYhNGuohUh0uLicrt3iqhCMu0ORxurSfmR5Axnu03/kT fKJvQHPa6wS0Z8bx1g3q2MawoHckbGD/nNe+Mu/izcbB3JNeC+ZuU764bQBuy4/0wOzOKJ0U WAz69ufvr18++KPXs3I8oKVbmtOtJ8oUaM5wa8igofuBRokr8lF48e2ibS2TMA68qlfr/Wr1 s3Ob7Xyfnb2O6d98tzXg4M4r6X6zC4rb1cFdm2UWJPeGBnonype+bXMHdhVRhpEa7bH/xQGM d14dAbjZur3IXaqmqgfLDN74AEsjTp+fX004hLED4g+GwRIAB+8Dtybap6LzkvAsRhnUtfY0 gvaEY+7qfpMO6nDyb5raVVezNZV3h6OH6Rn17PVQH9GSdKr/E7gfaPy2GQpro9r5ME2i0Hwm Uu31Sj5dz9z9Ir3kBls3A/OWau9VpB2i3tcnURTHbkvUUlXKncE6PTOuVxEuOFNAa19eHe4X nKi4TMkx0Whhq+TxguajG/ZIE8B90SigB//498dBrcW71tIhrXaHMTeOV5uZSVWoZ5glJg45 pugSPkJwKzhiWNmnr2fKjL9FfXr9vzf6GcMtGriSIxkMt2hED3+C4QPwuTsl4kUCXGelcO03 zxIkBLYrRaNuF4hwIUa8WLwoWCKWMo8iLTkkC0WOFr6WKBBSYqEAcYbPTikT7JhWHlpz2izA o49eXPEmz0BNprC1WgQaIZfKvi4LIjBLnrJCluipCR+IHpo6DPy3JQ+fcAh7iXOv9Ebbl3ns gsPkbRLuNyGfwN38wQhPW5UZzw7i4B3ub6qmcZUwMfmCnX5lh6pqrU2fCRyyYDlSFGOlZC5B CU/n70UDp975s1tki7pKbnUqLI9m+WEvItKkPwhQ00IHRINBG5gAyBRsYScl48XcweAG/QSd XAuaK2ybdMiqF0kb79cb4TMJNZozwjAg8dUCxuMlnMnY4KGP59lJ7+Wukc+ACRAf9V6Hj4Q6 KL8eCFiIUnjgGP3wBP2gWyTo+xCXPKdPy2Ta9hfdE3R7UWc3U9U48u5YeI2TWxoUnuBToxvb UEybO/hoQ4p2HUDjuD9esrw/iQt+eDImBIZid+RVlcMw7WuYEAtKY3FH01Q+43TFEZaqhkx8 QucR71dMQiDL4y33iNP9/pyM6R9zA03JtNEWO+ZD+QbrzY7JwNpiqIYgW/ymA0V2Ng+U2TPf Y+8Bi8PBp3RnWwcbppoNsWeyASLcMIUHYoe1WBGxibmkdJGiNZPSsIvZ+d3C9DC79qyZ2WL0 0OIzTbtZcX2mafW0xpTZKGtrmRdrdkzF1nM/lnbmvj8uC16US6KCFVYHPN8K+khS/9SSd+pC g5a2PUe09iZef3z8P8YHmDVTpcAeYkQU62Z8vYjHHF6AJfclYrNEbJeI/QIR8XnsQ/IOcyLa XRcsENESsV4m2Mw1sQ0XiN1SUjuuSlTiKNJOBD1jnfC2q5ngqdqGTL56/8KmPljGI9aOR05u HvVu++ATx12gpfsjT8Th8cQxm2i3UT4x2o9kS3Bs9R7r0sLK5pOnfBPE1PjFRIQrltCChmBh pgmHt0ylz5zleRtETCXLQyEyJl+N11nH4HAMTIf3RLXxzkffJWumpHqdbYKQa/Vclpk4ZQxh 5kWmGxpizyXVJnr6Z3oQEGHAJ7UOQ6a8hljIfB1uFzIPt0zmxrI8NzKB2K62TCaGCZgpxhBb Zn4DYs+0hjmi2XFfqJktO9wMEfGZb7dc4xpiw9SJIZaLxbVhkdQRO1EXeddkJ763twkxMTxF ycpjGByKZKkH6wHdMX0+L/BD1RnlJkuN8mG5vlPsmLrQKNOgeRGzucVsbjGbGzc884IdOcWe GwTFns1N75QjproNseaGnyGYItZJvIu4wQTEOmSKX7aJPYaSqqXGVgY+afX4YEoNxI5rFE3o PRzz9UDsV8x3joqHPqFExE1xVZL0dUw3T4jjPv8Yb/aoJmv6rnsKx8MgiITct+pJvk+Ox5qJ I5toE3LjThNUUXEmarVZr7goKt/GesnkekKotzuMUGXmdHYcWGK2KTzvTFCQKOZm92GC5WYG 0YWrHbdU2JmJG0/ArNecGAdbr23MFL7uMj2PMzH0nmCtd4pMr9PMJtrumOn3kqT71YpJDIiQ I17ybcDhYMKYnUfxFfjClKnOLVfVGuY6j4ajP1k44UK77+onCbDIgh3XnzItmq1XzHDXRBgs ENtbyPVaVahkvSvuMNwcablDxK1yKjlvtsYwWcHXJfDcLGeIiBkmqm0V221VUWw5SUKvcEEY pzG/J9LbOK4xjY+ukI+xi3fcBkDXaszOHqUgDxMwzk2hGo/YaahNdsw4bs9FwgkebVEH3Jxu cKZXGJz5YI2zMxzgXCmvUmzjLSO/X9sg5GTAaxuH3JbxFke7XcRsUoCIA2avBcR+kQiXCKYy DM50C4vDzAHqRv48rPlcz5wts7pYalvyH6THwJnZqVkmYynnAneaCvO2EVjSMLKCQIUdAD2S RCsVdaM6clmRNaesBAO9w+F8b5QY+0L9vHIDV0c/gVsjjTO9vm1kzWSQZtYAxam66oJkdX+T xpXsfz3cCXgUsrHmTx8+fn/48vXHw/e3H/ejgPFn6y3yP44y3A/leZXAaovjObFomfyPdD+O oeHRtvmLp+fi87xTVnRmWV/8lk+z67HJnpa7RFZcrM1on6LKZsYk/JjMhIKZEA80D9R8WNWZ aHx4fL3LMAkbHlDdUyOfepTN462qUp9Jq/EqF6ODVQA/NLgeCH0clEVncPCJ/uPt0wMYkPhM LCsbUiS1fJBlG61XHRNmurW8H242G85lZdI5fPv6+uH9189MJkPRh2dT/jcNN5kMkRRauOdx hdtlKuBiKUwZ27c/X7/rj/j+49sfn83rzcXCttK4P/CybqXfkeGRecTDax7eMMOkEbtNiPDp m/6+1FaX5PXz9z++/Lr8SdYQHldrS1Gnj9ZTReXXBb5OdPrk0x+vn3Qz3OkN5jqhhQUEjdrp KVKbFbWeYYTRe5jKuZjqmMBLF+63O7+kk463x0w2Gv9yEceqyQSX1U08V5eWoaxZyt5c32Yl rEQpEwocx5uX0ZDIyqNHPV5Tj7fXH+9/+/D114f629uPj5/fvv7x4+H0VX/zl69E42WMXDfZ kDLM1EzmNIBewJm6cAOVFVY+XQplbGma1roTEC95kCyzzv1dNJuPWz+pdWXgG2ipji1jiJPA KCc0Hu3ptx/VEJsFYhstEVxSVv/Ng+fzM5Z7WW33DGMGaccQww2+TwzmgX3iRUrjYcVnRscr TMHyDtw9eitbBFZK/eBCFftwu+KYdh80BeysF0glij2XpFU6XjPMoBfOMMdWl3kVcFmpKAnX LJPeGNBakmEIY4KE6xRXWSackdim3LTbIOaKdCk7LsZoDJaJoXdMEegBNC3Xm8pLsmfr2epD s8QuZHOCM2e+AuyVcsilpmW3kPYa46OKSaPqwE41Capkc4Q1mvtq0I7nSg/a3wxuFh6SuDV0 c+oOB3YQAsnhqRRt9sg192iomuEGTX62u+dC7bg+opdeJZRbdxZsXgQdifaRu5/KtCwyGbRp EOBhNm874c2cH6E2L5i5b8hlsQtWgdN4yQZ6BIbkNlqtMnWgqNWodj7UathSUAuFazMIHNDI nC5o3pQso64uleZ2qyh2ylucai350G5Tw3fZD5tiF9ftutuu3A5W9iJ0amWWPeqAKARNBHEq NMsMl3KNNNkvRY4bYlSe/scvr9/fPsxrZvL67QNaKsEnU8IsH2lrrW6Nir9/kwzoOzDJKHBi WyklD8TSOTaNB0GUsTGH+f4A9kOIoXJIKpHnyuigMUmOrJPOOjIK3YdGpicvAthevpviGIDi KpXVnWgjTVFrxBkKY5w68FFpIJajCpy6kwomLYBJLxd+jRrUfkYiF9KYeA7W87ADz8XniYKc 0NiyW4tNFFQcWHLgWCmFSPqkKBdYv8qIaR9jC/iff3x5/+Pj1y+jgyxv81IcU2d7AIiv3wio dRp2qokWgwk+G/mjyRiHLGBRLsHmFmfqnCd+WkCoIqFJ6e/b7Fd4IjGo//bFpOGo6s0YvUIz H2/NULKgb5EaSPcRy4z5qQ84sXBlMoCXlsGGfqP3YHMCYw7EDzVnEKsgw1O3QS2ShBx2BMS4 5IhjLZEJizyMqE4ajLwsAmTYpee1wM6GTK0kQdS5bTmAfl2NhF+5vg9zC4cbLd15+Flu13qZ orY/BmKz6Rzi3IIBVSUT9O0gikn8tAYAYhwakjMPqpKiSomjNE24T6oAs75/Vxy4cbuSqyY5 oI7+44zit0wzuo88NN6v3GTtc2SKjZs5tFV46ayXUNoRqeIpQOQRDcJBSKaIr886OV8lLTqh VAt1eK7lWJI2CRu/ws6M5huLMaWa3j1h0FGZNNhjjC99DGT3PE4+cr3buv6FDFFs8O3QBDmz u8Efn2PdAZxBNrgHpd8gDt1mrAOaxvCmzh6ztcXH99++vn16e//j29cvH99/fzC8ORv99s9X 9hACAgwTx3zo9p8n5CwnYMu5SQqnkM6TB8Ba2YsiivQobVXijWz3WeIQI8fOekGJNlhh1V77 ZhBfrvvexE1K3tvCCSVKuWOuznNIBJMHkSiRmEHJ80SM+vPgxHhT5y0Pwl3E9Lu8iDZuZ+Zc UhnceRZpxjN9ImwW2OF16l8M6Jd5JPiVEVtgMd9RbOA21sOClYvFe2y9YcJiD4PbPwbzF8Wb Y7fKjqPbOnYnCGtANK8dU4kzZQjlMdgS3XgqNbQYdeywJMxNkX0Nl9mRtrMPnImj7MBhYpW3 RIlyDgA+by7WVZW6kE+bw8BFm7lnuxtKr2unGLszIBRdB2cKhNEYjxxKUTkVcekmwtbDEFPq f2qWGXplnlbBPV7PtvBUiQ3iyJ4z44uwiPMF2Zl01lPUps6TF8psl5logQkDtgUMw1bIUZSb aLNhG4cuzMilu5HDlpnrJmJLYcU0jpEq30crthCgSRbuAraH6ElwG7EJwoKyY4toGLZizSuZ hdToikAZvvK85QJRbRJt4v0Std1tOcoXHym3iZeiOfIl4eLtmi2IobaLsYi86VB8hzbUju23 vrDrcvvleERxE3HDnsNxsU74Xcwnq6l4v5BqHei65DktcfNjDJiQz0ozMV/Jjvw+M/VBCsUS C5OML5Aj7nh5yQJ+2q6vcbziu4Ch+IIbas9T+G36DJsT76YuzoukKlIIsMwTW80z6Uj3iHBl fEQ5u4SZcZ9JIcaT7BGXn7Tow9ewlSoOVUV9RrgBrk12PFyOywHqGysxDEJOfy3wYQzidalX W3ZmBR3UYBuxX+QL4pQLI77TWDGcHwi+4O5y/PRguGC5nFTA9zi2B1huvVwWItkjEcozxoNE MKMvxxCuGhthiNiawHEW2RACUlatPBIbeoDW2MRuk7izILgpQVNFLrHVggZcoyRVCpLuBMqm L7OJmKNqvEk2C/iWxd9d+XRUVT7zhCifK545i6ZmmUILso+HlOW6go8j7ftE7kuKwidMPYHr SkXqTuitYpMVFTZZrtPISvrb91xmC+CXqBE399OoFx8drtViu6SFHnzMk5iOz6mG+qmENnYd I8LXZ+AhOKIVjzd98LttMlG84E6l0ZssD1WZekWTp6qp88vJ+4zTRWDrSBpqWx3Iid50WP3Z VNPJ/W1q7S8HO/uQ7tQepjuoh0Hn9EHofj4K3dVD9ShhsC3pOqOvA/Ix1m6cUwXW2lFHMFDp x1ADHpVoK8GdPUWMn10G6ttGlKqQLXFMBLRTEqPqQTLtDlXXp9eUBMN2KszVtLEUYX0LzJcd n8Fi4sP7r9/efFcBNlYiCnMcP0T+i7K69+TVqW+vSwHg6ruFr1sM0QgwpLRAqrRZomDW9ahh Ku6zpoGdTPnOi2W9TuS4kl1G1+XhDttkTxewgCHwscdVphlMmWg3aqHrOg91OQ/gWZmJATQb hfhHt7hIr+6ZhCXseUQhS5CmdPfAE6QN0V5KPJOaHIqsCMHkCC00MOaCrc91mklObiIseyuJ dRKTg5aWQCWQQVO4xzsxxLUwWsQLUaDCJdahuB6cRRWQosAn6YCU2CRNC7fXnu8yE1F0uj5F 3cKiG2wxlT6XAq6BTH0qmrr1L6oy41RCTx9K6b9ONMwlz5xrRTPI/HtE07EucFE8dWOr1/b2 y/vXz74rYghqm9NpFofQ/b6+tH12hZb9Cwc6KeuAFEHFhjgZMsVpr6stPnQxUfMYC5lTav0h K584PAE37SxRSxFwRNomiuwEZiprq0JxBDgdriWbz7sMVNzesVQerlabQ5Jy5KNOMmlZpiql W3+WKUTDFq9o9mBTgI1T3uIVW/DqusHvkAmB34A6RM/GqUUS4qMDwuwit+0RFbCNpDLyOAcR 5V7nhF8wuRz7sXqdl91hkWGbD/7arNjeaCm+gIbaLFPbZYr/KqC2i3kFm4XKeNovlAKIZIGJ FqqvfVwFbJ/QTBBEfEYwwGO+/i6lFhTZvqz37+zYbCvrSpchLjWRiBF1jTcR2/WuyYoYFUWM HnsFR3SysR7aJTtqX5LInczqW+IB7tI6wuxkOsy2eiZzPuKliagzNzuhPt6yg1d6FYb4JNOm qYn2Ospo4svrp6+/PrRXYzzRWxBsjPraaNaTIgbYNQ1NSSLpOBRUhzx6Usg51SGYUl+lIn71 LGF64XblPcckrAufqt0Kz1kYpQ5VCZNXguwX3Wimwlc98b1qa/inDx9//fjj9dPf1LS4rMgT TYxaSc6V2CzVeJWYdGEU4G5C4OUIvciVWIoFjelQbbElJ2EYZdMaKJuUqaH0b6rGiDy4TQbA HU8TLA+RzgLrRIyUINdZKIIRVLgsRso6l35mczMhmNw0tdpxGV6KtieX3CORdOyHGnjYCvkl AG32jstdb4yuPn6tdyv8mBLjIZPOqY5r9ejjZXXV02xPZ4aRNJt8Bk/bVgtGF5+oar0JDJgW O+5XK6a0FveOZUa6TtrrehMyTHoLySPiqY61UNacnvuWLfV1E3ANKV60bLtjPj9LzqVUYql6 rgwGXxQsfGnE4eWzypgPFJftlutbUNYVU9Yk24YREz5LAmyTZuoOWkxn2ikvsnDDZVt0eRAE 6ugzTZuHcdcxnUH/qx6fffwlDYgJYsBNT+sPl/SUtRyTYj1CVSibQeMMjEOYhINSZO1PNi7L zTxC2W6FNlj/C1Paf7+SBeB/7k3/er8c+3O2RdmN/EBx8+xAMVP2wDTJWFr19Z8/jBvvD2// /Pjl7cPDt9cPH7/yBTU9STaqRs0D2Fkkj82RYoWSoZWiJ6vO57SQD0mWjD7WnZTrS66yGA5Z aEqNkKU6i7S6Uc7ucGEL7uxw7Y74vc7jD+7kaRAOqrzaEkttwxJ128TYvsiIbr2VGbAtcnWB Mv3pdRKtFrKX19Y7zAFM9666yRLRZmkvq6TNPeHKhOIa/XhgUz1nnbwUg9neBdJxWmy5ovN6 T9pGgREqFz/5p9/++uXbxw93vjzpAq8qAVsUPmJsumU4GDRuQfrE+x4dfkOsVhB4IYuYKU+8 VB5NHHLd3w8Sq04ilhl0BrevNvVKG602a18A0yEGiotc1Jl7yNUf2njtzNEa8qcQJcQuiLx0 B5j9zJHzJcWRYb5ypHj52rD+wEqqg25M2qOQuAzW7YU3W5gp97oLglUvG2cmNjCtlSFopVIa 1q4bzLkft6CMgSULC3dJsXANb1XuLCe1l5zDcouN3kG3lSNDpIX+QkdOqNvABbCCIbhFV9yh pyEodq7qGu99zFHoidyBmVKkwwMYFoUlwQ4C+j2qkODywEk9ay81XMEyHU3Wl0g3BK4DvT5O bnCG9xjexHmd7hu8Tjg493EH5fC2M9FLWePvphDbeuz4BvNay6OWxlVNPKYxYRJRt5fGPfjW Dbtdr7d9Qp5ljFS02Swx202vd8zH5SwP2VKx4FVp2F/hcfS1OXo7+Jn2tqqOzdBh4J8hsIte 5f/n7Nqa28aV9F/R06mk9pwaXkXqYR4gXiRGvJmgaHleWJ5EM3GtY6ds5+xkf/2iwRvQDSZz 9mEm1tcAiEuj0Q00GgSC92XxLgM85foXRqWPiBhJ7exg+JYbAYG2e/CriKOCrBjTzcYoIRVi hecGQveqUzIs+PUdFe3bmsjqkdK1ZKxkwA/gISNBjBaplbyPk3HSkjYTbc/1OTGfwpinRFTF ZDJA0JMurox4rT6iNY7adDH1g2GJmoldTYd7ohXxeqEdHNKTPlvOluBQvMlZRAaIC/Y4l0Lp 9+v+4FCmVMimiqv0IqUVuDhCkxYToSFVn3KOl20OnGTmYqD2MPdMhGNHF+MBHpYCutkG5DjJ W2M+SegL2cS1fCNzmOYtnRPTdEnjmmhZE+0DHew5W0RaPZE6bihxip7THOheEkgxMu4Daj7I lHKjS8ozkRsyV1yYvkHHD+aZhop5Jh8tWF13ClKGwJyCgojbh9V+bVWTZ5YhnBZqAkoeUv9k KZyv05nmFlxAZ5VOg0J192E6TwyFSdYVVp+ZBiJ5jTpcp6dUOLL/Weuk5BS0dLZxB0tEGLdF Ef0CF2cNJihsDwBJ3x8Y/Afms9zvOt4mzA80z7nB3SDzAnyggrHMiQi25MZnIRibuwATpmJV bCl2iypVNCE+6Ir5vsFZC3bJ5F+kzCNrTkYQHVycEk1ZHMx62L8r0dlOwXbqJo/SzartMH5I mBSBtT3S5KmwzB0CG67TDJThVs7ELTQoEtDDvzZpMR6zb97xdiOvqr9f+GcpKtQe6PrPilOF ylBixhll9JmEmwJaaYvBpm00NyQVJd3EfoMNTIwekkI7bBtHILW3qearq8ANHYGkacSyHhG8 OXNS6fauPlbqrsQA/1blbZPN2y7L1E4fXq638DzSuyxJko3t7rz3K7ZjmjVJjLfHR3A4kaMO OnDA1Fc1eGbMIZQgYBTc/hlG8fkr3AUi+3qwheHZRFdsO+w4Et3VTcI5VKS4ZcQU2J9TB5lr C27YH5S40JKqGi93kmLyglHKW/OecVY9bhx9TwBbsz+wc42Ltdwv8La420a475TRk5I7Y6UQ VNqoLri6j7GgKwqVdEMadHhlU+L+6ePD4+P9y/fJ1Wbz7u3bk/j3n5vX69PrM/zx4HwUv74+ /HPzx8vz05sQAK/vsUcOOGs1Xc+EDc+THFxBsNNb27LoSHb9mvHK3vwiZ/L08fmT/P6n6/TX WBNRWSF6IJLZ5vP18av45+Pnh69L4L5vsMO75Pr68vzx+jpn/PLwlzZjJn5l55gqAG3MAs8l xouAd6FHN1djZu92AZ0MCdt6tm/QAgTukGIKXrsePXiMuOtadC+P+65HDsIBzV2Hanx55zoW yyLHJfsOZ1F71yNtvS1CLQz5gqoh90feqp2AFzXdowNn6X2b9gNNDlMT83mQyO41Y9vhxVWZ tHv4dH1eTcziDp7OIIakhF0T7IWkhgBvLbJ/N8JSSaMOhUFIu2uETTn2bWiTLhOgT8SAALcE PHFLe4l4ZJY83Io6bs07kvQAYIApi8Idr8Aj3TXhpva0Xe3bnkH0C9inkwMOYS06lW6dkPZ7 e7vTnoZSUNIvgNJ2dvXFHZ7vUFgI5v+9Jh4MnBfYdAbLHXYPlXZ9+kEZdKQkHJKZJPk0MLMv nXcAu3SYJLwzwr5N7M4RNnP1zg13RDawUxgamObIQ2c5BIvuv1xf7kcpveoGInSMkgkNP8el QUgzm3ACoD6ReoAGprQunWGAUlehqnO2VIID6pMSAKUCRqKGcn1juQI1pyV8UnX62yRLWsol EjWWuzOggeMTXhCodo10Ro2tCIx1CAJT2tAg2KpuZyx3Z2yx7YZ06Du+3Tpk6It2V1gWaZ2E 6foNsE3nhYBr7T2sGW7NZbe2bSq7s4xld+aadIaa8MZyrTpySaeUwmawbCOp8IsqJ3s/zQff K2n5/mnL6JYaoESICNRLogNd1P2Tv2dkLzppw+RERo37UeAWsxGaCxlBnbonEeSHVClip8Cl nB7f7gIqMwQaWkHfRcX0vfTx/vXzqkiK4ZosaTfErKDudXCJW+rtykLw8EXomP++gvk7q6K6 alXHgu1dm/T4QAjnfpG66y9DqcL8+voiFFeIwGAsFbSkwHeOfLYW42YjtXacHraV4AWRYUEZ 1P6H149XofE/XZ+/vWI9Gkv5wKWLceE72ntIo7B1DDthELIsi+Xar71K///Q8efHv39U4wO3 t1vtaySHYvoAjRrS0SV2wtCCu2PjltkSHINm022c6cLIsCp+e317/vLwv1c48B1sKmw0yfTC aitqLRaKQgPLInS0sEs6NXR2PyJqMWZIuWroAUTdheqbTBpR7lqt5ZTElZwFzzRxqtFaR4+6 hmjblVZKmrtKc1R1GtFsd6UuN62teTKqtAty19dpvuY3qtO8VVpxyUVG9T0/Sg3aFWrkeTy0 1noA5v6W+JmoPGCvNCaNLG01IzTnB7SV6oxfXMmZrPdQGgldcK33wrDh4H+70kPtme1W2Y5n ju2vsGvW7mx3hSUbsVKtjcgldy1b9RvTeKuwY1t0kbfSCZK+F63xVMljkiWqkHm9buJuv0mn 7ZlpS0ReV3x9EzL1/uXT5t3r/ZsQ/Q9v1/fLTo6+hcjbvRXuFEV4BLfEVRSuQ+ysvwwg9lMR 4FYYpDTpVlOApJOG4HVVCkgsDGPuDo/hmBr18f73x+vmvzZCHotV8+3lARwSV5oXNxfk9TsJ wsiJY1TBTJ86si5lGHqBYwLn6gnoX/zv9LWwLT3i1CNBNfiA/ELr2uijv+ViRNSHlxYQj55/ tLXNpmmgHNVBbBpnyzTODuUIOaQmjrBI/4ZW6NJOt7RQCVNSB/vhdgm3Lzucf5yfsU2qO5CG rqVfFeVfcHpGeXvIvjWBgWm4cEcIzsFc3HKxbqB0gq1J/Yt9uGX400N/ydV6ZrF28+7vcDyv xUKO6wfYhTTEIX79A+gY+MnFjlrNBU2fXFi4IfZrlu3w0KfLS0vZTrC8b2B510eDOl2M2Jvh iMABwEa0JuiOstfQAjRxpJs7qlgSGUWmuyUcJPRNx2oMqGdj5zTpXo4d2wfQMYJgARjEGq4/ +Hn3KfJVGzzT4fZuhcZ2uD5BMoyqs8ql0SifV/kT5neIJ8bQy46Re7BsHORTMBtSLRffLJ9f 3j5v2Jfry8PH+6dfTs8v1/unTbvMl18iuWrEbbdaM8GWjoUvoVSNrz+PNoE2HoB9JMxILCLz Q9y6Li50RH0jqga+GWBHu/w1T0kLyWh2Dn3HMWE9OSQc8c7LDQXbs9zJePz3Bc8Oj5+YUKFZ 3jkW1z6hL5//+I++20YQq860RHvufAYxXc9SCtw8Pz1+H3WrX+o810vVti2XdQZuQ1lYvCqk 3TwZeBIJw/7p7eX5cdqO2Pzx/DJoC0RJcXeXuw9o3Mv90cEsAtiOYDXueYmhLoGAdR7mOQni 3AOIph0Yni7mTB4ecsLFAsSLIWv3QqvDckzM7+3WR2pidhHWr4/YVar8DuEleasIVepYNWfu ojnEeFS1+CLVMckHZ45BsR7OwJfIsu+S0rccx34/DePj9YXuZE1i0CIaUz1fpGmfnx9fN29w FvHv6+Pz183T9X9WFdZzUdwNghYbA0Tnl4UfXu6/fobIuPSawoH1rFH9XgdARnU41Gc1ogM4 RWb1ucMhXeOm0H7IDR6hxygROgCNayFRLnNUc50Gp9PwilIKzmV6aaeCwzDoPtkjnu4nklZc KmOEGB7EW4hVlzTDsb9YPig5T9ipr4938DRpUugFwOXYXlhn8eK9gBuqnaUA1raoj7qGFcZm HZKil+8BGNoFTV6jQT5+BE9RE7VDbeDRMZlv7sLu23h8tXkmx+hKLnC4io5CLdrqdR4csXLt ysOEl5dabh3t1GNWQpSbWdp24FqFhgW9KZT92+X1PQVeHtCCjzUsTqrS+IwkkFkRC2ZXydOr f5t3gwdB9FxPngPvxY+nPx7+/PZyD04w6Pm/v5FB/3ZZnbuEnQ1PeMmBE+OKOOekxu+QtW8z uD9x0J5AAMLglztLr6aN0ICOjrtpVsSmnL7nujJ4WGmiBuskIQIumAVHSpfF2eRTNG35yv3d /cvDpz+v5grGdWYsjAiZOb0RBhfLlerOT6Hxb7//i0rwJSk4WJuKyGrzN9OsiIyEpmr1cMkK jUcsX+k/cLLW8HOcI3bAErQ4sIP2wjaAUdaIRbC/SdQ45XKqSI/S26GzKCXvYsR+NxdUgX0V HVEaCOMMnnU1+ljNyiSfuj5+eP36eP99U98/XR9R78uE8BhaD86BguPzxFCSoXYDjrfTF0qa ZHfwjmt6J3Q2x4szZ8tcKzYlzfIM/PSzfOdqihNNkO3C0I6MScqyysUyWFvB7jc1As6S5EOc 9XkralMklr53vKQ5ZeVhvNLSn2JrF8SWZ2z36LOcxzvLM5aUC+LB89XotguxyrMiufR5FMOf 5fmSqT6sSrom4wm4UvZVC5G0d8aGVTyG/2zLbh0/DHrfbY2DJf7PIGRN1HfdxbZSy/VKczeo L7631VmwXdQkauwsNeldDNc/m2IbkskwJqmik2zEh6PlB6WFNq6UdOW+6huIeRC7xhSzq/g2 trfxT5Ik7pEZ2UlJsnU/WBfLOEZaquJn3woZMydJslPVe+5tl9oHYwIZrzK/EaPX2Pyi3U7H ibjlua2dJyuJsraBgETCSg+Cv5Ek3HWmNG1dgeeivuO4UJtzfteXrev7u6C/vbnISxXzQo1E jSa90LtWS5kzRZNWizVgXMGGYBaiKay8BNqNVSmF43JYxTRUKPh7qYnHDAkRkG99UqJwnlLI JwcG10fE4tHG9QXiRx+Sfh/6llDY01s9MehddVu63pZ0HmhKfc3DLRZxQsET/2WCYGFCttMD aoyg4yKZ1B6zEh5vjrauaIhtOZhe8WO2Z6OfGdYmETVAVCEB0trD3AC3WsqtL7o4RErrPDDq laxJMSW+UojQDw6i341kYW6aCdjLSo61aaUdwZ4d9z1yRVXJmcN/RB4ukxCepwyrVbbAejrc hWNgLIkpQK5RTinyeE9B2rAMbtJmiKmTtmRd1hlB0wvPYuyaqD4gVUI+ay4YpIgwB5R3mok6 AqOZus8o5XgJXT+IKQFWdkfdcFEJrmebPmI5oXvTUkqT1Eyz/iaCkHlaPHwFD1wfTfu2S0yr WdpUWAscn688pGh8iyhGilEOouQOGbAxztfY6pH3qGdirQ8BnHXaOx+aBpGUrTTX+5tz1pyQ ZpBncIumjOWrhoMXz8v9l+vm929//CFswxg786R7YSnHQmdRJHm6H0JO36nQ8pnJmpe2vZYr Vq8dQ8kpXKHI80aLbjgSoqq+E6UwQsgK0fZ9nulZ+B03lwUEY1lAMJeVVk2SHUqxQMQZK7Um 7Kv2uOCzAQoU8c9AMJrHIoX4TJsnhkSoFdrtC+i2JBW6mQzuodWFi6VNjKeWFmIH59nhqDeo EOvcuJ/BtSJA/4fmi7lxMDLE5/uXT0OoF2zLidyHpjug8ZHWkAbVhYN/i4FKK5CBAi216wxQ RF5z3ZlagMK05/qX6q7Ry4V3zGFDTf86t2P0TB1wLxjPzADpMW4XGN02WQhLd6vEJuv00gEg ZUuQlixhc7mZ5hIK48qEfncxQEJeinWmFIq6VsBEvONtdnNOTLSDCdQc0JRyWKcaCVB5uT9k gGjrB3ilAwci7RzW3mnicoZWChJEnLiPSBKIE5w0wk4SBhqlXQhk/hZ3dc5zpbzTUiCxPUOk d0aYRVGS64QM8XfGe9eycJreVd+lTPf6EjL8FhMQhGVfC3st5Th1D++mFLVYSfZgjt/p3J9U QnBmOlOc7tSgmwJwtbVuBAxtkjDuga6q4kp9wAmwVmjNei+3wpYQC54+yOr9Uilx9DwRa4qs TEyYWCOZ0Jk6qSjNslsjRmfeVoVZfLdFpncBAEOL0TDqTwZKhEdn1F/alhTM/30h2LH1tEiz IIerPE4zfkQjLF/80udtAvZgVehth2NCB4nIEZPxZA6IjScaHrJ9U7GYH5MELcAczroD1NrA RuIbQoRQZDrSwGHVZ3p5hrMG/qtLc8q405kpU8y56VMiAxU5iIZmykKNIBa7mE5ZcyNUTNau pdP2YDWKEKbRCmmwQ4aIpTiFN6cgJH+dNJTL4zWKtiWsUcRU6NPo1NfyPeXTr5a55DxJ6p6l rUgFDRN6Ok/mcGuQLt0P2wZy13rcwqaPVc6Fjta6WOeZuzVxypQAm680QR3bDtdiJ85pRo0E 3kvrsh/SdaPMkGB+icCQalDW49pUwkgTVlhUrJLl5T8WXfytz07ryfJDfRTiu+Z9vrdc/8Yy dRzac3KDLohvkXhSU8odo1jYY22bRD9N5rlFm7D1ZPCmTJmHlhcec7lTMBvaP2eSKaXRhpGM tr//+N+PD39+ftv8YyNW9+nVRXKAC1uzQ6j64UGXpbpAyb3UshzPadWtQ0kouDBLD6l61i/x tnN966bT0cHsvVDQVfeCAGzjyvEKHesOB8dzHebp8BTWQUdZwd3tLj2oR4xjhcXKc0pxQwZT XccqiLbhqA8zzorPSl8t9FGjMpHws6ULRXscbIHxC4lKhiLceXZ/m6shpBYyflhpobC4DrXX AxApMJLoK2paq7auZewrSdoZKXWovYa4UOhzYguNPmql9LsWcEX5Uuc7VpDXJto+3tqWsTTW RJeoLE2k8ZFTdb7+ZK5NZQibEdZHHJPAbKOOa9foNvL0+vwoTNFxA26MoUDm8uDXIX7wSosb p8KwXJ+Lkv8aWmZ6U93yXx1/FlpC9RPLf5qCAywu2UAUU6MdlOusYM3dj9PKI8zBwWJxRPlx Y+d5Wh2UTQH41csDpl6GSTERRPfbWyMlys+to77aK2n8XCqUuX7EF2bKxKtzqcxG+bOvOEcP l+l4DwFMc5Yp5irXSinjHj3JC1CtrpAj0Cd5rJUiwSyJdn6o43HBkvIAij0p53gbJ7UO8eSG yDvAG3ZbwFm8BoLpJANzVGkKfi469QNEVvmOkTGuv+bUw4c+AhccHZSOAUCi7V8DIQikaC2n nTP0rAYfG0N3r71DIyvELmAnxUITd7RuGzT3Xpgo+mtD8uPC9OxTVFIHj8zzhNilOi0rW9SH SHWfoSkTbfelOZNNBvmVgvEW9wiHR5bKCPeJZAuQHAQeUtPhgBxj98LWHoSJJ1/qgaWEHaqZ tirNjEpfLUoSpiDNU9Rnz7L7M2vQJ6o6d3ttX1FFoUCd0l1oahbtgh5FJpMDgoMSSZB2H4N3 0NBnjI1oazWM6gBx9cRr6AP5ntnZ3vrqbb+lF9B8EfxasNK5eIZG1dUtXG0Sq5/eCEScR9bS mQ5NABbbofoKsMTaLLvUJkzu4yJJxc5haFsUcwyYi7FbRwf2rXZ3YYakm1+UV1hsRcyyVQ1T YjI0K2Key51QCA1MJXGUn3tOaBNMe/5pwYT5cCtspRrVi/u+66MjPUloLymqW8yanOHeEnKS YDm7owmH3J4ht2fKjUCxSDOEZAhIomPlHnQsK+PsUJkw3N4BjT+Y017MiRGclNx2A8sEomFK ixDPJQlNMe/gmVu0jh1jjlgdEMTjYs21A9x3EMYzDy+WGUUlnKrmYGuXI+WYVDnq7fyy9bZe wvGgXIiULAvHR5xfR5cjWh2arG6zGGsMReI6BNptDZCP0nUZCx08E0bQJB3kJmDFEVd0F8dB Bd8V6TBrpaZ9jP8lvS+Vy+5yZBgeKjZ0OIUHBeo7hptkAChlUH72iSnXQpNt/NXGCWTM7Om1 HZJdrkPi0xAB/kSrOpDHx1L+j7MrW3IbV7K/oh+40yJZ2u5EP4CLJHZxMwFKKr8wqm1Nd0WU XZ6qcvT13w8S4AIkErJjXuzSOSB2JBJbpofl+aFkZEE1f8LDdqbsfSKbw8dliAV/dQxrAAYv pS8W/TaLuxlmXclphFAvZ/0VYtudH1ln3T81ETU1TquJqcO5qbWZG5nMtre1sws2zz5lAbqA nMRk5j9mv6/vrLF7YTCEnBmKY5WViU2UhOaDNBPtBWvBiHucC7Ba+PsdPMoxA4KrkB8IwHdP LFj+ld3wFDqG7ViARa/y1cJy9sEDY6uFU1Q8CMPC/WgN1g5d+JjvGV4TxUlqvyAZA8NFgrUL N3VKgkcCFnJUDF5jEXNiUs1DshHyfM5bpKyNqNveqbO+qy/mrS81x3D7gH2KsbauW6iKyOI6 pnOk/C1Zb+AsVjBuuWezyLIWnUu57SAXOYkcw/bi5tJIPS5D+W9S1duSPe7+zLKDCJBcM7Ey 3eywNqk2CqTyFgUuDub8EVonDqCV6LhD6wNgxhNae83uBBvX3S4j6qaWAv7BZZizmtJgzy7q apif5E2a4woDuoTlAN4+GIjko9QZN2GwKy872HKVC2fTcioK2gowcUWE0RbdnUqcYNmgXorz m7Rl09r98jaNqV2gGVbuDuFSWzgMfN+Du/slXnSZUVxWP4lBbUun/jop8dQ0k2RLl/l9W6ut CIEEdJkcm/E7+QNFGydlKFvXH3HycKjwzJ81u0jOQbpRB0dLyWB5E54z7l+v17dPj8/XRdJ0 kxmK4THdHHSwKUt88m9bn+Nq86XoGW+JsQgMZ8TQUJ90siovno+45yPPcAEq86YkW2yf4z0N qFW4TpmUbnccSchih1c4pad6h01MVGdP/1VeFn++PL5+pqoOIsv4NjLvo5gcP4hi5cyCE+uv DKY6CGtTf8Fyy1z0zW5ilV/21WO+DsEJDu6Vf3y829wtXZEy47e+6T/kfRGvUWHv8/b+XNeE tDcZeI7CUibXmH2K1S9V5oMrtCWoSpNX5AeKs9yNmOR0DdcbQrWON3LN+qPPOZjjBWPb4GpC LizsC+hTWFg6yeEiYHIqslNWEJNT0uRDwNJ2DGTHUlr2f20uTs9qItn4JpshGFzfOGdF4QlV ivs+FsmJz65KoeOZQ4d9eX756+nT4tvz47v8/eXNHjWDn4DLQV0ARPJ05to0bX2kqG+RaQl3 N2VFCbxNawdS7eKqS1Yg3PgW6bT9zOqDDXf4GiGg+9yKAXh/8nIWo6hDEIKDY1huCks6/EIr ESshUj8DbxguWjRwFpw0nY9yj6htPm8+bJdrYjrRNAM6WLs0F2SkQ/iex54iOL5/J1IuLNc/ ZfEqaObY/hYlpQAxyQ00btSZamVXgeu5vi+590tJ3UiTGOFcKmB4H0pVdFpuTUurIz76Wrk9 obbXr9e3xzdg39xplB/v5KyX0/OZNxonlrwlZlNAqdW1zfXucnIK0OHtScXU+xsiG1hnB3wk QJ7TzOgngCSrmjhMQaR7Sc4MxIVcPomexXmfHLPknlgiQTDiNGyk5AhOsikxtRHnj0KfrckB 2twKNB7n5Q1eZFrBdMoykGwpntumCNzQg9PE4baelMSyvLfCQ7z7AnQRZTSBCknXu542b3cE Hcbf6pr3dhdNH+V0IFcHqppuBGOiLsewt8L55BuEiNmDaBk8UbvVmcZQnjgmReJ2JGMwOpYy a1tZlqxIb0czh/OMOLnuh43+++x2PHM4Oh7tDPXn8czh6HgSVlV19fN45nCeeOr9Pst+IZ4p nKdPJL8QyRDIl5MyEyqOwtPvzBA/y+0YktBAUYDbMendY39PB77IK6nTMp4V1n1wM9hFZBUn lpi8odZngMJLMCpPYjpe4aJ8+vT6cn2+fnp/ffkKt2iUZ6uFDDeY0ncuNc3RgAssck9BU0p7 bAllavBnuOdK1Zgn21/PjFb6n5//efoK9pCdaRrltqvucuoSgCS2PyPI8xjJr5Y/CXBH7dkp mFpxqwRZqg4H+jY7lMy60XarrIZbFFNLcV030WqPkFIa3OI4V48Gks+kx8OU1OzMlIkditFz J6OUmJEsk5v0KaG2KeBqbu/upk1UmcRUpAOnVzCeCtT7LYt/nt7//uXKVPEOB21z4/1q2+DY uipvjrlz0cdgekZplBNbpAHeAzfp5sLDG7RUJhg5OmSgwScoOfwHTqu0nmWwEc6zAXUR++bA 6BTUA2z4u5lEmcqn+zhwWooVhS4KtYve5h+d+w9AnKUW08XEF5Jgzn0BFRW8z1/6Ks13GUlx abCNiBWPxHcRIUQ1PtQAzVmP5UxuS2wFsnQTRVRvYSnrernwK8jzB9YF0SbyMBt8EjgzFy+z vsH4ijSwnsoAFl/kMZlbsW5vxbrbbPzM7e/8adpudAzmtMVndDNBl+5kmQyfCR4E+HaVIu7v AnzqMeIBsbcs8bsVja8iYpEOOD6qH/A1Psce8TuqZIBTdSRxfBNI46toSw2t+9WKzH+RrKzn fRaBrzIAEafhlvwiFj1PCAmdNAkjxEfyYbncRSeiZ0xOT2npkfBoVVA50wSRM00QraEJovk0 QdQjnLUWVIMoYkW0yEDQg0CT3uh8GaCkEBBrsih3Ib5INuGe/G5uZHfjkRLAXS5EFxsIb4xR 4BxqDwQ1IBS+I/FNga+rTQTdxpLY+ogdmSfwRUcRl3B5R/YKSVhOiUZiOMTxdHFgw1Xsowui +dX5NpE1hfvCE62lz8lJPKIKot4JEZVI66nDk0qyVBnfBNQglXhI9QQ4BqQ2qH3Hgxqnu+HA kR37IMo1NenItSx10cygqENS1X8p6QXG1fr2PlpSYifnLM6KglguF+Xd7m5FNHAJN7WIHJTs IpWiLVFBmqE6/sAQzayYaLXxJeRcV52YFTX9KmZNaBqK2IW+HOxCamddM77YSF1uyJovZxQB +/fBuj/DA0BqeYzCwA0kwYj9N7nuDNaU7gbEBl9YNwi6SytyR4zYgbj5FT0SgNxSR0YD4Y8S SF+U0XJJdEZFUPU9EN60FOlNS9Yw0VVHxh+pYn2xroJlSMe6CsL/eAlvaookE5PygZRtbbF2 r4BpPLqjBmcrLK+DBkxpjxLeUamCWyEqVRFYxt8tnIxntQrI3KzWlIQHnCytsD0WWjiZn9Wa UtkUTow3wKkuqXBCmCjck+6aroc1parpewQ+3NNTJLclphn/BRnsd37GDyW9AzAydEee2GmL zwkAdk17Jv+FswRi18Q4LvQdxdEbKpyXIdkFgVhReg8Qa2o1OhB0LY8kXQG8vFtRkxkXjNSl AKfmHomvQqI/wo2X3WZNHtLnPWfELoZgPFxRCw5JrJbU2AdiExC5VQR+mjMQcs1KjGflg5pS LsWe7bYbipi9PN8k6QYwA5DNNwegCj6SUYAff9i0l5RaILUcFTxiYbghlDnB9WLJw1AbCtrX NfGFIqjdL6mE7CJqQXQugpDSic7gj5SKqAzC1bLPToQIPZfuXfQBD2l8FXhxorsCTudpu/Lh VB9SOFGtgJOVV2431JQHOKVpKpwQN9SN2gn3xEMtggCnRIbC6fJuqClG4cQgAJyaRiS+pRR4 jdPDceDIkahuIdP52lEbe9St5RGnVADAqWUq4NSUrnC6vndruj521FJH4Z58buh+sdt6ykvt VSjcEw+1klO4J587T7o7T/6p9eDZc5lJ4XS/3lGq5bncLam1EOB0uXYbar4HHL9AnHCivB/V Wc5u3eC3ekDKtfZ25VlObiiFURGUpqdWk5RKVyZBtKE6QFmE64CSVKVYR5QSq3Ai6QpcI1FD pKJeNU8EVR+aIPKkCaI5RMPWcg3ALJe29nGW9YnWEOFeJ3ksM9M2oVXGQ8uaI2Knxy7jo8s8 dQ/SJTh/IX/0sTrVe4D7XFl1EMalX8m27Dz/7pxv58d5+hrCt+sncM4ECTsneBCe3YEZdzsO liSdMhGP4da8bD9B/X5v5bBnjeVAYILyFoHcfB6hkA7e76HayIp786asxkTdQLo2mh/irHLg 5Ahm7zGWy18YrFvOcCaTujswhJUsYUWBvm7aOs3vswdUJPzGUmFNaDlAV9iDftVkgbK1D3UF HgNmfMacis/Azw8qfVawCiOZdcdXYzUCPsqi4K5VxnmL+9u+RVEda/sNrv7t5PVQ1wc5mo6s tGyQKEqstxHCZG6ILnn/gPpZl4Ch8sQGz6wQpqkJwE55dlaOE1DSD60202OhecJSlFAuEPAH i1vUzOKcV0dc+/dZxXM5qnEaRaKezyIwSzFQ1SfUVFBidxCPaG9aBrAI+aMxamXCzZYCsO3K uMgaloYOdZDajwOej1lWcKfBlTXRsu44qrhStk6La6NkD/uCcVSmNtOdH4XN4Qiv3gsE1/AC AHfisitETvSkSuQYaPODDdWt3bFh0LMKrK4XtTkuDNCphSarZB1UKK9NJljxUCHp2kgZBeZq KRDMcf+gcMJwrUlb5m8tIks5zSR5iwgpUpTTiQSJK2UJ64LbTAbFo6etk4ShOpCi16newRsH Ai3Brawk4lpW9tvh5h/6UmSsdCDZWeWUmaGyyHSbAs9PbYl6yQF8qDBuCvgJcnNVslb8UT/Y 8Zqo84nI8WiXkoxnWCyAt4hDibG242IwczQxJuqk1oF20TemlWMFh/uPWYvycWbOJHLO87LG cvGSyw5vQxCZXQcj4uTo40MqdQw84rmUoWCes4tJXJvvHX4hBaNQhtfnm5GEfqQUp47HtLam 38M7g9IYVUMIbeTLiix+eXlfNK8v7y+fwI0l1sfgw/vYiBqAUWJOWf5JZDiYdZcRvMWRpYJr X7pUlmc5N4Kv79fnRc6PnmjU5XNJO5HR3022Icx0jMLXxyS3berb1ezcDlaWD9CNYGVnoYUJ j/H+mNgtZQezjDep76pKSmt4EwE2iJRpOD62avn09un6/Pz49fry/U3V9/As127RwRQG2NLl OUd59ZlbU4UXBwfoz0cpJQsnHqDiQol+LtTAcOi9+YhIGWqQEh+Max8OUhRIwH4io61TiFrq 6HLOAjtr4MwktLsmquWzU6Fn1SAx23vg6THKPE5e3t7BMuLoItSxFqw+XW8uy6VqTCveC/QX Gk3jA1wM+uEQ1sOMGXXes83xyyqOCbwU9xR6kiUkcPAQZ8MZmXmFtnWtWrUXqN0VKwR0T+2n 0mWd8il0zws69b5qknJjbgpbLF0v9aULg+WxcbOf8yYI1heaiNahS+xlZ4XXyw4hVYvoLgxc oiYrrp6yjCtgYjjH4+R2MTsyoQ6s7DgoL7YBkdcJlhVQI2GmKFOnArTdglff3caNqpVLfS5F mvz7yF36TGb2eGYEmChzBsxFOR7QAMIbKvQ4zMnP71/mIa2tNS+S58e3N3rWYwmqaWX8MUMD 5JyiUKKcNjoqqXj8e6GqUdRykZAtPl+/gVvfBRhOSHi++PP7+yIu7kGK9zxdfHn8MZpXeHx+ e1n8eV18vV4/Xz//9+LterViOl6fv6nL5V9eXq+Lp6//82LnfgiHGlqD+LWdSTnmqgZAyd2m pD9KmWB7FtOJ7aXuaallJpnz1DoMMTn5NxM0xdO0NX2jY87c5za5P7qy4cfaEysrWJcymqur DK3QTPYeTAnQ1LCH0ssqSjw1JPto38XrcIUqomNWl82/PP719PUvw3OuKYjSZIsrUi1CrcaU aN6gp8QaO1Ejc8bVW1X++5YgK6n0SgER2NTRcmA1BO9M6y8aI7piKbpI6WkIU3GSTo6mEAeW HjJBOMmYQqQdAw+QReamSeZFyZe0TZwMKeJmhuCf2xlS2paRIdXUzfA8fnF4/n5dFI8/rq+o qZWYkf+srTPJieou2lGHVgiVsCuZlBOfr3M8KmCT17JfFw9I/TsnkR0rIH1XKJNkVhEVcbMS VIiblaBC/KQStL614NS6R31fW7crJnhyoOzkmTUUDDulYOeLoFBv1uAHR65JOMRdBTCnlrRj 98fPf13ff0u/Pz7/6xWsbkMjLV6v//v96fWq1XcdZHpO9K4mhevXxz+fr5+HlzB2QlKlz5sj eEf3V3joGwY6Bqyb6C/cwaFwx8rxxIgWrEuXOecZbJDsORFGP4WGPNdpnqA10zGXa9gMydUR 7eu9h3DyPzFd6klCiyuLAl1ws0bjawCdFdtABEMKVqtM38gkVJV7B8sYUo8XJywR0hk30GVU RyFVmo5z67qKmoSUkWIKm85tfhAc9shsUCyX64jYR7b3UWDeaDM4fKpiUMnRugpvMGrxecwc TUGzcNVUO0LK3KXkGHcjVfsLTQ2Td7kl6axssgPJ7EWayzqqSfKUW3tABpM3ptlEk6DDZ7Kj eMs1kr3I6Txug9C8hm1Tq4iukoNySuXJ/ZnGu47EQdw2rAIjgLd4mis4Xar7OgYzAgldJ2Ui +s5XauWmimZqvvGMHM0FK7Du5O77GGG2d57vL523CSt2Kj0V0BRhtIxIqhb5eruiu+yHhHV0 w36QsgS2qUiSN0mzvWCteuAs8zOIkNWSpngPYJIhWdsysCxZWKeMZpCHMq5p6eTp1clDnLXK 0wHFXqRsctYigyA5e2paW0ihqbLKq4xuO/gs8Xx3gX1gqXTSGcn5MXa0kLFCeBc4C6ahAQXd rbsm3Wz3y01Ef6YndmOdYe8hkhNJVuZrlJiEQiTWWdoJt7OdOJaZcvJf4TIV2aEW9uGjgvE2 wSihk4dNso4wp7wPoyk8Red9ACpxbZ9KqwLADQHHZ7IqRs7lf5YbUgsGo7l2ny9QxqV2VCXZ KY9bJvBskNdn1spaQbCyE4O2wLhUFNTexz6/iA6t6waTsXsklh9kOLyX9lFVwwU1Kmzvyf/D VXDBey48T+CPaIWF0Mjcrc3baaoKwOyFrErwheYUJTmymlvn+6oFBB6scIpGrMSTC9z7QOvn jB2KzIni0sHGQml2+ebvH29Pnx6f9XKL7vPN0VgojSuFiZlSqOpGp5Jkpk9sVkbR6jLaUoYQ DiejsXGIBhwr9afYPJgS7Hiq7ZATpLXM+MH18DGqjdHScnZ2o/RWNpRKirKm1VRiYTAw5NLA /Ao8J2f8Fk+TUB+9unUUEuy4rQIuGrXHI26Em+aJyZvS3Auur0/f/r6+ypqYN/vtTjBuBOOd jP7Quti4TYpQa4vU/Wim0cACC3kbNG7LkxsDYBHe4q2IbR+Fys/VzjKKAzKOhEGcJkNi9hKd XJZDYGchxsp0tYrWTo7lFBqGm5AElaXVHw6xRfPFob5Hoz87hEu6x2pLFChr2r36yTq/BUK7 59I7Y/aoIXuLLe9iMAwNtsPwfOPuLu/l1N4XKPGxt2I0g4kNg8jg3BAp8f2+r2M8Aez7ys1R 5kLNsXYUHhkwc0vTxdwN2FZpzjFYgrVFcsN6DxIAIR1LAgob/d67VOhgp8TJg+XjR2PWkfpQ fOoMYN8LXFH6T5z5ER1b5QdJsqT0MKrZaKryfpTdYsZmogPo1vJ8nPmiHboITVptTQfZy2HQ c1+6e2dSMCjVN26RYye5ESb0kqqP+Mgjvm5hxnrC+04zN/YoHy9w89nXXkakP1aNbUdQSTVb JAzyz64lAyRrR8oaJFjFkeoZADud4uCKFZ2eM667KoFllh9XGfnh4Yj8GCy5keWXOkONaJ8a iCIFqvKBRqpItMBIUu0ygJgZQIG8zxkGpUzoS45RdXGQBKkKGakE74IeXEl3gLsJ2iaZgw5e 8Dxbk0MYSsId+nMWW94lxENjPmlUP2WPb3AQwExlQoOtCDZBcMTwHlQn88XUEAW4L91tL6be L358u/4rWZTfn9+fvj1f/3N9/S29Gr8W/J+n909/u5eKdJRlJ7X2PFLprSLrRv//J3acLfb8 fn39+vh+XZRwLuCsSnQm0qZnhSit+4yaqU45+G+ZWSp3nkQslRSchfJzLvCiSy6O1WUdu5nh pKi3VizdObZ+wIm/DcDFABvJg7vt0lDpytLoKM25BQeDGQXydLvZblwYbVjLT/tYuZZzofHq 03TcyZVHHMsZFwQeVrH6oK1MfuPpbxDy5/eF4GO0bgKIp1Y1TFAvU4dNbM6tC1kz3+DPpLSr j6rOqNCF2JdUMmCOVJhvo2YKbptXSUZRe/jf3Fwy8g3ONG1C28zjNgg7jy2q23wvtZPUBg91 ke5z8wq2SqtxKk2XP0HJiFI9o27dYri1nvf8gcPiIyGo2cC+w7tW/ABN4k2AaugkhyZPrR6s usX/MXYtzY3juvqvpGY1p+rOPZZsyfZiFrIk2xqLkiLKjtMbVU7a05Pq7qQrSdeZ3F9/CVIP gISS2aTbHyg+QRAkQeDG/s2Nl0I3+TG1/M92FPvas4P32Xy5XsUnYnDR0Q5zt1SHFTVD4bfm uhlHJfysDI9yb/cKdFuoBImVsrcucRm4I5BjDt2T184caUq5zzaRm0kXDoWCxCRuZNVzWuDD WjQpyN3yiEcixK+RRSpkkxFx0iHUnlBcvj89v8nXh/uvrkQfPjkW+vC8TuVRID1ZSDWhHLEl B8Qp4WNJ1Jeo5xtWMQbKH9qOpGjnqzNDrck5wQizA2tTyeiCOSu1+NfWoDq2zphqxFrrNYam bGo48SzgSHh/A4eKxU7fPuieUSncPtefRVHj+fhVpUELpUcE68iG5TxcBDaqmC0knklGNLBR yyGcwerZzFt42AuIxnXcertmGvQ5cO6CxH3eAK6x/4UBnXk2Cq8ofTtXeSxoWDaNqlat3Wp1 qIkRT8eWho03lajm64XTBwoMnEZUQXA+O6bVA833ONDpHwWGbtarYOZ+viLuj8bGBXafdSjX ZCCFc/uDG7Gae2dwZ9EcbWbX/sXsGiZqu+Yv5Ay/iDb53wgLqdPdMaeXDIY1E381c1rezIO1 3UfOk1xjph1HYTBb2mgeB2viLsJkEZ2XyzCwu8/AToHAycHfFlg2ZOUy36fF1vc2eBHV+KFJ /HBtNy6Tc2+bz721XbuO4DvVlrG/VDy2yZvh3HMUIsZv8LeHx6+/ev/SOnW922i62hr9fPwM Gr77luPq1/F1zL8sMbSBKxJ7/CqxmjkSROTnGt+jafAoU3uQJejit409U9U2MBfHibkDwsEe VgCNv6ShE5rnhy9fXFHaWe/bYrw36rfiuxNaqeQ2sc4kVLWhPUxkKppkgrJPlda+IeYhhD4+ TePpEF6GzzmKm+yUNbcTHzKibWhI9/pC97zuzocfr2DR9XL1avp0ZKDi8vrnA2zRru6fHv98 +HL1K3T9693zl8urzT1DF9dRITMSw522KRLELx4hVlGBT0oIrUgbeEE09SG8ELeZaegtehJl djPZJsuhB4fSIs+7VUt4lOXwqH24oRkOITL1t1CqXpEwpw91E+vAmm8YUKJrEa68lUsxegWB 9rFSJW95sHtp8/svz6/3s19wAglXgfuYftWB019Z2z+AipPQ52eaJRRw9fCoBv7PO2LsCwnV 9mMLJWytqmpcb7lc2Dz9YtD2mKVqJ33MKTmpT2R/C0+voE6O/tQnXq1AUCEB2hOizSb4lOIH fCMlLT+tOfzM5rSpY0HeufSERHpzvBJRvI3VXDjWt24DgY59k1C8vcEBFRAtxHdVPb6/Fasg ZFqp1riQeHZBhNWaq7ZZFbErqp5SH1bYfdwAyyCec5XKZO753BeG4E9+4jOFnxUeuHAVb6ln IUKYcV2iKfNJyiRhxXXvwmtWXO9qnB/DTbJUKhXTLZvruX9wYakU6/UscglbQX33DgOiGNjj 8QA7dcHpfaZvU6F2IAyH1CeFc4xwWhEv4EMDAsGAiZocq36CK03h/QkOHbqeGID1xCSaMQym caatgC+Y/DU+MbnX/LQK1x43edbERf3Y94uJMQk9dgxhsi2YzjcTnWmx4l3f42aIiKvl2uoK JtoBDM3d4+ePZXAi58S4keJqRyywWRKt3hSXrWMmQ0MZMqQGAe9WMRalZIWqz8k7hQceMzaA BzyvhKug3UYiw75QKBlrFISyZk2zUZKlvwo+TLP4B2lWNA2XCzuM/mLGzTRrh4hxTpbK5uAt m4hj4cWq4cYB8DkzZwEP1u54CilCn2vC5noBm07ng7oKYm5yAp8xc9Dsl5mW6f0ag1cpftqK OB8WKKaLimPMrtmfbotrUbl457G/n7FPj7+pncP7MyGSYu2HTBldDByGkO3A/0XJtEQH43Rh eng5LmexC5ow0MwI1AuPw+GmoFYt4HoJaBA426WMvqDsYppVwGUFQZROLr8o+Mz0kGyiWh9M ubrsebGeMxUSJ6b6JjDwimm1cw8yaAKN+h+75sflfj3z5nOGu2XD8RI9HBzXCk+ND1Ml40jf xfMq9hfcB4pAjzqGgsWKLaFJdzWj/MjiJJl6lmdyUTbgTThfc8pusww5PfQMrMKsPMs5Jyd0 7DCm7/m+rJvEg1Mgh0uMGdjvyDWavDy+QBTQ92Yy8vMBxxsM1zv3Vgk4p+9dNziYvTtElBO5 TYCXfYn9HjSSt0WsGL4PSQmn4AWEfDZXuDhXlWQHMegIdsrq5qgf3ejvaA3h3dW4X8/Vlj9S 0n5H4qFH58y6GduAqdEmatXWHt1XdTPDW9ESbIbusZWFycjzzjZ2LEIkF5IbpjJdwHtiWKij wZNGQEhtkcQ00nvnTERhIVqHD3OaSsRbKzMhKgigjAoEpKGI4vkSGQKJs6R1LDbVtmvNmHMF 7rRIMHoTbw9/OEAQmd5CBU0JgQRpdnMtRUwXDum0RABD2IgkVty/oZ8P4cUEHQM9u2nST2er F5tDu5cOFF8TSAdW3sOItGKHX1SMBMIOUA3rDrhD3WTk8gouVu3MulB6GfYvJI+0Gb1BL+1n PWipDgLpoOjbOKqtuiH7YIvShfaj84EqAI1mHq2sqNlYYykSf3uA0HSMFCEVVz+o7f4oRMzk HrPcHLeu9xmdKZh9o1bfaBQZkZiPtZreGaxY2Q11PJ775xmji6ZkQUXFQapleWX/NtGXZ3/P lyuLYHmVATkQyTjL6OOTfeOFB6w5du+/4AA1zTEMord/HDaz4LrUfRFQ2Fxbgk4niZmkoW7A 8UpP++WXcYOhPqu1u7VcCektuwfBSQpmB4Lo5naVlo1Et0mIJjqxPQY7C2wpAEDV6X9ZfU0J iUgFS4iwcRgAMq3jEp8k6nzjzFUrgVCkzdlKWh/JQzMFiW2I/beetvDeQtVkm1DQSlKUWSkE uhvQKBEYPaJEPXbyM8BqLTlbsCDH6wPUnyKPy1B93W5udZR6ERWKD9COAFZvpXRkJ3IHAyhp hP4N92dHO5HVigFzrEN7ksDW3x24ifK8xDuSDs+K6ti41RBc3bS1jgCfeanr5+r++enl6c/X q/3bj8vzb6erLz8vL6/IUG8QHR8lHZfDaAfx7keOrzMpfGqjAGGAsaG4+W2rawNq7nmU5Gpl 9iltD5vf/dli9U4yEZ1xypmVVGQydse2I27KInFqRoV1B/bSyMalVKxWVA6eyWiy1CrOiTt4 BON5heGQhfEx6givsE9aDLOZrHBciwEWc64qEHRDdWZWqh0stHAigdpEzcP36eGcpSsmJi5Z MOw2KoliFpVeKNzuVbhaqbhS9RccytUFEk/g4YKrTuOT6JMIZnhAw27Hazjg4SULY0uVHhZK eY1cFt7mAcMxESwmWen5rcsfQMuyumyZbsu0aaU/O8QOKQ7PcBxTOgRRxSHHbsm15zuSpC0U pWmVKh24o9DR3CI0QTBl9wQvdCWBouXRpopZrlGTJHI/UWgSsRNQcKUr+Mh1CFidX88dXAas JMgGUWPTVn4Q0MVp6Fv15yZSm9sExx7D1Agy9mZzhjdGcsBMBUxmOASTQ27UB3J4drl4JPvv V42GDHHIc89/lxwwkxaRz2zVcujrkNweUtryPJ/8Tglorjc0be0xwmKkceXBoVjmERtam8b2 QE9zuW+kcfXsaOFknm3CcDpZUlhGRUvKu3S1pLxHz/zJBQ2IzFIag+fpeLLmZj3hikya+Yxb IW4LvfP1Zgzv7JSWsq8YPUkp22e34llc2U9Zhmpdb8qoTnyuCn/UfCcdwHTkSF/d9L2g3anq 1W2aNkVJXLFpKGL6I8F9JdIF1x4BjvSuHVjJ7TDw3YVR40znAx7OeHzJ42Zd4Pqy0BKZ4xhD 4ZaBukkCZjLKkBH3gjyAGrNW+r9ae7gVJs6iyQVC9blWf4jhP+FwhlBoNmuXEMh9kgpzejFB N73H0/QWxqVcHyPjBz+6rji6PtyZaGTSrDmluNBfhZykV3hydAfewNuI2SAYkg5f59BO4rDi Jr1and1JBUs2v44zSsjB/AuWWu9J1vekKj/sk6M2wXocXJfHJsNu3+tGbTfW/pEgpO7mdxvX t1Wj2CCmdz2Y1hyySdpNWjmFphRR69sG38Sslh6pl9oWrVIEwC+19Fv+UutGaWS4s05NGOLh 07+hi41BWFZevbx2LimHmxFNiu7vL98uz0/fL6/kviRKMjU7fWyg0kH6uH/Yslvfmzwf7749 fQEHeJ8fvjy83n0Dg0hVqF3CkmwN1W8PmwGr38Z1wFjWe/niknvyfx5++/zwfLmHk8iJOjTL Oa2EBug7pR40ccLs6nxUmHH9d/fj7l4le7y//IN+ITsM9Xu5CHHBH2dmznV1bdQ/hizfHl// urw8kKLWqznpcvV7gYuazMN4zb28/vfp+avuibf/uzz/z1X2/cfls65YzDYtWM/nOP9/mEPH qq+KddWXl+cvb1ea4YChsxgXkC5XWLZ1AA3x1oNmkBErT+VvrDwvL0/fwJT8w/HzpWeimw9Z f/Tt4Oeemah9vttNK4UJn9fHZrr7+vMH5PMCDilfflwu93+h4/sqjQ5HHMnUAHCC3+zbKC4a LNhdKpa5FrUqcxzxx6Iek6qpp6ibQk6RkjRu8sM71PTcvEOdrm/yTraH9Hb6w/ydD2nIGItW HcrjJLU5V/V0Q8CJye80xgQ3zsPX5iy0hcUvwge+SVq2UZ6nu7pskxM5yAXSXgdh4VEIsHIA h5t2fpk4dwX11vD/K87Bv8N/L6/E5fPD3ZX8+R/X6fH4bSwzu0QFLzt8aPJ7udKvtS0NXLTH dr5wm7awQWOK8saAbZwmNXHdBNemkHPf1Jen+/b+7vvl+e7qxRga2Evp4+fnp4fP+FpuL7CX hahI6hKCR0n80jbDdn7qh7ZHTwU8h6jwvVqffZ80b9J2lwi1KUYKHhjUgJc+x/fB9qZpbuHM um3KBnwSaifR4cKl6/h1hjwfbtZ2st1Wuwjus8Y8j0Wm6iqrCN2EKynV4HlhfrfRTnh+uDi0 29yhbZIQ4n4vHML+rFaj2abgCcuExYP5BM6kV/rr2sNWdwif430RwQMeX0ykx85QEb5YTeGh g1dxotYrt4PqaLVautWRYTLzIzd7hXuez+B7z5u5pUqZeP5qzeLEKpjgfD7EpArjAYM3y+U8 qFl8tT45uNL1b8n9Zo/ncuXP3F47xl7oucUqmNgc93CVqORLJp8b/YqmbCi3b3Psr6lLut3A X/tq8CbLY48cL/SI9mLAwVgtHdD9TVuWG7ikxCYpxKs7/GpjcmWpIeIgSiOyPOK7KY1pOWlh SSZ8CyJKlkbIhdxBLonR3a5Ob4nviQ5oU+m7oO0fp4NBItXYTWhPUJJQ3ETYdqSnEA8qPWg9 LBtgfEg9gmW1IW5Le4oVg6+Hwf2dA7r+JIc21VmySxPqrLAn0sdqPUq6fqjNDdMvku1Gwlg9 SL1oDCge02F06niPuhpsyDTTUOud7pF/e1K6BTo9gyCozvt/szY7cJUt9A6ic8r+8vXyihSO YbG0KP3X5ywHIzPgji3qBTWLwYGTdBH7unjAz2ry1wwOjoLOSn3OGZpM42NNHtENpKNM25No weFGHQkngb50zoo/Uu0mifke7uDV2g3R8iAUXeAk+ISVuQGN86OO5FaBE8Y8E1nzuzdaoOCP 26JUmoEaZNZWhaTUybQ1WZlHNWO5wqTemMRIjwB3Gdp3JJZZewEv/YHjJHVbo/jv3FH0+Xmt NigkGqb6UFvwEIF3qGJ9XP1mAS1l2x4lk6QHyczrQWPbZc5eZFJcxVGVuTapgLbRCQ03JDbG rSex8dqNRw56Oepp8e7XcAY7mYH6S040LXLzbunxgiHtsl1EXAl2gG4q8mPWodqkzkkrPKxc INRzUWt67m9VTdCow8++7HGT7YzIMCB7tZSkQ/QmbEFh3gzQ0e7BuhJy58KZ3DeVCxMu6kHF m03pFqdXpQ1+DtFTThumIro3sBgbytQPUCms5Hilw7kSkySR5nlUlOcxhNWoUeh37O2+bKr8 iNrb4XhZKfMqhicWbwQ4l94y4LAWb9/2N6qHCu0lpbMgir893X+9kk8/n+8511rwSp2YOhtE dekGHZnG+UHWsTFfGsB+QTIv3THcHsoisvHutYcD9289HMJNG1UbG902jaiVJmTj2bkC610L 1Tvc0EbLm9yG6sSpLzzIcGprNrYWaJ502GgXy82Gu9cwNtz1cLKBoDaq+2NscxfnlVx6nptX k0dy6TT6LG1IB4f1nRoqXlG7XbsnC91IpVzB0TlfzSqTjVp6MDdEtTgthd5/Z/EB11GAAWjW 2JB0kCbedAU4BXbBaLVWRmzZt41whvdcREptrJxeAKtqe5DBDpxv4x+wjtGKy303PWLBoaI5 4hdfnQGzUuUFk7jBA5x2jVCdkrmdfUZHU/vVHFhN1CsG80IHxG4dTBFwlATv/OPGbbPadSi5 gsclVh3gIeYez9E5uTL0dJTlmxJZfeqzL0BGXbQTka3YH7EqAi+S2jlMnPpGjS39qD9aM7Dz PIOk3WfzUM0zGwx93wa72lo2hNquPqpipR9W1guPKontLMBgXyTXFqxtZ9XfU2RjZEk30BhQ 1ejncJb+cH+liVfV3ZeL9p3huqHuC2mrXaPj0bxNUdTgRh+RlaKdb6mHVSednuvywwQ4q3Fz 8UGzaJ79ovxmw11c10jKRukdxx2y4C63rWWzrIeyx7r7iO9Pr5cfz0/3zGunFCIpdx790C2E 84XJ6cf3ly9MJlSt0T+1MbmN6brtdMiAImqyU/pOgho7DHWoktgnI7LEFgYGH8ykx/aRdgzi Cg40bsxDQ3Nx8vTz8fPNw/MFPccyhDK++lW+vbxevl+Vj1fxXw8//gXH7fcPf6rRdvyxwRpc iTYp1eQrZLtP88peokdyX3j0/dvTF5WbfGIeqZnT7DgqTthKpUPzg/pfJI/4xaQh7ZQ0LOOs 2JYMhVSBEAX+bDxmZipoag4XD5/5iqt8+vd4SEvQbtpByVNyGh37IoIsyrJyKJUf9Z+M1XJL HyX82tM1GJ+0bJ6f7j7fP33na9trfea05g03ondbgjqEzctcf56rf2+fL5eX+zs1+6+fnrNr vsCkipTqEndOcvD15wc5DHcsfL6wJO2q+OTTUSb3KG5+oGf+/fdEjkYHvRY7NMs7sKhI3Zls Op+Gnx/umsvXCRbvVhm67igmrKN4i32sKrSC0NY3NfHpqGAZV8bzz/hugCtSV+b65903NXYT jGAkT1pkLd6HGlRuMgvK8zi2IJmI1SLgKNci6ySCtChKeu0tuU7FXi/wqKwcEmrPc6mTQ+VX TmJpf38TF1Ja07FTEmo8tmy34XnSaYZo8tzKGKJoLJeLOYsGLLqcsXDksXDMpl6uOXTNpl2z Ga99Fl2wKNuQdcijfGK+1esVD0+0BFekhniFMT4/MwkZSEDQNWxK1Ouju3rLoNzyAQzQ7WaQ /q892fLp9QWrJAebkAfeKOhIqJYUPz98e3icEFQmMEh7io+Yb5kvcIGf8Lz5dPbX4XJCcv4z VWDYCAg4ptzW6XVf9e7n1e5JJXx8IouBIbW78tR5um7LIklFhK9dcCIlQ2CXERFfBiQBrGMy Ok2QwdWgrKLJr5UCanQ2UnNH3VEKcT/I3bmsbvB3txPa9AQe7d7s0jTc51GUceVWiCSpKoH2 Vem5iUcPNunfr/dPj31scKeyJnEbqV0ODTDXE+rsU1lEDr6V0XqBX6R2OL116UARnb1FsFxy hPkcm+ONuOVCsyNUTREQo68ON3JcrYP6OZlDrpvVejl3WyFFEOAnQR187IJUcYQYuUUZtERR Yk9scFaRbdHW2jz0b4sU+y7vjzkw1o2nhIu6cRuEK5LBO0QdAIok6LAWh+NGMLgNVkrVkbip BPoB7ncgFYU7D4dKxezKIlTzX3xOir6h1epLlTA5hyQ+TiJv3KegBu6TT1TNTJ7v/8w8Ex2J 99AaQ+ec+JrrANu80YDkbHsjIg/Pg/9v7Uqa20h29F9R+DQvorvNXeTBh2RVkSyzNtUiUbpU qCW2zWhrGUmesd+vHwBZC5CZpfaLmIh2i/UBuW/ITAAJ35OJ+Pagw+r3Wt2oGR+jiOR9JV6I 8tWUX877scp9rlSggZUB8Htl5uJDJ8c1Qqj1mlNxTTXfIqJWKtugeFs4QEPvX+/R0Z+rQd8f Cn9lfBrXSgTJS6WD93k/Ho2533dvOpFu/BVIWHMLMK7kG9Bwwq/OFwsZF8i0EwGs5vNxbXrj J9QEeCYP3mzEr3IAWAgl88JT0mKlKPfLKdeYR2Ct5v9vKsc1Kcqj34CSO0Hxz8cToTV6PllI 1eTJamx8L8X37FzyL0bWN0yesAijRS+q5UUDZGNownqxML6XtcyK8KCA30ZWz1dCift8yZ/c gO/VRNJXs5X85j6Y9WZbxWruT3B5ZZRDNhkdbGy5lBiePtJjExIm9z8S8tUK54xtJtEoMVIO kssgSjO0PC8DT6hUNCuPYMfLhShH0UDAuLzFh8lcortwOeP6B7uDMKEOEzU5GIUOE9xSGrGj mqMvoSjzxkszcOPwyQBLbzI7HxuA8CeOAHfZhLKJcEeJwFi8R6uRpQSEp08AVkJVKvay6YQb JiEw4y6hEFiJIKguig8IxOUCZCX0AyJbI0jqm7HZSRJVnQvTa7yKkiwkG10q/T6TcI1NFO0g qz6kdiASqMIB/HIAB5g71UNvL9vrPJV5anyQSwz92RkQ9QS06TC9vWtHP7pQfLbtcBPyN4Uf O5k1xQwCo0RCdEVoDLGSijtajh0YtxdosVkx4mqFGh5PxtOlBY6WxXhkRTGeLAvhFrGBF2Np ikYwRMBt0jUG+/KRiS2nXGeywRZLM1OF9s4vUf3Oq1krZeTN5lyh83KzIM9KQv04w8dUUYtW 4M2Oten9/7lRy+bl6fHtLHi858d1IG/kASyj8ljRDtGcPT9/g/2rsSQupwthXcK49O371+MD PTmr3avxsHh3W2e7Rtriwl6wkMIjfpsCIWFSG8IrhHOCUF3Inp3FxfmI2yRhymFOWtPbjEtE RVbwz8ubJa1i/d2fWSqXgKjLVRjDy8HxLrGOQCBVyTbq9ti7033rrA4tPrynh4enx75emQCr NxtyejPI/XaiK5w7fp7FuOhyp1tFX4AUWRvOzBNJtkXGqgQzZYq+HYN+m7U/TrEiNiRmmRk3 TXQVg9a0UGP3pMcRDKlbPRDcsuB8tBAy33y6GMlvKVjNZ5Ox/J4tjG8hOM3nq0lu6Dg1qAFM DWAk87WYzHJZeljux0Jox/V/IU255sIruf42pcv5YrUwbaPm51xEp++l/F6MjW+ZXVP+nEoj wqVwS+JnaYkOVRhSzGZcGG/FJMEULyZTXlyQVOZjKe3MlxMpuczOueo+AquJ2GrQqqnsJdby QldqHzDLiXzURcPz+fnYxM7FnrbBFnyjoxcSnTqzvnunJ3eWnfffHx5+NuedcsDqB5GDS5BH jZGjzx1bW6MBij6KKOTRh2DojmyEBZvIEGVz83L87+/Hx7ufnQXhv/F5Fd8vPmZR1N6/an0M ul2/fXt6+eifXt9eTn9+R4tKYbSoXdgbehwD4bS/66+3r8ffI2A73p9FT0/PZ/8F6f7r7K8u X68sXzytDUj/YhYA4Fw8y/6fxt2G+4c6EVPZl58vT693T8/HxvTIOgkayakKIeHsvoUWJjSR c94hL2ZzsXJvxwvr21zJCRNTy+agignsNjhfj8nwDBdxsHWOJG1+jBNn1XTEM9oAzgVEh3ae 1BBp+CCHyI5znLDcTrV5uzVW7abSS/7x9tvbVyZDtejL21mun/R8PL3Jlt0Es5mYOwngD9mp w3Rk7ukQEe+bOhNhRJ4vnavvD6f709tPR2eLJ1Mue/u7kk9sOxTwRwdnE+4qfHqXv8GzK4sJ n6L1t2zBBpP9oqx4sCI8F6dM+D0RTWOVR0+dMF284YNPD8fb1+8vx4cjCMvfoX6swTUbWSNp JsXb0BgkoWOQhNYg2ceHhThLuMRuvKBuLA7HOUH0b0ZwSUdRES/84jCEOwdLSzOMo9+pLR4B 1k4tPCtwtF8v9MtUpy9f31wz2mfoNWLFVBGs9vxRD5X5xUo8ZknISjTDbnw+N755s3mwuI+5 FR4CwrUTbAKFOyJ8dG8uvxf8CJQL/6S6jUrIrPq32URl0DnVaMRuJjrZt4gmqxE/kJEU/ogI IWMuz/BT76hw4jIznwsFW3TuiDvLR+Ilvm7/Yj5WWObyyb1LmHJm4gVXdZhJxzkNwgTkNEN3 RSyaDPIzGUmsCMdjnjR+z/hgL/fT6VicINfVZVhM5g5I9vceFkOn9IrpjLvCI4BforTVUkIb iPdvCFgawDkPCsBszk0hq2I+Xk64/1IviWTNaUSYRgVxtBidc55oIW5rbqByJ/p2qBvBcrRp VZ3bL4/HN32Q7hiH++WKW+XSN98a7EcrcdTX3PHEaps4QeeNEBHkjYTaTscDFzrIHZRpHKDV 0lS+pzudT7gNbjOfUfzu1b3N03tkx+Lftv8u9ubL2XSQYHQ3gyiK3BLzeCqWc4m7I2xoxnzt bFrd6P2r5sZJUlyJIxLB2CyZd99Oj0P9hZ9LJF4UJo5mYjz6drTO01KRUZtYbBzpUA7ahwzP fkc/GY/3sCl6PMpS7PJGO911zUqvQedVVrrJesMXZe/EoFneYShx4kcT0YHwaIrjOrRxF01s A56f3mDZPTlug+cTPs346CpUnuPPhb25Bvh+GXbDYulBYDw1NtBzExgLg94yi0zZcyDnzlJB qbnsFcXZqrGOHoxOB9FbvJfjKwomjnlsnY0Wo5ipMq/jbCIFOPw2pyfCLLGqXd/XinvP8LNi OjBlZXnAHVnvMtEyWTTmArX+Nq5tNSbnyCyayoDFXN7U0LcRkcZkRIBNz80ubmaao06pUVPk QjoXm5ddNhktWMCbTIGwtbAAGX0LGrOb1di9PPmIvnPsPlBMV7SEyuVQMDfd6OnH6QE3C/iK 1/3pVbtZsiIkAUxKQaGvcvh/GdSX/GRqPZbvfG3QnxO/AinyDd/UFYeVcG6KZO7pK5pPo1Er u7MaeTff/7EHo5XY8qBHIzkS/yEuPVkfH57xSMY5KmEKCuO63AV5nHpplUWBc/SUAXfFFkeH 1WjBpTONiEupOBvxy3f6Zj28hBmYtxt9cxEM99Dj5VxciriK0vIn/JlL+IAxxRQbEQj9UnLo 511Krm2FcBYm2yzlnusQLdM0MviCfGMladj+UEh8XVa6D7+MA7KcbrZg8Hm2fjndf3Ho0CFr CQI3fz8PsY3ad2ftFP7p9uXeFTxEbthyzTn3kMYe8spHkYWhHHyYz6gi1JoVilC2KhuCjamd BHfhmrtGQoheNZ9KDNXO8fUKA22utiVKr4bzY2EESRNXIo1tHZq3CYLxPFIHQcYsNOuMWsL8 4uzu6+mZudVvRy8Umz8TjO8T5aoWLzh8JkNBxdna/IHE5CEz9E0HMb9wBMlv1NgglcVsiQIs T7Rl3y11KuycOb/oX6NRoR9wS674gPSiDIyDZ7MCugCZ8vbSW4C+nS3JX7iQttFnEgRIvZL7 ToK1DU3Ye7cCPyVFlTuug96Ah2I8OpjoOsgjWZGEWo/lErwr/L3JinokJhappAwvLFTfm5iw fn3OBWoXK7XKrYw4bGU1QdsOpOJx5p6Q8etvjevbA5Ob+necjedW0YrUQ79TFiz9eGmwDEnF XbytR4S2Kw3h9TaqApOIrwcy41K67mzbhcwy+wAGcaEVJbU4sbtG72WvpEnej8nmDRTy8PLT AdZxCPtOX5ARbu/CUJM3Ldk6gUTjFTaEtHaH8NjSwIuQpWESV44w1EWWayRMHJR6e4j+iTZ1 0sYTNRywIU6Nl5uQw7veJujkxiLQA2a5LEFn0Y8p1VaZkZwUjmz0BCPzSTFxJI2odgjsG/Hk mCnFlQ5ZVh2F028XQvMM4WYRWkoBHTo3kiHN7fiwjC8c7RoegmioLzS2xlagxjDZgcM0huNh 7YiqwHd0ktRRy3oCg0WyMojN647nc1JRb53VmKMivgzWVQ1ssMJUZRwaBWyoywNmzMqXJnvZ eDxy0rODqifLBESFgj9aJEh2ibQ2o13ZKst2aRLgE2tQgSNJTb0gSlGnIfeDQpJoibHj06Zm dvKEY0fcFYMEszS5IhNcKw2t6hYkU8co6M2ErB7ckcrrLDCSarQy/cz0LMaI1COHyZSg6AWt 4YFdG908/z5pOkCyy4aKJ6jVN4Y9P2bUmkI7+myAHu5mo3PHxEyCHnpm2V2zOkNflq38IScv WPOyMAuMrJcQQ+OClqNhvY1DtHUUlrVyieoCoE2Rxx/DirkRRqx95ksgyjpNouz4gu9L0x70 QV86uh58eo+tW465mWG5qxIf1eui3kTCcrup3WwyS+TG7+Y6xLDkC2GAxrcXRqj2VasPf54e 748vv3393+bH/zze618fhtNzuhGwHHqG6+TSD2O2RVlHe0zYeLcL3aVxv7Tw7UUqZLsl5OB+ CfGDOxcw4qNU0RMufz9UHRq/9gITVl0EsGiEt1P6NPdsGiQZPoyNoASnXsqdJmlCK/YE6NLA CtZSHQFR1duIEbdywaayDH4vNjLubv4ymHXEuHA7s6pHMLqRYnF1U4kzLq36Y2azNdF3BsHn fKHc24zLtOoSrQesSmp0ktt49A3/1dnby+0dnX6Z+8WC75HhQ/umQj220HMR0BFLKQmGXhFC RVrlXsBs4G3aDmbMch2o0kndlLkwYdTPu5Y7G5ETU4dunbyFE4WVxBVv6Yq3dUHWqxvYldsG or3MA/+q423e7XIGKbXik3njKybDqcXQTLNI5KTGEXHLaBzamnTvMnMQcW80VJZGzdkdK8yg M1NTqKXFsMM8pBMHVfvDtAq5yYPgJrCoTQYynLL1wWJuxJcH25DvEmFCdOIE+sJjcYPUG/50 NEdr4TlBUMyMCuJQ2rXaVA5UdHHRLnFmtgz3uQ0fdRKQaWKdiCclkBIrErCljSgjaK1eG1fo XHYjSbARZ/NIGXRzD/xk5tz9CSuDu0kQXxqCBjxQE5q3lw7nEhWq7G/PVxP+ELEGi/GMH6Mj KsuJSPNWmusK1MpcBitAxuSjIuTaFfhV2/5aiyiMxVEUAnoBkl4ZejzZ+gaNLjHhdxJ44j0Y 4yElflPpJaVJaG85BQl9kV1UytcO1ft7N3loq3U6T+iMnqRGfoyr8B6kDMgXqsoL4fgO/ZSK B1aDQzmRflc1YLlXbWCXd9WG5HCueiinZuTT4Vimg7HMzFhmw7HM3onFcFb5ee2z3Qh+mRwQ VbwmB6lsmQ/CAgVVkacOBFZPnBk2ONnbSQ9BLCKzujnJUUxOtov62cjbZ3cknwcDm9WEjKgj gF75mCh5MNLB74sqLZVkcSSNcF7K7zSht2sLL6/WTkoeZCrMJcnIKUKqgKop643CE+T+aG9T yH7eADW6ucTXG/yISc6w5hvsLVKnE74L6+DOxUPr0dfBg3VYmIlQCXAa36OnayeRi+/r0ux5 LeKq545GvbLxyiiau+PIqwQ28AkQ6RrLStKoaQ3qunbFFmxq2LiEG5ZUEkZmrW4mRmEIwHoS hW7YzEHSwo6CtyS7fxNFV4eVBNnyoIxrxDPk/HloDsILPx55i8CmEXobLFo84RB95ulOyK+I Eh/tEq8H6BBXkNCbV0aGkrQUle6bQKgBfdPXB1QmX4uQKX1BbhbisIBFlfuVMUY7faJHezrH okVyI6ozywFs2K5UnogyadjoZxos84DvFjdxWV+OTYBN5RTKK1mjqKpMN4VcRzQm+x+6AReO esXeL4U+HalrOTN0GPR6P8yhk9Q+n6dcDCq6UrBr2+ArPldOVjy5ODgpB2hCyruTGgdQ8jS7 bq8lvdu7r/wpmE1hLGcNYM5OLYwHyulWeA5qSdZaqeF0jQOljkLu/pFI2Jd53XaY9SZ4T+Hp s/e3qFC6gP7vsNv+6F/6JBBZ8lBYpCs8KhcrYhqF/ErzBpj4gK38jebvU3SnotWo0uIjLDcf k9Kdg42ezno5t4AQArk0WfC79U/pwS4B3cN/mk3PXfQwRZeQ6PT7w+n1abmcr34ff3AxVuWG OXxNSqPvE2A0BGH5Fa/7gdLqQ8fX4/f7p7O/XLVAApDQHkBgT7tnieEdIh+7BJKD/DiFBSrN DZK3CyM/D9g8uA/yZCN9o/HPMs6sT9dMrgnGqrOrtjDBrXkEDUR5ZHN4EG9g45AHwlkcvtNQ 71RBDtSTMvSMUPqPbhpW646a7dLBd+5psNCzRVzCyFWyDYxmVr4b0M3cYhvzOQZabNwQHpUV 9AYWqxIjPHxnUWVILmbWCDAFDTMjlnBrChUt0sQ0svArkAgC09dRTwWKJbtoalHFscot2O4j He4Uu1tx0CF7IwnvwFCZD22qU1rgC5PlBg08DCy6SU2I9HAtsFqT/kP3dESTKr5vWSdpEjje i+AssIanTbadURThjfuJCs60UZdplUOWHYlB/ow2bhF8TxqdsPm6jth83TKISuhQWV09XJS+ CSusMuZF2QxjNHSH243ZZ7oqdwGOdCWFNQ8WNfkmAH5rGRHf3DAY65jntrioVLHjwVtES4x6 kWdNJMlaDHFUfseGR3dxBq1JZvOuiBoOOiJyNriTEwVJL6veS9qo4w6XzdjB0c3MiaYO9HDj irdw1Ww9o5sfvADCLu1gCOJ14PuBK+wmV9sYHek1shVGMO1We3PjHIcJzBIupHHnDMK+HyrW d9LYnF8zA7hIDjMbWrghY87Nreg1gk8uoeu2a91Jea8wGaCzOvuEFVFa7hx9QbPBBNgm1K73 IAwKdxT0jRJOhEde7dRpMUBveI84e5e484bJy1k/YZvZpI41TB0kmKVpBThe345ytWzOencU 9Rf5Wel/JQSvkF/hF3XkCuCutK5OPtwf//p2+3b8YDHqey6zcsmluglujG1/A+Ouo59fr4tL uSqZq5Se7km6YMuAQ6gOyqs037tltsSUyuGbb23pe2p+SxGDsJnkKa74sa/mqMcWwvzwZkm7 WsDWUjymShQ9MiWGT+85Q7Tp1aR9iDMjLYZ16De+Xz99+Pv48nj89sfTy5cPVqg4xMdExOrZ 0Np1F58oDyKzGttVkIG4wdcOB2s/MerdbKdN4Ysi+NASVk372Bwm4OKaGUAmtigEUZ02dScp hVeETkJb5U7i+xXkD59sbXNylAdScMqqgCQT49MsF5a8k59E+zdedPrFskpy8fAvfddbPss2 GK4XsMlNEl6ChiY7NiBQYoyk3ufruRWTHxb0uESYUMXgyuqhflRhxWseSQTZTp4MacDoYg3q Evxb0lCLeKGIPmxPjCeSBZ8UTq/6AjTeMyXPVaD2dXaFG82dQaoyD2IwQEPkIoyKYGBmpXSY mUl9cu1XIPZJrRZNHcqHXZ+pr+Ru1dy92rlSrog6vhpqreBnCKtMREifRmDCXG2qCbbwn3AD cPjolyv7iAbJ7RlPPeOmYIJyPkzhNsGCsuTW9wZlMkgZjm0oB8vFYDrcv4JBGcwBN+k2KLNB ymCuuftOg7IaoKymQ2FWgzW6mg6VR7jzlDk4N8oTFin2jno5EGA8GUwfSEZVq8ILQ3f8Yzc8 ccNTNzyQ97kbXrjhcze8Gsj3QFbGA3kZG5nZp+Gyzh1YJbFYebgHUYkNewHsYj0XnpRBxU1S O0qegvDijOs6D6PIFdtWBW48D7i5UwuHkCvhvr4jJFVYDpTNmaWyyvdhsZMEOjnuELwq5R/m /FsloSc0WxqgTtCJfhTeaNmv08hkx+xCpUF7xDvefX9Bq8qnZ/QmxQ6U5bqCX7Q7UKUB5sFF FRRlbczp+DBICMI3bNKBLQ+TLb/ztOIvc7zW9TXan0bqS7gW5wnX/q5OIRFlnOB1y78fBwXZ upR56JU2gyMI7i1IfNml6d4R58aVTrPdGKbUhw1/ZbIjQ1Uy4SEqYvQwneHZRK18P/+0mM+n i5a8Q+XHncr9IIHawNtFvIUiYcVT4szeYnqHBBJqFNFLz+/w4PRXZPx4hLQVPOLA40bzYSgn WRf3w8fXP0+PH7+/Hl8enu6Pv389fntmisVd3UDnhaF1cNRaQ6F3sdHTtKtmW55GGn2PIyDP yu9wqEvPvLuzeOi+G8YB6ouiglAV9MfiPXMs6lniqDuXbCtnRogOfQm2IaWoZsmhsixIyP93 gv5xbLYyjdPrdJBA7yvjbXRWwrgr8+tPk9Fs+S5z5YclvSA+Hk1mQ5xpHJZMfyNK0TxzOBed 4L2uoLwhzmNlKe4+uhBQYgU9zBVZSzIkdDedHQAN8hlz8ABDo7Hhqn2DUd/pBC5OrCFhjGpS oHk2ae65+vW1ipWrh6gN2u5xmwGHskoH6U5UipfYeqIqruMY3+H2jFm5Z2GzeS7armfp3pZ8 h4c6GCPwssFH+1xcnXl5HfoH6IacijNqXkVBwQ/2kIAm93gC6DgGQ3Ky7TjMkEW4/afQ7W1w F8WH08Pt74/9qQtnot5X7Og1KJGQyTCZL/4hPeroH16/3o5FSnRcBlsrkHauZeXlgfKdBOip uQqLwEDxYvU9dhqw78dIsgI+Z7sJ8/hK5Xhyz8UCJ+8+OKCr4X9mJG/jvxSlzqODc7jfArEV Y7SuTkmDpDllb6YqGN0w5NLEF7eYGHYdwRSNKhvuqHFg14f5aCVhRNp18/h29/Hv48/Xjz8Q hD71B7fIEcVsMhYmfPAE/Bl2+KjxSAJ211XFZwUkBIcyV82iQgcXhRHQ9524oxAIDxfi+D8P ohBtV3ZIAd3gsHkwn84TcItVrzC/xttO17/G7SvPMTxhAvr04eftw+1v355u759Pj7+93v51 BIbT/W+nx7fjFxS8f3s9fjs9fv/x2+vD7d3fv709PTz9fPrt9vn5FiQkqBuS0vd0eHv29fbl /kguXXppvXmSEHh/np0eT+jC8PTvW+lRFnsCCjEoR6SJmNSBgIbxKEZ2xeKniC0H2iJIBvY4 oTPxljyc9855trkHaRM/wICiM1t+IFVcJ6a7Yo3FQexl1yZ64H7bNZRdmAiMG38B04OXXpqk shMjIRwKd/geDzv3MpkwzxYX7WJQ9NIqVS8/n9+ezu6eXo5nTy9nWgbuW0szQ5tsxQPEAp7Y OEznTtBmXUd7L8x24j1tg2IHMo46e9Bmzfn01mNORlv2arM+mBM1lPt9ltnce27C0MaAG1mb FfbsauuIt8HtANKdi+TuOoSh7ttwbTfjyTKuIouQVJEbtJPP6K+VAfrjW7DWk/AsXHrVacAg 2YZJZ9GSff/z2+nud5i5z+6o7355uX3++tPqsnlh9XnYpltQ4Nm5CDx/5wBzv1BtLtT3t6/o FO3u9u14fxY8UlZgvjj739Pb1zP1+vp0dyKSf/t2a+XN82Ir/q0XW5nzdgr+m4xARrgeT4U3 1HZMbcNizH2VGoTITZnMF3ZfSUHgWHCnjpwwFj7cGkoRXISXjirdKZiqL9u6WpPHcNxiv9o1 sfbsUm/Wdj8q7aHgObpy4K0tLMqvrPhSRxoZZsYED45EQGySD+W2I2M33FCo01FWcVsnu9vX r0NVEis7GzsEzXwcXBm+1MFbp3/H1zc7hdybTuyQGq5ha5x7/PCdk+36OdBk7GAuxyM/3NiT jXPyHqy42LdzEvtze17054M5j0PokeR3wy50Hvuu8YPwwu7wALuGDsDTiWN47PjTugwczKne XbnCAPxeqPnYbhoNvxdqaoOxA0OV/HW6tQjlNh+v7HSvMp0bLV+cnr8Ks8FuGrLHFWA1t/pl 8FAhVFKtw8KC0f01BHDwu0AQ6642oaMXtwTrVZi2l6s4iKJQDRKGBxNZcQ7FWpT2QEDU7nnC d0mPDaa7cS/T+526UfYyXaioUI6O3a5LjgUhcMQS5FmQ2IkWsZ2/MrArs7xKna3T4H016g73 9PCMDivFpqOrGdK2srsLVyBssOXM7tmofujAdva0QnqGTY7y28f7p4ez5PvDn8eX9uUMV/ZU UoS1l+WJPdT8fE2vt1W2TIMU5/KgKa7ZliiuJRUJFvg5LMsgx2NYcYDP5M5aZfawbQm1c4Ho qEUrQQ9yuOqjI9JWw56xlGPZpvMraZbZUq7smkCb7VBtVa7sfoDExjWOs7GAXMxt+QBxVcLM MCj/Mg7nwG6ppXvct2SY2t+hho61v6e6BGIR82Q0c8fuiYlFXYZVbGC8akvhH98i1V6SzOcH N0sT+U3oruMLzx7iGk/jwQYL420ZeO7OinTb/yTP0C6ICm563gB1mKGKUkhWrc4+1jKWkbtB L8O8FBGzLqY2wUG8CMzj9YQdHaOQb7CCe4mSh+jkQ0ocKrTErFpHDU9RrQfZyiwWPF06dPrm BVCgDWrIB5bNerb3iiVaHVwiFeNoOLoo2rhNHEOetxcZznjPaXOJgftQzeFkFmjdR7IE6XX3 9XKCL3H8Rfu817O/0GPS6cujdk179/V49/fp8QtzidCd+lI6H+4g8OtHDAFsNWxZ/3g+PvQX jKQPOnzOa9OLTx/M0PqAlFWqFd7i0Crqs9Gqu9DtDor/MTPvnB1bHDTfkmkg5Lq3rvuFCm2j XIcJZopMSTefuodM/ny5ffl59vL0/e30yDdQ+uSMn6i1SL2G2RYWSX41jp5KRQHWMPEE0Af4 bUPrJhJk4MTDO+qcXLrxzsVZoiAZoCboArMM+WWol+a+8AuXoz1KUsXrgD9yqLUKhIF767vS C00fD+imtn0KnU03HswHYSmmYm8spEkYttZ+DSausqplqKk4+oFPrtshcZgrgvX1kp+YC8rM eZ7dsKj8yrjXMjigtRzH3J4p9Upx32MqSLBHsDfCHtsKNlvbn31DJH4a8xJ3JGEa8MBRbQ8j cTRuQUEkEsOVUEtCFdYMPznKYma4y7xhyK4BuV2xSFuGBwG7ynO4QbgPr7/rw3JhYeTpLrN5 Q7WYWaDiqio9Vu5giFgE2vFY6Nr7bGGys/YFqrcoUPx0ENZAmDgp0Q0/WmcEbn0k+NMBfGaP b4dCDSzqfl2kURpLz7s9inpKS3cATHCIBKHGi+FgnLb2mIRUwvJSBHgh2zP0WL3nDuUZvo6d 8Kbg/vjIFUDfeirP1bW2LONyR5F6obacIoaehJa3YSrc5GkI9dVrMW0iLi5JEir/FsEaJvUt 144iGhJQQwq3GqbJL9JQa6ou68VszS8+fbok9yJFVis72lVJKu5pDP0OAdfcpKXYRrqTsDsy 2AxXtakFpZ1gODQpvKxCfyR1utnQnZyg1LmoJP+Cr0FRupZfjoUgiaSueZRXteGSwItu6lKx qNAdeZbye4c4C6U1oF0MP4wFC3xsfO6FMfTJ6VdR8svwTZqUtv0CooXBtPyxtBA+JAha/BiP Dej8x3hmQOiqNHJEqEAcSBz4ePRjbGJFlTjSB3Q8+TGZGDDs3ceLH3zdLvDF5oj3ywJ9kKbc 4AI7gx9kKWeCriw6BN5Kc71S1G5Mtk5lT0to61pm/Vltt+1RSXc/2wrWhD6/nB7f/tZvbTwc X7/Y+qEkIe5raQPdgGh6IMaCthZDXbEINe66W7/zQY6LCl1IdFpl7TbDiqHjQIXANn0f7XVY V71OVBz2NiddFQ2WsjvWOn07/v52emgE5VdivdP4i10nQUJXfnGFJ43SU9UmVyBpolcWqVcH 7ZfBjIqORLmdGmrnUFxA6tEqAUnXR9Z1ysVa25HRLkA1O/RzAt2Kj+yWYGQPLeFj2KPofbOQ 0Zs5UNswoTuEWJWeVKoTFCokepW6NkufpeS0xso3KrM1NjXory2reBv9cit0XUVtQ/JykTP/ 9gzs1Bh0a32Cwe7i0o8lmHlF1xeBhaKPiHav1KhD+Mc/v3/5IraqZEcACy8+6c51LAhPrxKx faY9dRoWqWwMiddJ2niVGuS4CfLUzC6x5MHGxLVrGatfNbBDBpf0jZAdJI1c8Q3GLBWoJQ2d pu+EcoOka4P3zjvgAFczMttZo2vxIqrWLStXuUTYONIkFeymF4CEE0F/tXrHP+A1LkSox7lt DwRGA4ymwCyInR7OxmrCjgc9GNWFx9W2m4FMekBVIdyiaBJXEWsRutyUqv0dKV87wGwL26mt 1dSQL/S3JZXSmu6oBz3KdnyrTgeD9V5BB2/F856qYS0/jS1dpH7wGbFBIC+91G7Iar4naupm F9KkoW9yMZIzfPf6+7Oecna3j1/4A26pt69w619CFxNqyOmmHCR2iuucLYNB7P0KT6NePubK aJhCvUPX8CXIlY4d+tUFzMkwM/upWP2GCtjPJJggukkRLtUE3OVHEHG0o7lsrwUPHci3lKgJ lLcDhJn69sSn+y2quBtLl246THIfBJmeLfWpFepAdF3h7L9en0+PqBfx+tvZw/e3448j/Di+ 3f3xxx//ko2qo9ySYGW6Ksny9NLhMY6CYb7NfOG2p4LtVmCNiALyKt0vNCPFzX51pSkwN6VX 0nakSemqEKbuGqWMGRsW7QIlswBUpiRZgXWuNg4gO3pWo/VepiheFVEQZK70sSLp3qlZQAqj 3mB84N7CmPT6AruE2/+gbdsI9aiHEW5MUNSzDBcFJMNAZYDIhRes0P/0UZQ13+oFZgCGRRYm Y364yRYR+HeJnv4La2odpkivb8306QILS4Ajf4OhYxH2cihfUobaakRfn3qVU4Chvg9Edu7g bDpcs/ENNwc8HACXABJWu+ljMhYhZQshFFz01sn9y30i88YgumikzbyVM2XFU3cEEQ3Pc7lO ImRtB1NypNdPch5Cj1WwE4qmeusgz+mB2Nbovz9rjt1MPUe6IR3U4fjYNj8otYvrd7mGXWuq MCoifgaAiBYMjcmCCLHaB62ln0GiF2F1e0nCBgcvx0ReHHsWnVLsuRKSYfsRW5tWUXiUm3jX JTfqSuitWuDOjYG4qRId4fvUba6ynZun3VqaLk50BDqLMcmm1LS5b7CgMz7q8shJ+yNT4vSa gDoWNvIoO2SIZaStU/Xk2kLHBKZXNthJ42kF8IvFDDs3DgL9iqNVcBZV4y1BOonIYB8Qw34S NlHOYlnptYevZkINo70Im7U92I7/0IQsp1QV3BwkvwDZa2MF0cKI1ReuoN/ZqeuWaNq4sNqu SEDi3aV2o7aETjSWFbyGtQitcfKU7lAbnf7e9U+DqyTBt6fRRoUCBIXbU1DLDt3QxchXSauI 7QMutm/fPcS7Dqx6rdzwOttYWDu2TNwdw9BI7LpAU067fQbGZ9t61q63JZQKlrKslsR+SP0K B92Pu/sHdnx5YI4XvM272mZfoiHmunHlY7UnP7jI7tyyIUKnasbCrYsRoMUDHs1jBbNxjXut tnuZ7ZJDnePlK8ZHZdWaVl23jPZ+GTs7LFUaXXcXMCsMswxSddcsuENuJ9+6W2WwEwzz5XRt YtFbKr/X6eTYdprBQwusPWcM/RjVhxwDKWj5ezGTknJLZBYug/FTfe2CA3qUeadC9WGzvulw zREtV6ENcWToPRDK9DAUrNE4eBBgc/xtRgUwSD2R2wcecaBZ2zBV32sN09Hh8wYWtmGOHO+p yVnAO/UJLMPU0FfDRH3MP1RV0T62quQyJrltKAgp75E3AKOCM6vKUZlkl9Jh2SVPZhPiq1sh m2aGEmvNO42YG8fDZs4rmleGexM5E5B+IXR/isl5lowMjcBgJXbtVXXLtncfRhq4SeWePNrI JAqAnB31uWHtq1KhbkletR7jey+dCl2yuQYLSXf6xnbrM0nc/mof7vXMx6WIaOyoe4wcPKZc vGA0ui7RA/rTh8vxZjwafRBse5ELf/3OsTlSoYHo1WEZBiXJMKnQYWqpCtRm3YVefyxUrQt+ QEmfeKatonCbxOKiVncV4jcWn3ZDb4uJjZcsbxNVXKmkk6RtG0WpC0WHAOSWHw3VUq+KG5Hj /wCEkOkOxqcDAA== --u7wedkesix5licz2--