Received: by 2002:a25:7ec1:0:0:0:0:0 with SMTP id z184csp2496610ybc; Sun, 17 Nov 2019 23:13:40 -0800 (PST) X-Google-Smtp-Source: APXvYqw59AjS8bh2iel9dI4ZHYST7SJUukvpDdsxLiV547hHE72+56DC+ueQYKpMlon6bJ2y8PCm X-Received: by 2002:a17:906:8305:: with SMTP id j5mr13075765ejx.48.1574061220422; Sun, 17 Nov 2019 23:13:40 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1574061220; cv=none; d=google.com; s=arc-20160816; b=020gQt1yRmtxzeHQvrb+dbw8KHsKwmTBGapZBYuw+DqDvgjT3AAVJwjgzEFkKVIVNC PdtQsaHZUM7vsgPGw9gUuuDO8NIppTifc3ZuYC4lULIKgArP5xLy2RzjtOYL7v3QtUVj uZE0v3Ho/KXW3oOBb5hmpvzQdx3fr0YvPYvXeiMBCEvSxs7RDh6H6/M6UQmBG8UwK03T pFmlKCZHZH8R45S61YABTNp/YILE5ElCWRWscPrKqYBJwfLhe3OMwSWmAFroyeL/nx8x JC0RAUAIkKLCUMe7w6r60qk3BRQHpJuQ+pSl/wtSZAAobQtcNjb/XWl+7MxgPcOEkD8Z MwYQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:user-agent:in-reply-to :content-disposition:mime-version:references:message-id:subject:cc :to:from:date; bh=2FTJTXyXM76RY3y4AH1mLpx0VC0KLHMEGMtmzEJOpMQ=; b=iCi8WrrltmOQp6KkhLvzKxNIs6rLWWOWKoNC7k0nYi/Cxtp4EopBDm3u6wGEcRX2c7 qMdv7h1mGqo2wqUc+dj08Fh+ZhmZL8DBHB45nSDhOUdiRIvM+TmKdKIbqrE7k0sU4r9y S1W/Ybj1/zOsAjY2jyDihohAFhwMIWUMkZO0+OKQMvlAIUS9bAOzODx1vKFxTgp1rfgo PQ50i74hmUPsuNZZ3U7fH5R0pFA8qoO8gjpHvEwGeOiK42a6LwWU8GjwHV6KY/giK7TK mKOXyYQ8aVFAnIZdByQo4D12RD9TX9UjzKPSu35QdXFj53KrRNbEV2xn2ksPnmp3gNEE RNfQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: best guess record for domain of linux-crypto-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-crypto-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=intel.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id z16si12882046edb.23.2019.11.17.23.13.05; Sun, 17 Nov 2019 23:13:40 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-crypto-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-crypto-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-crypto-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=intel.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726677AbfKRHNB (ORCPT + 99 others); Mon, 18 Nov 2019 02:13:01 -0500 Received: from mga09.intel.com ([134.134.136.24]:45532 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726643AbfKRHNB (ORCPT ); Mon, 18 Nov 2019 02:13:01 -0500 X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga102.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 17 Nov 2019 23:12:56 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.68,319,1569308400"; d="gz'50?scan'50,208,50";a="203985769" Received: from lkp-server01.sh.intel.com (HELO lkp-server01) ([10.239.97.150]) by fmsmga008.fm.intel.com with ESMTP; 17 Nov 2019 23:12:53 -0800 Received: from kbuild by lkp-server01 with local (Exim 4.89) (envelope-from ) id 1iWbDQ-000FHv-LP; Mon, 18 Nov 2019 15:12:52 +0800 Date: Mon, 18 Nov 2019 15:12:14 +0800 From: kbuild test robot To: Corentin Labbe Cc: kbuild-all@lists.01.org, davem@davemloft.net, herbert@gondor.apana.org.au, mripard@kernel.org, wens@csie.org, linux-arm-kernel@lists.infradead.org, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-sunxi@googlegroups.com, Corentin Labbe Subject: Re: [PATCH 2/2] crypto: sun4i-ss: remove dependency on not 64BIT Message-ID: <201911181510.4s0BW0Qc%lkp@intel.com> References: <20191114104907.10645-2-clabbe.montjoie@gmail.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="aajvmco7yeehmz6r" Content-Disposition: inline In-Reply-To: <20191114104907.10645-2-clabbe.montjoie@gmail.com> X-Patchwork-Hint: ignore User-Agent: NeoMutt/20170113 (1.7.2) Sender: linux-crypto-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-crypto@vger.kernel.org --aajvmco7yeehmz6r Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Corentin, I love your patch! Perhaps something to improve: [auto build test WARNING on cryptodev/master] [also build test WARNING on next-20191115] [cannot apply to v5.4-rc8] [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/Corentin-Labbe/crypto-sun4i-ss-Fix-64-bit-size_t-warnings-on-sun4i-ss-hash-c/20191114-211327 base: https://git.kernel.org/pub/scm/linux/kernel/git/herbert/cryptodev-2.6.git master config: arm64-allyesconfig (attached as .config) compiler: aarch64-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=arm64 If you fix the issue, kindly add following tag Reported-by: kbuild test robot All warnings (new ones prefixed by >>): In file included from include/linux/clk.h:13:0, from drivers/crypto/allwinner/sun4i-ss/sun4i-ss.h:14, from drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:13: drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c: In function 'sun4i_ss_opti_poll': include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ >> drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:75:10: note: in expansion of macro 'min3' todo = min3(rx_cnt, ileft, (mi.length - oi) / 4); ^~~~ include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:90:10: note: in expansion of macro 'min3' todo = min3(tx_cnt, oleft, (mo.length - oo) / 4); ^~~~ drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c: In function 'sun4i_ss_cipher_poll': include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:242:11: note: in expansion of macro 'min3' todo = min3(rx_cnt, ileft / 4, (mi.length - oi) / 4); ^~~~ include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:256:12: note: in expansion of macro 'min3' todo = min3(rx_cnt * 4 - ob, ileft, ^~~~ In file included from include/linux/printk.h:332:0, from include/linux/kernel.h:15, from include/linux/clk.h:13, from drivers/crypto/allwinner/sun4i-ss/sun4i-ss.h:14, from drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:13: >> drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:277:20: warning: format '%u' expects argument of type 'unsigned int', but argument 6 has type 'size_t {aka long unsigned int}' [-Wformat=] dev_dbg(ss->dev, "%x %u/%u %u/%u cnt=%u %u/%u %u/%u cnt=%u %u\n", ^ include/linux/dynamic_debug.h:125:15: note: in definition of macro '__dynamic_func_call' func(&id, ##__VA_ARGS__); \ ^~~~~~~~~~~ include/linux/dynamic_debug.h:157:2: note: in expansion of macro '_dynamic_func_call' _dynamic_func_call(fmt,__dynamic_dev_dbg, \ ^~~~~~~~~~~~~~~~~~ include/linux/device.h:1751:2: note: in expansion of macro 'dynamic_dev_dbg' dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__) ^~~~~~~~~~~~~~~ include/linux/device.h:1751:23: note: in expansion of macro 'dev_fmt' dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__) ^~~~~~~ >> drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:277:3: note: in expansion of macro 'dev_dbg' dev_dbg(ss->dev, "%x %u/%u %u/%u cnt=%u %u/%u %u/%u cnt=%u %u\n", ^~~~~~~ drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:277:20: warning: format '%u' expects argument of type 'unsigned int', but argument 11 has type 'size_t {aka long unsigned int}' [-Wformat=] dev_dbg(ss->dev, "%x %u/%u %u/%u cnt=%u %u/%u %u/%u cnt=%u %u\n", ^ include/linux/dynamic_debug.h:125:15: note: in definition of macro '__dynamic_func_call' func(&id, ##__VA_ARGS__); \ ^~~~~~~~~~~ include/linux/dynamic_debug.h:157:2: note: in expansion of macro '_dynamic_func_call' _dynamic_func_call(fmt,__dynamic_dev_dbg, \ ^~~~~~~~~~~~~~~~~~ include/linux/device.h:1751:2: note: in expansion of macro 'dynamic_dev_dbg' dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__) ^~~~~~~~~~~~~~~ include/linux/device.h:1751:23: note: in expansion of macro 'dev_fmt' dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__) ^~~~~~~ >> drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:277:3: note: in expansion of macro 'dev_dbg' dev_dbg(ss->dev, "%x %u/%u %u/%u cnt=%u %u/%u %u/%u cnt=%u %u\n", ^~~~~~~ In file included from include/linux/clk.h:13:0, from drivers/crypto/allwinner/sun4i-ss/sun4i-ss.h:14, from drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:13: include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:285:10: note: in expansion of macro 'min3' todo = min3(tx_cnt, oleft / 4, (mo.length - oo) / 4); ^~~~ include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> drivers/crypto/allwinner/sun4i-ss/sun4i-ss-cipher.c:311:12: note: in expansion of macro 'min' todo = min(mo.length - oo, obl - obo); ^~~ -- In file included from include/linux/clk.h:13:0, from drivers/crypto//allwinner/sun4i-ss/sun4i-ss.h:14, from drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:13: drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c: In function 'sun4i_ss_opti_poll': include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:75:10: note: in expansion of macro 'min3' todo = min3(rx_cnt, ileft, (mi.length - oi) / 4); ^~~~ include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:90:10: note: in expansion of macro 'min3' todo = min3(tx_cnt, oleft, (mo.length - oo) / 4); ^~~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c: In function 'sun4i_ss_cipher_poll': include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:242:11: note: in expansion of macro 'min3' todo = min3(rx_cnt, ileft / 4, (mi.length - oi) / 4); ^~~~ include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:256:12: note: in expansion of macro 'min3' todo = min3(rx_cnt * 4 - ob, ileft, ^~~~ In file included from include/linux/printk.h:332:0, from include/linux/kernel.h:15, from include/linux/clk.h:13, from drivers/crypto//allwinner/sun4i-ss/sun4i-ss.h:14, from drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:13: drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:277:20: warning: format '%u' expects argument of type 'unsigned int', but argument 6 has type 'size_t {aka long unsigned int}' [-Wformat=] dev_dbg(ss->dev, "%x %u/%u %u/%u cnt=%u %u/%u %u/%u cnt=%u %u\n", ^ include/linux/dynamic_debug.h:125:15: note: in definition of macro '__dynamic_func_call' func(&id, ##__VA_ARGS__); \ ^~~~~~~~~~~ include/linux/dynamic_debug.h:157:2: note: in expansion of macro '_dynamic_func_call' _dynamic_func_call(fmt,__dynamic_dev_dbg, \ ^~~~~~~~~~~~~~~~~~ include/linux/device.h:1751:2: note: in expansion of macro 'dynamic_dev_dbg' dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__) ^~~~~~~~~~~~~~~ include/linux/device.h:1751:23: note: in expansion of macro 'dev_fmt' dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__) ^~~~~~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:277:3: note: in expansion of macro 'dev_dbg' dev_dbg(ss->dev, "%x %u/%u %u/%u cnt=%u %u/%u %u/%u cnt=%u %u\n", ^~~~~~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:277:20: warning: format '%u' expects argument of type 'unsigned int', but argument 11 has type 'size_t {aka long unsigned int}' [-Wformat=] dev_dbg(ss->dev, "%x %u/%u %u/%u cnt=%u %u/%u %u/%u cnt=%u %u\n", ^ include/linux/dynamic_debug.h:125:15: note: in definition of macro '__dynamic_func_call' func(&id, ##__VA_ARGS__); \ ^~~~~~~~~~~ include/linux/dynamic_debug.h:157:2: note: in expansion of macro '_dynamic_func_call' _dynamic_func_call(fmt,__dynamic_dev_dbg, \ ^~~~~~~~~~~~~~~~~~ include/linux/device.h:1751:2: note: in expansion of macro 'dynamic_dev_dbg' dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__) ^~~~~~~~~~~~~~~ include/linux/device.h:1751:23: note: in expansion of macro 'dev_fmt' dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__) ^~~~~~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:277:3: note: in expansion of macro 'dev_dbg' dev_dbg(ss->dev, "%x %u/%u %u/%u cnt=%u %u/%u %u/%u cnt=%u %u\n", ^~~~~~~ In file included from include/linux/clk.h:13:0, from drivers/crypto//allwinner/sun4i-ss/sun4i-ss.h:14, from drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:13: include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ >> include/linux/kernel.h:890:23: note: in expansion of macro 'min' #define min3(x, y, z) min((typeof(x))min(x, y), z) ^~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:285:10: note: in expansion of macro 'min3' todo = min3(tx_cnt, oleft / 4, (mo.length - oo) / 4); ^~~~ include/linux/kernel.h:842:29: warning: comparison of distinct pointer types lacks a cast (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) ^ include/linux/kernel.h:856:4: note: in expansion of macro '__typecheck' (__typecheck(x, y) && __no_side_effects(x, y)) ^~~~~~~~~~~ include/linux/kernel.h:866:24: note: in expansion of macro '__safe_cmp' __builtin_choose_expr(__safe_cmp(x, y), \ ^~~~~~~~~~ include/linux/kernel.h:875:19: note: in expansion of macro '__careful_cmp' #define min(x, y) __careful_cmp(x, y, <) ^~~~~~~~~~~~~ drivers/crypto//allwinner/sun4i-ss/sun4i-ss-cipher.c:311:12: note: in expansion of macro 'min' todo = min(mo.length - oo, obl - obo); ^~~ vim +/min +890 include/linux/kernel.h 526211bc58c4b3 Ingo Molnar 2009-03-05 828 ^1da177e4c3f41 Linus Torvalds 2005-04-16 829 /* 3c8ba0d61d04ce Kees Cook 2018-03-30 830 * min()/max()/clamp() macros must accomplish three things: 3c8ba0d61d04ce Kees Cook 2018-03-30 831 * 3c8ba0d61d04ce Kees Cook 2018-03-30 832 * - avoid multiple evaluations of the arguments (so side-effects like 3c8ba0d61d04ce Kees Cook 2018-03-30 833 * "x++" happen only once) when non-constant. 3c8ba0d61d04ce Kees Cook 2018-03-30 834 * - perform strict type-checking (to generate warnings instead of 3c8ba0d61d04ce Kees Cook 2018-03-30 835 * nasty runtime surprises). See the "unnecessary" pointer comparison 3c8ba0d61d04ce Kees Cook 2018-03-30 836 * in __typecheck(). 3c8ba0d61d04ce Kees Cook 2018-03-30 837 * - retain result as a constant expressions when called with only 3c8ba0d61d04ce Kees Cook 2018-03-30 838 * constant expressions (to avoid tripping VLA warnings in stack 3c8ba0d61d04ce Kees Cook 2018-03-30 839 * allocation usage). 3c8ba0d61d04ce Kees Cook 2018-03-30 840 */ 3c8ba0d61d04ce Kees Cook 2018-03-30 841 #define __typecheck(x, y) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 842 (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) 3c8ba0d61d04ce Kees Cook 2018-03-30 843 3c8ba0d61d04ce Kees Cook 2018-03-30 844 /* 3c8ba0d61d04ce Kees Cook 2018-03-30 845 * This returns a constant expression while determining if an argument is 3c8ba0d61d04ce Kees Cook 2018-03-30 846 * a constant expression, most importantly without evaluating the argument. 3c8ba0d61d04ce Kees Cook 2018-03-30 847 * Glory to Martin Uecker ^1da177e4c3f41 Linus Torvalds 2005-04-16 848 */ 3c8ba0d61d04ce Kees Cook 2018-03-30 849 #define __is_constexpr(x) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 850 (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) 3c8ba0d61d04ce Kees Cook 2018-03-30 851 3c8ba0d61d04ce Kees Cook 2018-03-30 852 #define __no_side_effects(x, y) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 853 (__is_constexpr(x) && __is_constexpr(y)) 3c8ba0d61d04ce Kees Cook 2018-03-30 854 3c8ba0d61d04ce Kees Cook 2018-03-30 855 #define __safe_cmp(x, y) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 @856 (__typecheck(x, y) && __no_side_effects(x, y)) 3c8ba0d61d04ce Kees Cook 2018-03-30 857 3c8ba0d61d04ce Kees Cook 2018-03-30 858 #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) 3c8ba0d61d04ce Kees Cook 2018-03-30 859 e9092d0d979611 Linus Torvalds 2018-04-09 860 #define __cmp_once(x, y, unique_x, unique_y, op) ({ \ e9092d0d979611 Linus Torvalds 2018-04-09 861 typeof(x) unique_x = (x); \ e9092d0d979611 Linus Torvalds 2018-04-09 862 typeof(y) unique_y = (y); \ e9092d0d979611 Linus Torvalds 2018-04-09 863 __cmp(unique_x, unique_y, op); }) 3c8ba0d61d04ce Kees Cook 2018-03-30 864 3c8ba0d61d04ce Kees Cook 2018-03-30 865 #define __careful_cmp(x, y, op) \ 3c8ba0d61d04ce Kees Cook 2018-03-30 866 __builtin_choose_expr(__safe_cmp(x, y), \ e9092d0d979611 Linus Torvalds 2018-04-09 867 __cmp(x, y, op), \ e9092d0d979611 Linus Torvalds 2018-04-09 868 __cmp_once(x, y, __UNIQUE_ID(__x), __UNIQUE_ID(__y), op)) e8c97af0c1f23d Randy Dunlap 2017-10-13 869 e8c97af0c1f23d Randy Dunlap 2017-10-13 870 /** e8c97af0c1f23d Randy Dunlap 2017-10-13 871 * min - return minimum of two values of the same or compatible types e8c97af0c1f23d Randy Dunlap 2017-10-13 872 * @x: first value e8c97af0c1f23d Randy Dunlap 2017-10-13 873 * @y: second value e8c97af0c1f23d Randy Dunlap 2017-10-13 874 */ 3c8ba0d61d04ce Kees Cook 2018-03-30 875 #define min(x, y) __careful_cmp(x, y, <) e8c97af0c1f23d Randy Dunlap 2017-10-13 876 e8c97af0c1f23d Randy Dunlap 2017-10-13 877 /** e8c97af0c1f23d Randy Dunlap 2017-10-13 878 * max - return maximum of two values of the same or compatible types e8c97af0c1f23d Randy Dunlap 2017-10-13 879 * @x: first value e8c97af0c1f23d Randy Dunlap 2017-10-13 880 * @y: second value e8c97af0c1f23d Randy Dunlap 2017-10-13 881 */ 3c8ba0d61d04ce Kees Cook 2018-03-30 882 #define max(x, y) __careful_cmp(x, y, >) bdf4bbaaee3d4b Harvey Harrison 2008-04-30 883 e8c97af0c1f23d Randy Dunlap 2017-10-13 884 /** e8c97af0c1f23d Randy Dunlap 2017-10-13 885 * min3 - return minimum of three values e8c97af0c1f23d Randy Dunlap 2017-10-13 886 * @x: first value e8c97af0c1f23d Randy Dunlap 2017-10-13 887 * @y: second value e8c97af0c1f23d Randy Dunlap 2017-10-13 888 * @z: third value e8c97af0c1f23d Randy Dunlap 2017-10-13 889 */ 2e1d06e1c05af9 Michal Nazarewicz 2014-10-09 @890 #define min3(x, y, z) min((typeof(x))min(x, y), z) e8c97af0c1f23d Randy Dunlap 2017-10-13 891 :::::: The code at line 890 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/hyperkitty/list/kbuild-all@lists.01.org Intel Corporation --aajvmco7yeehmz6r Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICM1A0l0AAy5jb25maWcAnDzZciM3ku/+Ckb7ZSYm7OElSt4NPYAoFAmzLhVQPPRSQavZ bYXVUg8l2dN/v5moK4FC0R3b4aMrMwEkgEQiL/DHH34csfe3ly/Ht8eH49PTt9Hn0/PpfHw7 fRx9enw6/e8oSEdJqkcikPpnII4en9//++/j+ctiPrr6ef7z+Kfzw2S0OZ2fT08j/vL86fHz OzR/fHn+4ccf4J8fAfjlK/R0/p/R8Xh++H0x/+kJ+/jp88PD6B8rzv85usZ+gJanSShXJeel VCVgbr81IPgotyJXMk1ur8fz8biljViyalFj0sWaqZKpuFylOu06qhE7lidlzA5LURaJTKSW LJL3IiCEaaJ0XnCd5qqDyvyu3KX5poMsCxkFWsaiFHvNlpEoVZrrDq/XuWBBKZMwhf+Umils bBZmZVb6afR6env/2k0f2SlFsi1ZviojGUt9O5t2bMWZhEG0UGSQNQwhcge4EXkiIj8uSjmL mlX78MGaTKlYpAkwECErIl2uU6UTFovbD/94fnk+/bMlUDuWdV2rg9rKjPcA+H+uow6epUru y/iuEIXwQ3tNeJ4qVcYiTvNDybRmfN0hCyUiuey+WQEiS9aIbQUsKV9XCOyaRZFD3kHNDsF2 j17ff3v99vp2+tLt0EokIpfcSEOWp0vCPkWpdbobxpSR2IrIjxdhKLiWyHAYgpyqjZ8ulquc adxDMs08AJSCXSlzoUQS+JvytcxsuQ7SmMnEhikZ+4jKtRQ5ruXBxoZMaZHKDg3sJEEk6BFq mIiVxDaDCC8/BpfGcUEnjCM0jFk9GpbSnIugPoYyWRG5zFiuhJ8HM75YFqsQOf9xdHr+OHr5 5MiDd0fgpMhm1kS4UO44nLqNSgtgqAyYZv1hjR7Z9kSzQZsOQGoSrZyuUadpyTflMk9ZwBk9 657WFpmRdP345XR+9Qm76TZNBMgs6TRJy/U9aqPYCB9o+Xo37ssMRksDyUePr6PnlzdUb3Yr CWtD21TQsIiioSZkt+VqjXJtliq3Nqc3hVal5ELEmYauEmvcBr5NoyLRLD/Q4V0qD2tNe55C 82YheVb8Wx9f/xi9ATujI7D2+nZ8ex0dHx5e3p/fHp8/O0sLDUrGTR+VeLYjb2WuHTRupocT lDwjO1ZHVPEpvoZTwLYrW96XKkANxgWoVWirhzHldkYuNdBISjMqhgiCIxOxg9ORQew9MJl6 2c2UtD7a+yeQCu/XgO75d6x2e3fAQkqVRo2+NLuV82KkPDIPO1sCrmMEPuCCB9Ems1AWhWnj gHCZ+v3AykVRd3YIJhGwSUqs+DKS9AgjLmRJWujbxbwPhKuEhbeThY1R2j08ZoiUL3Et6Cra q2AbA0uZTMllLjfVX/oQIy0UXBkeRESiFDsN4faTob6dXFM47k7M9hQ/7c6ZTPQGzJJQuH3M XCVXyblRdc0eq4ffTx/fwQAdfTod397Pp9duowuwH+Osscps4LIAdQm6sjreV91yeTq0lLEq sgxsQFUmRczKJQMTlVsiblPB5CbTG6JaB1rZ8PZYiKQ5FY2gr/K0yMi6Z2wlqlnQKwmsKL5y Ph1TroP1R6lwG/gf0RnRph7d5abc5VKLJeObHsbsWAcNmcxLL4aHcG/BxbqTgSZmH+hILznZ 2tLPUyYD1QPmQcx6wBDO9j1dvBq+LlZCR8TmBDFWgqpFPBQ4UI3p9RCIreSiBwZqW2M2LIs8 7AGXWR9mjBeiqlK+aVGW6YEWPVhCoOfJ0qHsUq8HrHf6DTPJLQBOkH4nQlvfsDN8k6Ug6Xh3 g0tFZlzfTIVOnV0CMwh2PBBwzXKm6da6mHI7JfKAd5Atk7DIxqvKSR/mm8XQT2WREYenQxnj kXQdlKt7ajYDYAmAqQWJ7qkEAWB/7+BT53tu+adpBlc5OKM4utnwNI/hzFumi0um4C8eu8D1 n4wpUMhgsrAWE2jgcuMiw6sRLjJGJ21Jl3sFOn0Z6xelg3QPJwQdmLJn1Va76AMjPz14WBnV rqfY2oHWZeF+l0lMrArraIgoBOVIJXLJwC1Ac5QMXmixdz5B6kkvWWpNQq4SFoVE3gyfFGAs cQpQa0uZMknEBGylIrfvkGArlWiWiSwAdLJkeS7pJmyQ5BCrPqS01riFmiXAk4ROqCUL/Y1B 4K9SQ087dlAltWlQFMwtRefZOiwdp9Bpwp1dAN+MGKpGnzkwaC6CgCoGI994ZErXSzJAYKfc xsA8NVQyPhnPG1uhjmNlp/Onl/OX4/PDaST+PD2DRcng7udoU4KP0dkP3rEqXj0jthbEdw7T dLiNqzGaS5yMpaJi2VP2CKvvbnPG6JZgAIlpcAA3VJ+oiC19+gN6sslSPxnDAXMwM2qrhDID OLw/0aItczjDaTyExdgF2HHWmSjCELx7Y8KYZWRwezhTRdsRfHmM4VlqRIvYXHYYHpSh5E6k BK7mUEbWoTKqz9xTlmdpB+o6OY4XRHMv5ksabrJiFIa0moRr3FYo+NA1am6dkzgG4ytP0A6H SzmWye3k5hIB299OB3podr7taPIddNBf51eA48I3Zo0a65VoqCgSKxaVZvXgRG9ZVIjb8X8/ no4fx+RPZ/TzDdzg/Y6q/sFLDSO2Un18Y+lbIk+ArdpqWPHEntY7IVdrX4xEFbEHyiK5zMHS qBzcjuA+TQAWs9n01lZvlbncRCrXqc4i64TGxIio47RxGggwnKiEhnC/CZZHB/gurcshW1Wx ZhNDVLcza/DWsyhMcNKNFRmTdIPKtoRbjAaMmWIJSCEL0l2ZhiHaq7CBn/BPt4eVosyejm+o u+BMPJ0e6nA/HYVxPG3u2GwlI3qR1vwme+kSRplMhANc8nh6M7vqQ8FCtZzPCi7yiMYPK6DU dlSxguY8VnrpbuL+kKTuDDYzBwACATLGWeZyG60mGwe0lsqdaCwCCZLlUoJRnrpcxlvQ8y5s 7077jlMFa0C5YFF/iBykWzF3frCOGzs2XO2RYFpH7hSVxvDzfjJ24YfkDhyYXgRUi1XOXNos d40DvS6SoN+4grpHrUhktpY96i2YquBruNPb45l2YPeuQN4D++aEtjeAR9ypvRB2gQUDBqU+ Op3Px7fj6K+X8x/HM9zoH19Hfz4eR2+/n0bHJ7jen49vj3+eXkefzscvJ6SiBwjvBMwzMXCJ UCVHAk4mZ+AquZeKyGELiri8mS5mk1+GsdcXsfPxYhg7+WV+PR3Ezqbj66th7Hw6HQ9i51fX F7iaz+bD2Ml4Or+e3Ayi55Ob8Xxw5MlkcXU1HZzUZHqzuBlfD3e+mE2nZNKcbSXAG/x0Oru+ gJ1N5vNL2KsL2Ov51WIQOxtPJmRc1ARlyKINOIjdso1n7rSIoOUig4Ne6mgp/7afXxyKuyAE ORq3JOPxgjCjUg73Adw3nXLAALqkhjOqx0jiZdcOs5gsxuOb8fQyNwJM+Al1z8AfUUXHCXA7 ntDz/P87oPayzTfGolPUQK4wk0WN8iYUKprF3ENjUWxZZYPNfumP0ODmN3/X/Hb2i2uFNk37 9mnVYt5amGhZL9HTSuCSItdRFbOJuQtRMU0R5SbodTu9ag3I2hCq488NXUHjJQmYQao2hVsj Gd0o8KeQHRMFRaJSuo4f2CtViKxKmsCtR7rFyHqDMo4jWFc5+BwcbhVyM67TSGBI1ph2t3Zi C6TIs9qAmF6NHdKZTer04u8GFmpsL+c6xwxRz1qqrbvazQQZcjza+lrF7CYYjbUtOojueWz1 fR8JrhsDFm1TN4xU2ZJhgpa+tRU7v1cMDlnHex04Dd3recfAD0JkmcUBmqK5yzgGDsxFWIJx J0zgy297qyyS2nST6Tod0HAiOPo4xJpmOcNkWx8ynFXbiL3gzieIFF3oCqZMsqTKRLx//fpy fhuBJTHKhKmvGb0+fn42xsPoz9P58dPjg6mdGX18fD3+9nT6SKpicqbWZVBQxvciwcT32IIQ PYjhS5NWQWlOc7SpOq+vSNDjq70PUPoiGtMtRlccDGOWGJcBrFRued41gYimYGo5VTKVOlFq ScQiT40rjmG14dRF3XBXar3Mx7ALiYvTbLXCcHEQ5CWjl1TltZLFN0HqtYgy4bC2vfEHlXcZ KIYicqIEPJtclU2YyoMHpQPa0cI0JuCfNz9PRljy9PgGNuM7RhD6GahqWnBoWBgsY3e6nhWI QBcyncaS91Z8uxbOJXeJBcLm9DvZLFja49AOWhoYSCpWQ/VY50nW529wbMLf7Dv5y3SOmYR1 f5TBHhzR2/YMbNB9BUagIt1b70yJIkjt2HKFqXVzLtNc6oOp4LG0Ry5MKMtWzFVwDEP6GH71 wWtecrHCQH0donajiqG1gMsXuGdevqJSIcvF4wDVJ0l61JA25dH2anVAlLmp6XJPHVXAqMZN yItWKVXBg5e/TufRl+Pz8fPpy+nZw58qVGaVLtWAfiauQcACZyaMTM3JJSg3DNtgwBqTj6qP tEOCMbi0QRVM1HZpHKIiITKbGCF2NAegmMvq0+7YRpgCID+0rvSbdBEyC7uiEevY6sKJ/iID wRYTRoEHhWWA/dVtp+I0CAwPmq+DdABqLkisS5hMKeM82li9N5G0qkqLLMHurszSHarWMJRc YpC7Z5D023u2wqVIaU4UA8Rk0ZB01bNq6ghNKxaYYFKybzpRkqrGoWehVSJJ2neBhCHRb4qH aoq4pWjLaAEnPz6dyCHGihYrJdZAqkRchmVxudxaF2BLskq3ZQT3qJXWpshYJMUASgtyDwS6 QmBBkPGG2hBIw/IoOIMndbbVNfZoc4/ATHHpx/AoU9eTyZ5gLXeuPxgpEqpWrl3H8Hz6z/vp +eHb6PXh+GTVZOE8Qcnc2TNHiJk503DF2Il8inaLelokLo4H3FhC2HYo1eulxTOjwAz3ehne JmgPmUT/9zdJk0AAP8H3twAcDLM18ffvb2W8nUJLX/2ftbz2EnkpmoUZwLerMIBvpjy4v938 Bkjaydx2FYGjT67AjT66RwLIqoWx5aSGgf3BdCC29pmAa20nkwQTqEVyNZZtg2TrmmX4LwtY Obve7xsyL8HNxo9WPJN+TB09L9lW+QlkvF/cDaK8M0dcExr3tzRxoAvztfDrnY0ECzUDLZ4f huakeDyAMTHs6fgCcjKdX8LeLPrYO7AT6QpZusujrSi6d2EYqQsfz1/+Op4HdK+ZXpanOuVp 5Jl5dSe7FditGAy1zC62xJgNJuRC6/iFMo934OdjrCGm1Wd0jxoi0mxX8rBOcPuhrZHbYnH0 qEtalHiUreorlyBX5AY0AgWr04eUNA/cAoN0l0QpC6rMXs+q0bLEu66/lLoAZ1NBq32Z7zQZ rg67QO8x59xeXHNvhkTKlzye41FPtjmL+2AF49JMZ5qu4ArvL3ONwGzhMk116bgsNRqLDUAz ph5UCMODURmGGHure7nQfphmm9HimVC2mVGyfaBMApXZAEXLb2tAmVmVjAosORU3+lqfPp+P o0/N+akUNakNxkNcyi3ZgAq0zOyckb8fM8T9t+f/jOJMvfAL57TKQnn2xEG0Rns78sXuG6Ie xhKzzTbGHLydCaSY0I2+1vAyB2+gX3++aWpYaDsExjGtc2ppY5oobaF40WJ6f18pEqxYs3vb ht7eqvxhtCzDqFBrp+ZpS5wHmesDlhibN1t4NAUtwrTmuTxkjKYXW+TWcFkkVdnnmiUrqmHa liWYGeAdE+sbA44FvkNzvFLo1GYXDzy+xupDM1p1YjhNYE4Yye0F6bbYA1ZquiDF6dpXsK2y Iqhbe/SKpnqcVaUKSiwG4aRSog4AgTK3XuOZb4zzTq8WbkFNh7yaTIeRk6Zv4e33IrbteAA/ Gxo2nl1oF8+Hkas1RnEH0TznejIOZDhMwoQa4KrFXGwGyJLTW8xHsKT+e48Aq1S8JCDt8A8Y R3YdS41N1lkaHSaz8ZUf3w2wbN3IpvSKRO9OP308fQUl5g0cVVFyu5KwisM7MLc05tcCVGrE ljQigE4baIWNwNSFiEL7DWWvusZogC6OUSRwllcJRqs5tyoRNrnQ3sY9riroEHlYJKbKBhOd aQ5n/VfB3deAQGbFJ7vcjSm0WqfpxkEGMTP1aHJVpIWneErBQhmHv3pT1ycwSKyHrTJyVAnU CRxw4rQMD03pdZ9gI0TmVmy3SOi1TkwNIGuVZ1mTZN7Vi9zqdW+5W0st7Nc2FamK0XCr38i6 K5+LFcgqhh2xJK7e4JJl7kLbBav2puHz3sGGVgDNQNY7cLQEq8roHZxJuCFPPrhJhFR82tmj bkl8wu/DekqCq2mCSVUVpGF8trcrlQxWD3h4nO352jUPmpNSbwqGjd0FqdpVL5cHcEFa9MN1 JqVY1zRiyLp69dm8ffZMt04PYjLPejAzBCctcZEj2CMHaeC1NUFzaPVjdBvdPFPsdJC3rdMI Fi7tGV14irHiAk/6pm+TDbwvdKj+/m1ho00STCqLOoHr2cJKGjC5u+0fTThrTWZacKzWJQa6 yXooUwWA1foohJ6Tb1BNqsQ3tFUq63Rg47oaW09rUh871AklccpsjTg2wS+dZuglVg0jdsBA eicdEVaXYtoCrHz6UinFN/pyVYeZSTlPPWyNZ85dYAqUzVb2WsymfVQ3c9ytSt58+laDytdN Gjnf7amIDqLc5k1iy9Pch8pFaGTReaVB6hJARmbTJs3mKURFWYI7JBc4NzxGHR4TLrTe3vfW GjrOWxOFp9uffju+nj6O/qgycF/PL58e7bAyEtUr4enOYKt6dGF7JwZjYp66nJfX1Mu7NG7T HKtt8Lk+2Oec3374/K9/fbAWC39Xo6KhF70FrOfIR1+f3j8/UlurowPZ1bhe8G+eZgdfV+Zo VurdngTp2K23/xujr5UGEBJ8kEPtI/OAReHLi+5HQWpJgqNRr2hPxbiAuoICozg9VJF4wVUL D7JvSfRNjDZM3rCa8xqLUuGJjndT6jFST5OaVwRjCRmBo0PlY6RCTadzb1TfobpafAfV7OZ7 +gIP7eK08fisbz+8/n6cfHCwqNvsCmAH0Tzmc4du8fv74bGx5mpXxlIpvDbbV5SljE2FE3ET EtA1oJAP8TKNesyo6t14BGY4tZSXdsUSPmKEa9jUeTlqGlHosYNKuiss/6R5+bhUKy/Q+rGU 7pkkBrOk9rygxBqioA8GczrV2n5H08fBDHc2vik4MPZYbuN2S2ce9dNVmRpFww8DWJ66CwA9 lfGdyxkWZ9CwMYX65okbmGasTelkx/Pbo6nT0t++0jKUtnKgzcGT4w4eaEJqC4YQJS8wNDSM F0Kl+2G0XRjkIFkQXsCa4L2mdW0uRS4Vl3RwufdNKVWhd6YxmCVehGa59CFixr1gFaTKh8Cf rQik2jjOTAzO5L5UxdLTBH8TAgPu+5uFr8cCWlZh1n63URD7miDYfZO38k4PjMDcv4Kq8MrK BrN0PgRGxH3dHNR2cePDkPPXoroyBUfALb3Uq/rBIxLflRmXPRj6GDQki+CsDbXLtPsxBXKK oJ1MqxLYAFx1O4lDkJvDkmqOBrwM6YEP78pGPTi/EIAo57l890s/Fmft8W5/SUaDi2K/O2b2 u3qmElKRbiw9mVQlqxn+Dlh+sFX8EEW5XF8g+ps+vq8D+ydhBknsrHqPDE2ei8xUBJfZqWku M9QR9X5MgNKaKM8wTy16kKOOYpAfi2R4gQzZpQUiBP/H2b82x40j7aLoX1HMh31m4qxZUyTr uk70BxTJqqLFmwhWFeUvDI2t7naMbXnL6jUz+9cfJMALMpEo9V7vG9NWPQ+I+yUBJDJvZ+e9 CiKBblaQtslxo4Zm3psnK4g3SziMv5JMuFu1ZId4J0vv1RMN5VQUmAV8p3NP2uxGHbdvCkvE 0TsS87FaNtUm356pmqtMCx+ps+Thpr2rto+X6GBEqdDP0I+bK/+pg8+7dfP2X9WeqGs7X7Na pp7X0/88f/rjDRTYjZK7fuX+Zs3w+6w8FKBybmvpjYcmLqV+4ON7/XoVTjNnXfL80DsWh4a4 ZNxk9k3hACvhPcZRDuej0yrgK4cuZPH87eX1v5biBaPGeusVxfwEQ4l7Z8ExM6Tfr0xaffqR zEyaAzSTSK2N/rVcMmmn9hr23mGmLkb5wnkr4oRwEzUigX6R4/LaCtXRuQOA4/3pW2vMmCLY Vrow4zykxviQXS899pWqxCLF8FSkNcINvFlakhj2sPVCcqYBTKclB20cxlhqjPUdS0/NUZwe pXne0DImBSbJw5IIpdVNxhLqxlRCr47pl+Vit0b1P81cQ/EOIsvPjVtxDn661lUG6hLmrmkm bh//cuxgL+QXa//NBiuMpRNmJ06D62sD8khWv5wl2KFRNY8tXcXI6JOSsIn4PkH27glAeGUm f5lMmX3E0X6sK1uz5+P+bImfH6NDldu/pWOaZHjlrxqzRvvrMShRKx0v4LRmjJJ39ekm6hxp 0+BbFm3syBKhk9HYhntnMK0CtTaEgM/wtZrPoGRgFcC82SOmAo9gs0rt4k+FsC3patFFDc3H vj3V2qqR8zxsTF3fEQj0+ME/G89TqH24bhYbhamp4B50gOTwlnMOrermiA+QAEwJJu/3MLOm 5XiIpxeH8vkNnoyCpqezKqjJ4d7Oi/mt9pfCqm3YduJfWPdMI/iT1j5eUj8c42LdoSnwLzDz gE8qNSryY0UgbNVJQ4wyn8bVNhuufzP7mEYTZhJ0gsMtu2zRsYWJv8bP9KD279NHB2DiTWpt 8gyZYrNAUnEZ6hpZbRZabEVVodOzClBxQhtPuBTcqyGTpbSvj5HBqq0HM+Z0TEMIYVu1m7hL 2uwre02bmDgXUtovLxVTlzX93Sen2AVBxc5FG9GQ+s7qzEGOWuesOHeU6NtziS44pvBcFIyp WqitoXBEkX5iuMC3arjOCqmkl4ADrVfl8hHW8uo+c+aA+tJmGDonfEkP1dkB5lqRuL/14kSA FGkuDog7QDOTKzw0NKgHDc2YZljQHQN9G9ccDAVm4EZcORgg1T/gRtoaqxC1+vPIHIxO1N6+ 9Z3Q+MzjV5XEtaq4iE6t3eVnWHrwx719ozzhl/Ro20eZ8PLCgLAzwsLzROVcope0rBj4MbU7 xgRnuVqnlOjFUEnMlypOjlwd7xtb5BoFxj1rr3lkxyZwPoOKZm9xpgBQtTdD6Ep+J0RZ3Qww 9oSbgXQ13QyhKuwmr6ruJt+QfBJ6bIJf/vLpj39++fQXu2mKZIXu8NSss8a/hkUH9ncHjtEe BghhTETC0tondApZOxPQ2p2B1v4paO3OQZBkkdU045k9tsyn3plq7aIQBZqCNSKR1Dog/RpZ +AS0TNQmX+9O28c6JSSbFlqtNILm9RHhP76xEkEWz3u47aOwu7BN4DsRuuuYSSc9rvv8yuZQ c0ryjjkc2foE2RhfdygEbMWAJhQW3WHar9t6EEkOj+4nalurLy6VeFTgvYwKQTWqJohZLPZN lhxT9NXgZeT1GaTuX7+A7RbHE4kTMyfbD9SwKeCogygytUExmbgRgMpROGZiId3liU8MN0Be cTU40ZW02xHsm5al3tAhVNvdJnLWAKuI0GOzOQmIajR4zyTQk45hU263sVm4dpUeDqy7HXwk NTSCyPF5sp/VPdLD6/5Pom7Nkx21nsQ1z2B51yJk3Ho+URJWnrWpJxsCXiQKD3mgcU7MKQoj D5U1sYdhpHLEq56wzypsHxq3cumtzrr25lWK0ld6mfk+ap2yt8zgtWG+P8y0sRdya2gd87Pa neAISuH85toMYJpjwGhjAEYLDZhTXADBMkuTuhkCmxNqGmlEwk4kar+jel73iD6ja8wE4RfP M4w3zjPuTB+HFgw3IeVSwHC2Ve3kxvIkFjd0SGq+3oBlacwmIBhPjgC4YaB2MKIrkmRZkK+c XZ/Cqv0HJJIBRudvDVXI7LpO8UNKa8BgTsWOGswY07pPuAJtnZ4BYCLDB0GAmIMRUjJJitU6 XablO1Jyrtk+4MMP14THVe5d3HQTczTq9MCZ47p9N3VxLTR0+m7n592nl2///PL9+fPdtxe4 8f/JCQxdS9c2m4KueIM24wel+fb0+tvzmy+pVjRHOCTAPqy4INq2PjJby4biJDM31O1SWKE4 EdAN+E7WExmzYtIc4pS/w7+fCTjS1sbXbwdDdqjYALzINQe4kRU8kTDflmAk/526KA/vZqE8 eCVHK1BFRUEmEJynIm1CNpC79rD1cmshmsO16XsB6ETDhcHOC7ggf6rrqk15we8OUBi1wwY1 9ZoO7m9Pb59+vzGPtGDiOEkavCllAtEdGeWpuxUuSH6Wnu3VHEZtA9CtMRumLPePbeqrlTmU u21kQ5FVmQ91o6nmQLc69BCqPt/kiTTPBEgv71f1jQnNBEjj8jYvb38PK/779eaXYucgt9uH uXpxgzT4aTMb5nK7t+RhezuVPC2P9r0IF+Td+kCnHSz/Th8zpzDIDD0Tqjz49vVTECxSMTxW 92FC0Is1LsjpUXp273OY+/bduYeKrG6I26vEECYVuU84GUPE7809ZOfMBKDyKxOkRXeEnhD6 uPSdUA1/gDUHubl6DEGQFj8T4KydCsyWXm6db43RgAk8cpWpH8uCV4jZCu+AalP4dY/cgBKG HBPaJPH+YDj9uJ2JcMDxOMPcrfiA88cKbMmUekrULYOmvISK7Gact4hbnL+IiszwRfrAarco tEkvkvx0rgsAIxosBlTbn+FVYjhoYKsZ+u7t9en7T22Z9sfry9vLp5evd19fnj7f/fPp69P3 T6DD8NNYrrWcFOvozOFVS+6XJ+KceAhBVjqb8xLixOPD3DAX5+eouE2z2zQ0hqsL5bETyIXw VQsg1eXgxLR3PwTMSTJxSiYdpHDDpAmFygdUEfLkrwvV66bOsLW+KW58U5hvsjJJO9yDnn78 +DqaLv79+esP99tD6zRreYhpx+7rdDj6GuL+X3/iTP8AV2yN0BcZllUMhZtVwcXNToLBh2Mt gs/HMg4BJxouqk9dPJHjqwF8mEE/4WLX5/M0EsCcgJ5Mm/PFEjxcCpm5R4/OKS2A+CxZtZXC s5rRtygP4/bmxONIBLaJpqb3QDbbtjkl+ODT3hQfriHSPbQyNNqnoy+4TSwKQHfwJDN0ozwW rTzmvhiHfVvmi5SpyHFj6tZVI64UUvvgM37pZ3DVt/h2Fb4WUsRclPkJzY3BO4zu/73+c+N7 HsdrPKSmcbzmhhrF7XFMiGGkEXQYxzhyPGAxx0XjS3QctGjlXvsG1to3siwiPWe2WSDEwQTp oeAQw0Odcg8B+abGb1GAwpdJrhPZdOshZOPGyJwSDownDe/kYLPc7LDmh+uaGVtr3+BaM1OM nS4/x9ghyrrFI+zWAGLXx/W4tCZp/P357U8MPxWw1EeL/bERe7ByXzV2Jt6LyB2Wzu35oR2v 9YuUXpIMhHtXYlxBO1Ghq0xMjqoDhz7d0wE2cIqAG1CkjmFRrdOvEIna1mK2i7CPWEYUyGqL zdgrvIVnPnjN4uRwxGLwZswinKMBi5Mtn/wltx0V4GI0aZ0/smTiqzDIW89T7lJqZ88XITo5 t3Bypr7nFjh8NGhUHONZUdKMJgXcxXGW/PQNoyGiHgKFzOZsIiMP7PumPTRxj97yI8Z52erN 6lyQwZHA6enTv5ARkzFiPk7ylfURPr2BX32yP8LNaYxeKmliVMbTyrhaUwm0436xvZD6woHx ClZDz/sF2FriHJpCeDcHPnYwmmH3EJMiUo5FNnzUD7xvBoC0cJvVMf5lTCLjfbXGcUrCthqr fihREjn0GxBV+j6LC8LkSBMDkKKuBEb2TbjeLjlMNTcdQviMF365T2k0eokIkNHvUvsoGM1F RzRfFu7k6Qz/7Kh2QLKsKqyONrAwoQ2TvWvwSk8BEh+NsgC4q4HZP3jgKbCc7apgkQA3PoW5 FTlysEMc5ZXq7o+UN6+plynae564lx954iH2RKWqdhfZbuhsUn4QQbBY8aRa17McmUyFZiIV PGP98WJ3BIsoEGFEHPrbeeaR28c56oftPrAVtsE+sH0i6jpPMZzVCT4RUz/7tIztfWNn+xXM RW3N6/WpQtlcq40IchA0AO7wGonyFLOgVtfnGRAc8dWgzZ6qmifwvsZmimqf5UgytlnHerBN onlvJI6KACN3p6Ths3O89SXMf1xO7Vj5yrFD4M0VF4Kq+KZpCj3RdvU4Y32ZD3+kXa0mIKh/ +32wFZLee1iU0z3UUkXTNEuVsYqh1/+HP57/eFbL9z8G6xdo/R9C9/H+wYmiP9n+cyfwIGMX RevTCIKzJBfVN29Mag1R19CgPDBZkAfm8zZ9yBl0f3DBeC9dMG2ZkK3gy3BkM5tIV4cacPVv ylRP0jRM7TzwKcr7PU/Ep+o+deEHro5i/Fx9hMFoCs/Egoubi/p0Yqqvzpiv2SeYOjR6Bz7V 0mRl33mdcXi4/fgDynQzxFjwm4EkToawSjY6VPpRvL1WGG4owi9/+fHrl19f+l+ffr79ZVBt //r08+fkGhAPxzgndaMA51x3gNvYnNw7hJ6cli5u+xMYsbPt63wAtJ1ZF3X7t05MXmoeXTM5 QGbDRpRRejHlJsoyUxTkTl3j+lQJmcEDJtUwhw0WMKOQoWL6THXAtb4My6BqtHByADIT2FW7 nbYos4Rlslqm/DfIGsZYIYLoLgBg1A1SFz+i0EdhNNn3bsAia5zpD3ApijpnInayBiDVnzNZ S6lupIk4o42h0fs9HzymqpMm1zUdV4DiU44RdXqdjpZTXTJMi19qWTksKqaisgNTS0YR2X0N bRLAmIpAR+7kZiDclWIg2PmijccX78xUn9kFS2KrOyQlGE2VVX5Bp2dKEhDaVh6HjX96SPtZ mYUn6Ahoxm3PgBZc4LcOdkRUiqYcyxCHNBYDh5JItK3U3u2iNmlowrFA/JDEJi4d6onom7RM bQtLF+cd/IV/BG8stXHhMcHtV/XLCBydO4IAUZvSCodxJX6NqmmAeWFd2vfiJ0klIl0DVPOp zyM4WQfdGkQ9NG2Df/WySAiiMkFygJxjwK++SgswptebI3yrlzW1feBzkNrau1WizuYHQ3SQ Bh6QFuG8+Ne71K7fn+WjNrhv9TtbvlUzVP8BHQMrQLZNKgrH/CZEqW+4xpNj25zF3dvzzzdn S1Dft/hlB+zYm6pWW70yI7cFTkSEsA1mTA0tikYkuk4G65uf/vX8dtc8ff7yMmms2A6u0B4a fqlJoRC9zJHtMZVN5AOpMWYWjPfC7n+Gq7vvQ2Y/P//vL5+eXZdtxX1mi6brGmmh7uuHtD3h 6e5RO4eCd4JJx+InBldNNGOP2pvT7PnwVkanLmRPFuoHvrECYI8cgsDelQT4EOy0H3ojkIry LjFJOV6LIPDFSfDSOZDMHQiNTwBikcegogLPmO0pAjjR7gKMHPLUTebYONAHUX5UG39RRhi/ vwhogjrOUttLkc7suVxmGOoyNevh9GojjpEyeCDt0Q/sULNcTFKL481mwUB9Zh/YzTAfeXbI 4F9ausLNYnEji4Zr1X+W3arDXJ2Ke7YGVTM0LsLlBk4AFwtS2LSQbqUYsIgzUgWHbbBeBL7G 5TPsKUbM4m6Sdd65sQwlcdtoJPj6ldWhdbr7APbx9HgJRqGss7sv39+eX399+vRMRuEpi4KA NE8R1+FKg7NiqRvNFP1Z7r3Rb+GQUwVwm8QFZQJgiNEjE3JoJQcv4r1wUd0aDno2nRkVkBQE Tzp7bRoOTCVJ+h2Z5aaJ2V5L4cY4TRqENAeQkhiob5FpbfVtaTsyHgBVXvemeaCM0iPDxkWL YzplCQEk+mlvv9RP57xQB0nwN64bJAvs09hWZbQZ5CMbrn4n4dp4Kf/6x/Pby8vb7961Fu64 wTsjrpCY1HGLeXQFARUQZ/sWdRgLNH67qWtsOwBNbiLQ5YhN0AxpQibIIrJGz6JpOQyEArQs WtRpycJldZ85xdbMPpY1S4j2FDkl0Ezu5F/D0TVrUpZxG2lO3ak9jTONZDJ1XHcdyxTNxa3W uAgXkRN+X6uZ1kUPTCdI2jxwGyuKHSw/p2rpcvrI5YTsXzPZBKB3Wt+t/GuGn7DDp+2986HC nG4D3kfRNsbkrdG7lmlq8w63SWg+qH1FY18/jwi52ZlhbRCyzytbIp5Ysl9uunv7gbcKdm93 Ds/WBLTxGuymA7phjs6HRwSfUFxT/UbX7rMaAsMSBJK2/5IhUGbLpYcj3KJYXcXc1gQ9THRg 49UNC8tLmqttetNfRVOqdVwygeIUvKJlxmFNX5VnLhC4eVBFBN8X4DCrSY/JngkGZn5HxzsQ RDuxY8KBTVgxB4En8H/5C5Oo+pHm+TlXItspQ+Y2UCDjnBP0Chq2FoZjcO5z17zmVC9NIkaT pQx9RS2NYLg/Qx/l2Z403ogYJ4Tqq9rLxeiYl5DtfcaRpOMPV3CBixi3QjFDNDFYcoUxkfPs ZPT1z4T65S/fvnz/+fb6/LX//e0vTsAitY9YJhjLARPstJkdjxzNiOLTHfStCleeGbKsMmKj d6IGg4i+mu2LvPCTsnVMu84N0HqpKt57uWwvHc2diaz9VFHnNzi1KPjZ07Wo/axqQVBhdSZd HCKW/prQAW5kvU1yP2nadbDXwXUNaIPhAVanprGP6eyh6ZrBU7X/op9DhDnMoL9Mftmaw31m yybmN+mnA5iVtW3xZUCPNT323tX0t+O+YoA7ety1c9ojFtkB/+JCwMfk1CM7kC1NWp+wft+I gPqP2k7QaEcWlgD+2L08oFcfoD52zJCGAYClLc4MAJiVd0EshQB6ot/KU6K1Z4bTxKfXu8OX 56+f7+KXb9/++D4+HfqrCvq3QSaxH8+rCNrmsNltFoJEmxUYgOk+sA8PADzY+6AB6LOQVEJd rpZLBmJDRhED4YabYSeCIoubCjtPRTDzBZIlR8RN0KBOe2iYjdRtUdmGgfqX1vSAurGAF2mn uTXmC8v0oq5m+psBmViiw7UpVyzIpblbaX0D66z5T/W/MZKau6tE13Kurb0RwbeDCbjJxsbI j02lRSvbojSYob+IPEtEm/Ydfd1u+EIS9Qc1jeBdgzbjjQ2Qgz33Ck0FxmfxfEFglIA9Z7vg YVwUe9tUanpU4qM47UmM6CiM/uiTqhDI46AFjkbMMTk4nkBgCmN9bwvJo51/+AIC4ODCLvcA OHbsAe/TuIlJUFkXLkJndAt31FAmTvvYAi8orB4JDgZS758KnDbao2EZc9rMukx1QaqjT2pS yL5uSSH7/RW3QyEzB9AeYk3rYQ42Kve0lZ0a0wYCwJa98T2hT2FI47fnPUb09RUFkd1tANQu HZdn0vwvzrgr9Vl1ISk0pKC1QDdvVlfj+1/sZeSpnlZC9fvu08v3t9eXr1+fX91TL10u0SQX c3lvDmafPj9/V8NTcc/Wxz/dR9q6CWORpGVMG39AtWdQD5UiVyjvporiMJcjfXkl9Xxo1X/R +gyonkVILvB9AYSCrDqXzxPBTRtjPnDwDoIykNu5L1Ev0yIjcWb40GDGmON8i6SxgwMMJSHT chvQzYsuZHs6lwncYqTFDdbp96o21ZIRn+wdKoK5bjBxKf1KP0Jo03sKV/vskmaTk8Tk+eeX 375fn151pzEGLCTbRZMriSq5cjlSKMlLnzRi03Uc5kYwEk55VLzQcjzqyYimaG7S7rGsyCSU Fd2afC7rVDRBRPMNJzRtRbvmiDLlmSiaj1w8qlUjFnXqw51PTpnTPeEokXZOtcYkot/Splfy Zp3GtJwDytXgSDltcZ81ZBlJdd7UfE+me7VJrWhIPZEEuyWBz2VWnzK6/PfYgcjN7jr5ReTn 62kuT79//vHy5Tvu4GplS+oqK0nzjWhvsANdvdQiN9y0oOSnJKZEf/77y9un399dR+R10JAx Dj5RpP4o5hjwmTe9BDW/tavkPrbt1MNnRkobMvz3T0+vn+/++frl82/2Ju8RlNznz/TPvgop oub46kRB2zy4QWA+VxJ46oSs5CmzJdg6WW/C3fw724aLXWiXCwoAD8W0dSBbvUfUGTqSH4C+ ldkmDFxcmyIfDdBGC0oP8k/T9W3XEyfCUxQFFO2ITsYmjpyxT9GeC6oRPHLggqd0Ye3CuI/N wYRutebpx5fP4BPT9BOnf1lFX206JqFa9h2DQ/j1lg+v1uTQZZpOM5Hdgz25M57LwZf4l0/D Zuauos54zsbTOzWZhuBe+2aZz8VVxbRFbQ/YEVGLIDKNrfpMmYgcz+qNifuQNYV2LLs/Z/n0 AOPw5fXbv2ESAgs8thmVw1UPLnQhMkJ6r5eoiGyfefpkf0zEyv381VlrHJGSs7TaOeb5Hqk3 zeEsR9tTk9BijF9dRam3qra7vYEyHrV5zofqq/smQ1va6UK/SSVF9V20+UDtO4rK1gfTnDAn pyYEaDSnv3ybGvNR9qdHVRuXTNperka3W+DqCnYv5jOWvpxz9UPoF1DI1Yza0/doL9ukR2RP xPzuRbzbOCA68hgwmWcFEyE+epmwwgWvgQMVBZruhsRtF5tjhLGt+zsGtK9SYSKTJ9GYXntA 7aeog96BEGOeY0VqV2Cqmqu8Oj7anc4z1o2GwR8/3YNFONCI7X3aACwXC2enAQ8ulRDSHzNQ FWis8hVV19qK9iCv5GqZKvvc3mIrSbC/pvaBJUhYfbrPbD9EGRw1qd067g3yXK4WsHsOHbxT O2j7FHA4klG/SuyhT+NHu6VHuQh6dpuSJC9pp0f1IJ5YA1/moJ9iAs9Xylb9Tku/yQPyCAdb IWqx/1hK8gvUHjL7QFqDRXvPEzJrDjxz3ncOUbQJ+qFHvlTjnPh2//H0+hPre6qwotlol9kS R7GPi7WS6DnKdrRNqOrAoebeW/UXNam3SKca0j/IG9+0TYdxGGO1ajDmEzX2wAvYLcqYWtAO MLWnzr8H3ghUZ9LHOGpjmNxIR3v5Ayd/v7Dexscq1y1xVn/eFcYi951QQVuwU/fVHNXmT/91 2maf36tpn7YM9jF6aNE5Ov3VN7YtF8w3hwR/LuUhsQa4LDCtW7iqSX6wh8ih7YwHdnDxKqTl 1KQRxT+aqvjH4evTTyWd//7lB6OEDF3skOEoP6RJGpN1CHA1hfYMrL7XTxTAYVBV0v6rSLWt Ndmezh5HZq/kl0dwyah49pByDJh7ApJgx7Qq0rZ5xHmA9WMvyvv+miXtqQ9usuFNdnmT3d5O d32TjkK35rKAwbhwSwYjuUEu+6ZAoHCFVCCmFi0SSac6wJVQKlz03Gak7zb2MZIGKgKI/eBr eBbF/T3WOE1++vEDdPwHEDwqm1BPn9TKQbt1BYthN/o/pVPe6VEWzlgyoOMuweZU+Zv2l8V/ tgv9f1yQPC1/YQlobd3Yv4QcXR34JC9wiq8qOOXpY1pkZebharXr0W588TQSr8JFnJDil2mr CbK+ydVqQTB0PG0AvKGfsV6o3e+j2tmQBtA9r780anYgmYPTsQY/VHiv4XXvkM9ff/07HEI8 aW8MKir/2wtIpohXKzK+DNaDXkrWsRRVXFBMIlpxyJE3DQQP7uJVKyIXCjiMMzqL+FSH0X24 IrOGlG24ImNN5s5oq08OpP5HMfVbycKtyI0qhe3qeWDVfkOmhg3CrR2dXhpDIw6ZI9svP//1 9+r732NoGN8toC51FR9ti1bGDrvaPxW/BEsXbX9Zzj3h/UZGPVptoInmnp4KyxQYFhzayTQa H8K5LbBJpyFHIuxg8Tw6zaLJNI7hiO0kCvxWxRNASQskeXCn6ZbJ/nSvHwoOBzL//ocSlp6+ fn3+egdh7n41M+58M4NbTMeTqHLkGZOAIdxJwSaTluFEAZpAeSsYrlLTV+jBh7L4qOlMhAZo RWm7Jp7wQc5lmFgcUi7jbZFywQvRXNKcY2Qew4YuCruO++4mC5tHT9uqncNy03UlM/+YKulK IRn8qDbtvv4CW7TsEDPM5bAOFlgBaC5Cx6FqZjvkMZVrTccQl6xku0zbdbsyOdAurrkPH5eb 7YIh1KhIS3BfHvs+Wy5ukOFq7+lVJkUPeXAGoik27KwZHDb3q8WSYfB9yVyr9tsAq67p7GPq Dd+EzrlpiyjsVX1y44nchFg9JOOGinVLaUSyLz8/4blCukappq/hP0jramLIyfzcSzJ5X5X4 9pEhzb6E8fh4K2yizx0X7wc9Zcfbeev3+5ZZMGQ9DTJdWXmt0rz7v8y/4Z0SkO6+Gc/zrISi g+EYH+D5/7QJm1bF9yN2skWlrgHUin9L7W5Rbd3twyLFC1mnaYIXH8DHS/+Hs0jQESGQ5gLu QD6B0xg2OOhtqX/pnvS8d4H+mvftSTXiqVLTPRFedIB9uh+eIocLyoEhFWcHAAQ46eNSI2cB AOsDXaxFtC9ita6tbTtJSWsV3hbyqwOcorX4SZQCRZ6rj2zTQRVYDhYtOIBFYCqa/JGn7qv9 BwQkj6UoshinNAwCG0NnstUBeyxQvwt0b1WBiWKZqnUP5pKCEqA8ijDQIMvFI07hXNiXamox Rnr3A9CLbrvd7NYuoSTTpYuWcGxkP8DJ7/Ej4QFQyav63tu21ijTGx15o++V2VNbnKB97fgh XBFLCfN3Vg+r+nSm8VGJgMwZxvjpGdXiiOaVbZ3MRkFz32hMzwrOI69fF1T8t0mzt+ZJ+OUv 5VQf9icjKO85sNu6IJJ9LXDIfrDmOGdnoqsc7AbEySUhLTHCw72AnKsE01eiSCnguhhubZCR yC4th2PB/tBUasNqy0sWCXdbiBusXqA+NWNq+23rS0yF5Sq3kbrzGM3nS5G6SjCAkj3O1FwX 5CYGAhpnRAJ5RQL8IPZqCZYUjQmArI4aRBuXZkHSaW3GjXjE/d+YtGc9XLs2JlnEvaaRaSnV SgbeUKL8sgjtp2PJKlx1fVJXLQviuzGbQMtWci6KRzxt1idRtvbEYI47ikxJULa+QZsdCtJ4 GlIyvW0UNpa7KJRL+1m63oL00raQp9bgvJJneN8F14yxfUV4qvsst6ZtfXsUV0oCR/sVDcPK iJ/v1YncbRehsBWNM5mHu4VtidMg9vnRWPetYlYrhtifAmSaYMR1ijv77eWpiNfRypJgExms t0jXApxX2XqdsCpmoIsY15FzESXRZDTdV4Gu8IHomE66NnihHtQUZXKwH/oXoKfRtNLWz7rU orQX3jgcFjjdbdNUyXOFq4BpcNXQobW4zeDKAfP0KGzvXgNciG693bjBd1Fsa5dNaNctXThL 2n67O9WpXbCBS9NgoTc109gkRZrKvd8EC9LdDUafocygEjrluZiuFnSNtc//efp5l8FLtD++ PX9/+3n38/en1+fPli+ir1++P999VhPClx/w51yrLRxh23n9P4iMm1rwlIAYPIsYFU3ZinpS dsy+vz1/vVOymRLhX5+/Pr2p1OfuQILAXak5Vhs5GWcHBr5UNUbHvq5kBkunao759PLzjcQx kzHoXTHpesO//Hh9gcPZl9c7+aaKdFc8fX/67Rmq+O6vcSWLv1mng1OGmcxao1Rrqg42lWdH Bjdqb/zymJbXB6wNoH5Pu9k+bZoKlDpiEAIe5z1hGp8qMrZFrjowOewax7wPRi9tTmIvStEL 9KgarV1D7cpsPNt05gYge2TxrREZnEu1aM+G5Az9TWJL2hopqc9zjeqr9tnEgs7MkIu7t//+ eL77qxoP//ofd29PP57/x12c/F2N979ZBhdGMdAW0E6NwexH52O4hsPUtFwm9kZ1iuLIYPYB jS7DtB4SPNbqeEiJQON5dTyi01eNSm0vCDR7UGW04+zwk7SK3ii77aBEGxbO9H85RgrpxfNs LwX/AW1fQPW4QVY0DNXUUwrzCTspHamiq3lLaS36gGMvbhrS1/bEoJ2p/u64j0wghlmyzL7s Qi/RqbqtbPE3DUnQsUtF175T/6cHC4noVEtacyr0rrNPZEfUrXqB9VsNJmImHZHFGxTpAICm B3gwawZrMpat0DEE7LNB/01tn/tC/rKyrh/HIGbJNMqgbhLDq2kh739xvoQH+OZJKDxfwZ4V hmzvaLZ372Z79362dzezvbuR7d2fyvZuSbINABU4TBfIzHDxwHhyNzPwxQ2uMTZ+w7SqHHlK M1pczgWNXZ9mykenr4EuWUPAVEUd2kd6ShbUS0KZXpF9vYmwLQzNoMjyfdUxDBUuJ4KpgbqN WDSE8uuH20d0nWh/dYsPTayWZw5omQLeAzxkrCcOxZ8P8hTTUWhApkUV0SfXGCyVsqT+ynmp M30aw5vpG/wYtT8EvgiYYPfZzETh1xcTvJdO/wYpmq4BxaOtjThCVuPBOYdZwJwjELUK2Rt5 /dOeiPEv01poIzRBwxh31oqk6KJgF9DmO9AXgzbKNNwxaalwkNXOSlxm6Ln+CAr05MxkuU3p siAfi1UUb9XUEnoZUE4dTlzhElebewl8YQe7HK04SutkjISCwaJDrJe+EIVbpprOHgqh+rIT jrWmNfygJCXVZmqE0op5yAU622njArAQrXgWyM6TEMm4gE9j/UENAFZFTBEHj98eEFjqQ+yb GZI42q3+Q2dXqLjdZknga7IJdrTNuczXBbfq18V2oU9vcO72B6guX/6o/QgjI53SXGYVN7ZG 4cz3vEacRLAKu1knfcDH0URx08wObPoW6AR9w7VBh1hy6ptE0OGu0FPdy6sLpwUTVuRn4Yin ZFs0fmNej8NZrjvBIsEYgoymYPTWz0pXf15MXmRj67Xqv7+8/a5a6vvf5eFw9/3pTW1VZ8OA 1jYAohDIioWGtPOSVHXJYnTEvnA+4XJ+0o+PYwplRUeQOL0IAqELZINcVK8lGLmv1hi5TdYY ef2qsYeqsX1s6JJQlbS5eDJVGw5byNOUChwH67CjX+jXU0xNyiy3D8U0dDhM+zPVOp9os336 4+fby7c7NQVzTVYnaneG98YQ6YNsnb4hO5LyvjAfmrQVwmdAB7NeD0A3yzJaZCUguEhf5Unv 5g4YOgWN+IUj4B4bdBBpv7wQoKQAnOZlkrYafmU9NoyDSIpcrgQ557SBLxkt7CVr1bI52Viu /2w96+kA6S0ZxDZzZ5BGSLCAe3Dw1haaDNaqlnPBeru2369pVO2P1ksHlCukZzmBEQuuKfhY 41tbjSqBoSGQkviiNf0aQCebAHZhyaERC+L+qAk0IRmk3YYB/V6DNOQHbb6Gpu/oU2m0TNuY QbPyg7CVqA0qt5tlsCKoGk947BlUycduqdTUEC5Cp8Jgxqhy2onA1DjasRnUVvTXiIyDcEHb Gp1gGQTu1ZtrhS1hDANtvXUiyGgw98WqRpsMzF0TFI05jVyzcl/N6it1Vv395fvX/9JxRwab 7vELYrhFtyZT56Z9aEEqdElm6pvKNPwybz4/+Jjm42AdGj3v/PXp69d/Pn36190/7r4+//b0 idHHMasatRIBqLMxZm5xbaxI9Du/JG3RCysFw0MfewgXiT6oWjhI4CJuoCXSHE64m99iuPJH uR9dh1ulIJfl5rfjxsKgw5GrcwIyqR0UWj2zzRj1gsRqrsQxkKO/PNgC8RjGqOaAh2VxTJse fqBzXBJO++JxjQtC/BkoV2VIIy7RFnLU0Grh3W2C5EjFncFsYlbbOmcK1YoXCJGlqOWpwmB7 yvSTmovawlclzQ2p9hHpZfGAUK155gZG5kHgY/ySWCHgXqdCjye1X2R4uitrtBtUDN7VKOBj 2uC2YHqYjfa2VwlEyJa0FVIQAuRMgsBeHTeDfhaIoEMukIsbBYFud8tBo9Z3U1WtNi8osyMX DF31QqsSByxDDeoWkSTHIFDT1D/Cu60ZGTQdiEKA2i5nRPkMsIPaTNijAbAan3sDBK1prYqg X7HX/Z8obugo7Ren5mCfhLJRc15vyWn72gl/OEukSWR+48vSAbMTH4PZp4gDxpwPDgzSMx4w 5OpmxKZ7HnNnmabpXRDtlnd/PXx5fb6q//3NvXE7ZE2K7VaPSF+hDcoEq+oIGRip081oJdGr xpuZGr829h+xokeR2YbwnM4E6zmeZ0B5Zf6ZPpyVsPzRcepidwzqKLFNbVWKEdHHW+APXSTY SxIO0FTnMmnUzrj0hhBlUnkTEHGbqR2t6tHUqdscBkwN7EUukCWrQsTYJRcAra0QmtXa6Wse SYqh3+gb4lyJOlQ6otchIpb2fAJybVXKilgLHDBXf1Nx2G+P9qejELjhbBv1B2rGdu8YDG0y 7BTW/AYTIvTFz8A0LoO8HKG6UEx/0V2wqaREHgMuSM9uUI1DWSlzx6/xxfYTqD1KoSDyXB7T Ap6+zZhosHNe87tXwnfggouVCyJnNwOGXO6OWFXsFv/5jw+35+kx5kxN61x4tTGw94aEwHI1 JW0NPvCrbWxRUBAPeYDQ/e3gyFtkGEpLF6Ay2giD9RwlrTX2uB85DUMfC9bXG+z2Frm8RYZe srmZaHMr0eZWoo2baJnF8FSUBbWSvequmZ/NknazQa6sIYRGQ1sLzka5xpi4Jr70yAgmYvkM ZYL+5pJQ26xU9b6UR3XUzp0nCtHCNS682p6vORBv0lzY3Imkdko9RVAzZ2U5vckOllqXs8nT 9pORjxWNgEYHcf8144+2a0ANn2wJTCPTQf74TvLt9cs//wA9pcHokHj99PuXt+dPb3+8ct5L VvZryZVWNXMM1wBeaEtOHAEv4zhCNmLPE+A5hPjgA0fqeyUlykPoEkRvd0RF2WYPPm/yRbtB J14Tftlu0/VizVFwTKSf3NzLj5w3QTfUbrnZ/IkgxPavNxg2P8wF2252jAt6J4gnJl12dF/m UP0xr5Q8w7TCHKRumQoH11FoUiHEza9gFLvkQyy29y4MdlnbVO21C6aMspAxdI1dZKsPcyzf KCgEfo4yBhmOi5WYEG8irjJJAL4xaCDrVGk2/fcnh/MkYYNbPySUuCUwem99RIwo6uu3KF7Z t5MzurUM0V2qBl1Rt4/1qXLkKZOKSETdpkjRXQPa1MEBbXnsr46pzaRtEAUdHzIXsT6hsO8H wcQR9cw9hc+vWVnaM5L2oAf+h2PPF21qF07EKVIzML/7qsiUfJAd1RbQXiWMQm4rPeUsxEdf xdnHeurHNgCfKLZgW4N0hs6kTWuVRYy2CerjXu2lUxfBjnAhcXIHN0H9JeRzqXZ0ahK2l/IH /LrHDmzbrlY/dJ2TLeQIW40PgVwrsXa80OkrJIfmSIrJA/wrxT+RArWnm52bCl1Y6t99ud9u Fwv2C7M3Rc+3bBv+6ocxoQyevdIcndYOHFTMLd4C4gIayQ5SdrZPO9RhdSeN6O/+dMVGxUD3 kfxUKzoyR70/opbSPyEzgmKMSpK264Wf4qk0yC8nQcCM2/S+Ohxg601I1KM1QsqFmwgel9rh BRvQMVStyrTHv7SEeLqqWa2oCYOaymzx8i5NhBpZvjknFpfMdv492k+Gica22m/jFw++P3Y8 0diESREv0Xn2cMZ2REcEJWbn2+iPWNEOCiVtwGF9cGTgiMGWHIYb28Kx+spM2LkeUeS/xC5K JmOrIHjOt8OpLpzZ/caoJzArcdyB/Wv7GBmfScxxJuTgRu14c3vuS9IwWNj3vgOgxIp83sqQ j/TPvrhmDoSUuAxWitoJB5jq4krWVDOGwLP8cJnXb5fWbJgUu2BhTUMqllW4Rral9YLVZU1M z+DGmsCvB5I8tPULVF/Gx24jQspkRQgG9m3ZZZ+GeOLUv53J0KDqHwaLHEwfBjYOLO8fT+J6 z+frI17ezO++rOVw81TABVHq6zEH0SjB6pHnmjQFHxX26bLdwcAkxwFZ2wWkfiCiI4B6xiL4 MRMlUg6AgEktBJZWRjT0wWrqgVskZBFPkVDkmIHQFDSjbp4Nfit26NRg/FhP3uj82q7F84es lWen8x6Ky4dgy0sNx6o62tV+vPBi4GSWc2ZPWbc6JWGPlwitLX5ICVYvlrhST1kQdQH9tpSk dk62PT2g1a7kgBHc4RQS4V/9Kc6PKcHQtDyHuhwI6u3NJ2sgnOrAI2GdzuKa2p4sMt8cnW3D Fd2mjRR2CpqixFLs7Vn/tAqbHffoB501FGSXOetQeCyS659OBK6QbqCsRmf7GqRJKcAJt0TZ Xy5o5AJFonj0255pD0WwuLeLaiXzoeC7uWvA6LJews4Xdd7igntpAaf8tuWZS21ffdWdCNZb HIW8t/sk/HJU2QADmRlrkN0/hvgX/a6KYTPYdmFfoJcMMy54ychVsQdyRMHIsuezXC0m6M1E 3qnRXjoAbkkNEttkAFELc2Ow0aT5bBsz71aa4S1n5p283qQPV0bx2C5YFiN/kPdyu12G+Ld9 Y2J+q5jRNx/VR50rYFtpVGRZLeNw+8E++xsRc61O7egptguXira+UA2yWUb8dKKTxJ5ZChnH qn+kObxYIzf6Ljf84iN/tF3/wK9gcUSrushLPl+laHGuXEBuo23Iz7Tqz7RB8p4M7SF66exs wK/RqDmo/eObARxtU5UVmi0OyB9e3Yu6HjZ8Li72+loDE6SH28nZpdXqxn9KtNpGO+QUyGi7 d/jmjxqPGQD6DL5Mw3uiu2biq2Nf8uVFbbis6U9to+M0QdNdXsf+7Ff3KLVTj5YdFY9n5qnB 7Eg7uHSw5QShpIoT8moB1vEP9Ip9jCYtJVyxW0tF5VumhycBE/WQiwidVT/k+CTD/KaHBAOK 5sMBc88C4AESjtNWmXkAg1Qk9jThVzfQbYArAytoLDZIgBgAfBw8gtg1ojHAjgS4pvC1MVIB bdaLJT+Mh2PzmdsG0c6+m4XfbVU5QI/MtY2gvoZtrxnW5xvZbWD7LgFUK5o3w5NNK7/bYL3z 5LdM8VO/E17nG3HhN+9wXGhniv62gkpRwN2+lYiWsFA6dvA0feCJKhfNIRfoQTgyTAZuLW2j xxqIE3hqX2KUdLkpoPuGHDyGQrcrOQwnZ+c1QwfEMt6FiyjwBLXrP5M79Fwtk8GO72twi2IF LOJd4G78NRzbPm3SOovxizgVzy6wv9XI0rNSKTkKdEnsc0Sp5np0vQqA+oRqx0xRtHoRt8K3 Bex6sYRpMJnmB2OinzLuiWdyBRyeTzxUEsdmKEcD2MBqicJrr4Gz+mG7sA9TDKzWArUbdWBX /Bxx6UZN7Hoa0ExI7emhcij3cN7gqjEO9VE4sK1+PUKFfZExgPjd0ARuM7e2PRKgtNWHTkpm eCxS29+C0eqZf8cCHk8iOeHMR/xYVjXSxYeG7XK85Z4xbw7b9HRGNpvIbzsoMu00mjgli4RF 4G1UC44fldBenx6h2zoEAewuPQDYJEiLphArm0jTX/3omxNyCjVB5JAOcLU9VAO45c+xrtlH tACa3/11hSaMCY00Ou1JBnx/loPvCHbnYoXKSjecG0qUj3yO3DvfoRjU8eNg6Ul0tCkHIs9V p/BdFNCjU+tENbTfIB+SxB5K6QFNEfCTvuW9tyVxNbiRc55KJM0Z36LOmNogNUq2bohdfOMI 7IJOETSITFxqxJgCpcFAUxk7uJzwc5mhGjJE1u4Fsnc9pNYX545H/YkMPDFca1N6Ku2PQSh8 AVQFN6knP4PCep52dqXqEPQySINMRrjDQU0gNQeNFFWHpE0Dwma0yDKalDnbIKC+NCfYcLlE UOrU9PRInEEDYFsJuCIly1yJ4G2THeHthSGMOb4su1M/vUb4pd19RQIvIZDqZpEQYLjIJqjZ xu0J2m4XUYexycsOAbX5EwpuNwzYx4/HUnUGB4fhTitpvF3GoeMsBieYGDP3UxiEJcL5Oqnh BCB0wTbeBgETdrllwPUGg4esS0ldZ3Gd04IaE4bdVTxiPAfzI22wCIKYEF2LgeF0kQeDxZEQ ZrR2NLw+lnIxo1vlgduAYeB0BcOlvjMTJHYwSdyCDhTtEg9uDKPeEwH1LomAo4tchGrVJoy0 abCwH5uCuorqcFlMIhyVlRA4rFBHNRjD5ogeBwwVeS+3u90KPXtEl5J1jX/0ewndmoBqgVLi dIrBQ5ajjSdgRV2TUHpaJRNOXVcC+RNXAPqsxelXeUiQyWSXBWn3fEi/U6KiyvwUY25yT2iv dZrQZmcIph8bwF/WedJZ7o06GdXEBiIW9sUZIPfiivYdgNXpUcgz+bRp821gm9ScwRCDcBiK 9hsAqv8hSW3MJkynwabzEbs+2GyFy8ZJrG/TWaZPbQHeJsqYIcylkZ8HothnDJMUu7Wt2D/i stltFgsW37K4GoSbFa2ykdmxzDFfhwumZkqYGrdMIjDB7l24iOVmGzHhGyXsSuIO2a4Sed5L fRqIjWi5QTAHzjmK1ToinUaU4SYkudin+b19hqjDNYUaumdSIWmtpu5wu92Szh2H6DBizNtH cW5o/9Z57rZhFCx6Z0QAeS/yImMq/EFNyderIPk8ycoNqla0VdCRDgMVVZ8qZ3Rk9cnJh8zS ptEP0jF+yddcv4pPu5DDxUMcBFY2rmjjBu/DcrBNe00kDjNrcBbo4ED93oYB0qg7ObrSKAK7 YBDYUfM/mYsCbQdXYgJMsA1vk4zXVwBOfyJcnDbGpi46MFNBV/fkJ5OflXnBa085BsXvY0xA cM4an4Ta+uQ4U7v7/nSlCK0pG2Vyorh9G1dpp8ZXPajLTbtVzTP70yFte/qfIJPGwcnpkAO1 84pV0XM7mVg0+S7YLPiU1vfo3Qf87iU6ehhANCMNmFtgQJ3X0wOuGpna5hLNahVGv6CNvpos gwW7vVfxBAuuxq5xGa3tmXcA3NrCPRt56iE/tXonhcztEf1us45XC2LJ1U6IUyaN0A+qdqkQ acemg6iBIXXAXntu0fxUNzgEW31zEPUt52VA8X6l1ugdpdaIdJuxVPj2QcfjAKfH/uhCpQvl tYudSDbUllNi5HRtShI/tUCwjKithgm6VSdziFs1M4RyMjbgbvYGwpdJbF/Fygap2Dm07jG1 PjpIUtJtrFDA+rrOnMaNYGB+shCxlzwQkhksRHNTZE2Fni7aYYn6T1ZfQ3SaOABwRZMha00j QWoY4JBGEPoiAAKMulTkZbBhjF2k+Iy8G44kOoYfQZKZPNsrhv52snylHVchy916hYBotwRA n718+fdX+Hn3D/gLQt4lz//847ffwImi48V+jN6XrDXDTq9e/kwCVjxX5NBnAMhgUWhyKdDv gvzWX+3hOfmwt7Se8d8uoP7SLd8MHyRHwFmotdbNj368haVdt0EmsUB8tzuS+Q1mAIorupck RF9ekL+Cga7ttxAjZss/A2aPLbVLK1LntzZ7UjioMThyuPbwZgbZ3FBJO1G1ReJgJbxEyh0Y 5lsX00uvBzZij33KWqnmr+IKr8n1aukIcIA5gbCOhwLQbcAATGY4jUcDzOPuqyvQdvtk9wRH r04NdCX92nd4I4JzOqExFxSvxjNsl2RC3anH4KqyTwwMtmmg+92gvFFOAc5YgClgWKUdr5F2 zbes3GdXo3NHWijBbBGcMeC4/FQQbiwNoYoG5D+LED82GEEmJOPkDuAzBUg+/hPyH4ZOOBLT IiIhglXK9zW1NTCHaVPVNm3YLbi9AfqMqp7ow6TtAkcE0IaJSTGwCbHrWAfehfZl0gBJF0oI tAkj4UJ7+uF2m7pxUUjthWlckK8zgvAKNQB4khhB1BtGkAyFMRGntYeScLjZRWb2AQ+E7rru 7CL9uYRtrX0u2bRX+8RF/yRDwWCkVACpSgr3TkBAYwd1ijqBvl1YYz+JVz96pGrSSGYNBhBP b4Dgqte+HOynInaadjXGV2xuz/w2wXEiiLGnUTvqFuFBuArob/qtwVBKAKLtbI61Qq45bjrz m0ZsMByxPkyffZtgk2V2OT4+JoIcu31MsG0U+B0EzdVFaDewI9Y3dWlpv7l6aMsDuvccAO0q z1nsG/EYuyKAknFXdubU59uFygy86uPOg82RKT5NA1sM/TDYtdx4/VKI7g4MLH19/vnzbv/6 8vT5n09KzHM8iV0zsD2VhcvForCre0bJ8YDNGG1b4zxjOwuS76Y+RWYX4pTkMf6FDdWMCHlz AijZemns0BAA3flopLP9TakmU4NEPtqniaLs0ClKtFggPcWDaPCFDDwB7xMZrlehrVeU23MT /AKDX7Mbv1zUe3LToLIGlz0zALazoF8oEc25dbG4g7hP8z1LiXa7bg6hfQzPsczOYQ5VqCDL D0s+ijgOkQFYFDvqRDaTHDahrYFvRyjUKudJS1O38xo36PLCosjQ0sq42oqUxyXiQLouEQvQ x7bfNBtVhH2Vt/gA3cSAUoXBfBBZXiE7JZlMSvwLTDMh4ytKgid27adg+j+oDSamyJIkT/GG rMCp6Z+q+9YUyoMqm4yHfwPo7ven18//fuIsu5hPToeY+o0yqL4ZZXAsjmpUXIpDk7UfKa7V dA6iozjI5yXWGdH4db22lT0NqKr/AzJYYTKCJqEh2lq4mLSfHpb2ll796GvkJXNEptVlcCv2 4483rzOsrKzPtolC+EnPFjR2OICL2hyZTjYMWE1DltEMLGs1a6X3yE2wYQrRNlk3MDqP55/P r19h5p7Mi/8kWeyL6ixTJpkR72sp7Ks0wsq4SdUI634JFuHydpjHXzbrLQ7yoXpkkk4vLOjU fWLqPqE92Hxwnz7uK+QBaUTUpBWzaI0tYGPGFmMJs+OY9n7Ppf3QBosVlwgQG54IgzVHxHkt N0jJeaL0A2jQWFxvVwyd3/OZS+sdMkwzEVhvDMG6n6ZcbG0s1stgzTPbZcBVqOnDXJaLbRRG HiLiCLVGb6IV1zaFLcfNaN0oKZIhZHmRfX1tkOXWiUUWxie0TK+tPZPNRccuDCa8qtMSBGcu Z3WRgd8ULh3nHcLcNlWeHDJ4+wBWaLloZVtdxVVwhZJ6/ICbOY48l3z3UYnpr9gIC1vHxo5r mfV5ww/JSs1lS7b/RGrUcfXRFmHfVuf4xDdWe82Xi4gbTJ1nvIJOVp9ymVPLMqhfMczeVhGZ +1d7r1uSnUutBQp+qlk3ZKBe5LZ67ozvHxMOhpdR6l9bcp5JJfqKukUOlhmylwXWtJ2COBb/ Zwrkm3t9L8+xKVhgQ6aXXM6frEzh8sWuRitd3fIZm+qhiuEwiU+WTU2mTWar/RtU1HWe6oQo o5p9hbz0GDh+FLWgIJSTaNgi/CbH5vYi1QwhnISIxq8p2NS4TCoziWX+ccGWirOEoxGBByeq u3FElHCorVk+oXG1t2fHCT8eQi7NY2OryiG4L1jmnKnFqrBfyk6cvhkRMUfJLEmvGdZSnsi2 sOeuOTr95NJL4NqlZGjrPk2kkv6brOLyUIijfvLN5R2splcNl5im9uid7cyBBgxf3muWqB8M 8/GUlqcz137Jfse1hijSuOIy3Z7VJkwtlIeO6zpytbA1iSYCxMkz2+5dLbhOCHB/OPgYLK9b zZDfq56ipDUuE7XU36IzMYbkk627hutLB5mJtTMYW9Cqs62l699GBS5OY5HwVFajI3WLOrb2 MYxFnER5RW8iLO5+r36wjKMjOnBmXlXVGFfF0ikUzKxmx2B9OINwv12nTZuhSz6L327rYru2 3bTbrEjkZmv7EsfkZmvb5XS43S0OT6YMj7oE5n0fNmpbFdyIGDSC+sJ+t8jSfRv5inWGZ7pd nDU8vz+HwcJ2l+OQoadSQI+8KtM+i8ttZMv6KNDjNm6LY2AfE2G+bWVNnQ+4Abw1NPDeqjc8 NXrBhXgniaU/jUTsFtHSz9nK0YiDldh+UmqTJ1HU8pT5cp2mrSc3alDmwjM6DOcIPihIB8eo nuZyrB3Z5LGqksyT8EktsGnNc1meqW7m+ZC8urIpuZaPm3Xgycy5/Oiruvv2EAahZ8CkaJXF jKep9ETXXwdvi94A3g6mNrJBsPV9rDazK2+DFIUMAk/XU3PDAa7as9oXgEi5qN6Lbn3O+1Z6 8pyVaZd56qO43wSeLq82wUoKLT3zWZq0/aFddQvP/N0IWe/TpnmE5fXqSTw7Vp65Tv/dZMeT J3n99zXzNH8LfjqjaNX5K+Uc74Olr6luzcLXpNWPv7xd5FpskalbzO023Q3Otr1MOV87ac6z KmiF9aqoK5m1niFWdJLu+TEdevJUxEG02d5I+NbspmUSUX7IPO0LfFT4uay9QaZaZPXzNyYc oJMihn7jWwd18s2N8agDJFRdwskE2ApQotc7ER0r5F6Q0h+ERLaZnarwTYSaDD3rkr7pfQTT PtmtuFslzMTLFdo90UA35h4dh5CPN2pA/521oa9/t3K59Q1i1YR69fSkruhwsehuSBsmhGdC NqRnaBjSs2oNZJ/5clYjByJoUi361iNqyyxP0S4DcdI/Xck2QDtczBUHb4L4FBFR+GUxppql p70UdVB7pcgvvMluu1752qOW69Vi45luPqbtOgw9negjOR1AAmWVZ/sm6y+HlSfbTXUqBunb E3/2INGTsOGoMZPO8eO4X+qrEp2ZWqyPVPuaYOkkYlDc+IhBdT0wTfaxKgUY28AnkgOtNzKq i5Jha9h9IdCrw+HCKOoWqo5adAw/VIMs+ouqYoFVq82tW7HdLQPnuH8i4WG2/1tzTu/5Gi4k NqrD8JVp2F001AFDb3fhyvvtdrfb+D41iybkylMfhdgu3Ro81rZRghED4wNKVk+d0msqSeMq 8XC62igTw8zjz5pQYlUDB3a2Dd3pgk+q5XygHbZrP+xYcLiwGp8k4BYEk3GFcKN7TAV+Djzk vggWTipNejzn0D887dEoWcFfYj2phMH2Rp10daiGZJ062RmuN25EPgRgm0KRYASMJ8/sjXYt 8kJIf3p1rOawdaT6XnFmuC1yGzHA18LTwYBh89bcb8FPCDvodM9rqlY0j2CWkeucZg/OjyzN eUYdcOuI54xA3nM14l7ci6TLI24i1TA/kxqKmUqzQrVH7NR2XAi8b0cwlwZoztzvE16tZqiB 5hLC0uGZtjW9Xt2mNz5aGybRA5Kp30ZcQO/Q3/OUwLMZp2qHa2GmDmjLNUVGD4I0hOpGI6ja DVLsCXKw/ciMCBUONR4mcKkl7fXEhLcPuQckpIh9mTkgS4qsXGR6lXMaFYGyf1R3oMNiW0PB mdU/4b/Y/4KBa9GgC1SDimIv7m17oUPgOEMXnAZVUg+DIiXCIVbjHoUJrCBQUHI+aGIutKi5 BCswjClqW41qKLm+q2a+MGoQNn4mVQc3HbjWRqQv5Wq1ZfB8yYBpcQ4W9wHDHApzQjRpcXIN O3ny5HSXjDuy359enz69Pb+6qqbISMXF1mQenEG2jShlrs2VSDvkGIDDepmjg7/TlQ09w/0+ I95Cz2XW7dRy2dp21cZXgx5QxQanTOFqbbek2hmXKpVWlAlSHNJ2IFvcfvFjnAvkjix+/Ah3 iLYho6oT5q1gji9hO2FsdaDR9VjGIGLY91cj1h9tXcTqY2UPqcxWZKcqcGV/tJ9QGcu6TXVG NlAMKpF8U57Bgpjd5JNCiRdVO+smf3QbME/UvkM/UsWuV9TSUmgzHLrryefXL09fGZtMpmV0 3DEyWWmIbWiLrhao4q8b8J2RJtp7O+qWdrgDtNE9zzmFQQnY72FtAulO2kTa2YqHKCFP5gp9 7LXnybLRBmDlL0uObVQfz4r0VpC0g3U9TTxpi1INl6ppPXkzFtf6CzZCa4eQJ3gpmDUPvhYC j/N+vpGeCk6u2PqXRe3jItxGK6S1iFpb5r44PZlow+3WE1mF9DApA4OiAltWZ08gx+4mqv12 vbKvI21OTXr1KUs9fQmu7tExGk5T+rpa5vaD6mAbJdUDtXz5/ncIf/fTjFjtuNLRgB2+BwlA xbAI3DE6U95RNgUJblDer8cpAyzC9GAXC1uqGSPCZhVs1J8vzdaJW8WGUe0u3JTuj8m+L6k4 pAhiT9VGvVlwtT8J4f3StV2McDNd9MvbvDOdjKwvVaL4aKN9a+9XKOONsRBdhK3+2rhbMUhT c8a88UM5c3SHQYh3v5zn54DW1kntUNyOYGDrsy0fwNu0hvaulQPPrVsnCbNRFDKz0Uz5eyPa Nlmg+8UoyGE/4cMnH2xpZWxPHvPmRdscPiLX0JTxV2B2yC4+2P9VHJedO8Ub+MZXwTqTm47e B1D6xodoa+qwaJs6Dqus2KdNIpj8DMYofbh/MjTbsQ+tOLKCAOH/bDyzxP9YC2bJGoLfSlJH o6YDI8LQGcsOtBfnpIFzvyBYhYvFjZC+3GeHbt2t3dkInCeweRwJ//zWSSU0c59OjPfbwcZi Lfm0Me3PAejG/rkQbhM0zOLYxP7WV5ya90xT0emyqUPnA4XNE2UUEhbcdOU1m7OZ8mZGB8nK Q552/ihm/sa0WCqJv2z7JDtmsdr+uAKbG8Q/YbRK4mYGvIb9TQTXTUG0cr+rG1feA/BGBpDB dRv1J39J92e+ixjK92F1dZcHhXnDq0mNw/wZy/J9KuBoW9JTLsr2/ASCw8zpTOcsZEtLP4/b JicK2gOlnyue3TkPcP2VEjDxeQRsv+tGbWTvOWx45DuddmjU3j3kzDJV1+gd1ukSO27ZAUOb NwA6W3VzAJgjZB1fbHVn45LezUdWFxmooCY5OrsHFLYm5DG5wQX4bdEvX1hGtg06Q9LUYFpH 18wBP9AE2j5mMYCSCgh0FW18Sioasz7Frg409H0s+31hm9sz+2nAdQBElrW2C+1hh0/3LcMp ZH+jdKdr34CznYKBtIfDJquKlGWHvTZHac28vimPyMrBzOOd84ybXsDGqGR1FV/McSd0Cjbj xIz4TJCpbCbIXmwmqEF16xN70M1w2j2Wtr0tq+x1m7K5gja22rSuwb/jtPE2JgfuPvnPaKcD Q/s0CWygFKLsl+j+Z0Zt5QgZNyG6iapHU5/2vObNyPgZvPOncwUYHtB4epH2yWsbq//VfOez YR0uk1R5xqBuMKzRMYDweobs923KfYFss+X5UrWUZGJD8x8AF1UO0FvvHjF+ABz1hCnzbRR9 rMOlnyHKNZRFpVc1jhcLJf7lj2h9GRFi+mKCq4Pd/u4twdzwpuGas5JK9lXVwomv7gXm4W4Y M2+l0d2jqmj9Xk61RYVhUCq0T1U0dlJB0WthBRpHDcbg/x9f3778+Pr8H5VXSDz+/csPNgdK /tybixwVZZ6npe2bboiUrNUzijxDjHDexsvIVlUdiToWu9Uy8BH/YYishFXfJZBjCACT9Gb4 Iu/iOk/strxZQ/b3pzSv00Yf4+OIyXM0XZn5sdpnrQuqItp9Ybqk2v/x02qWYba7UzEr/PeX n293n16+v72+fP0Kfc558K0jz4KVvRJN4DpiwI6CRbJZrR1si2wg61owHnYxmCHtbI1IpKek kDrLuiWGSq0ERuIynvtUpzqTWs7karVbOeAaWQQx2G5N+iPyrjMA5mnBPCz/+/Pt+dvdP1WF DxV899dvqua//vfu+ds/nz9/fv58948h1N9fvv/9k+onfyNtQBywaKzraNqO0DCAVJlfw2DZ s91jMFZTCnLgrUGYptwBmqQyO5baXiFeOAjpet4iAWSO3IHRz+3DPODSA5IvNKREITIk0iK9 0FBaaiC145ZLT1XGDmBWfkhjrI4GPbA4UqBzACX3O7Pvh4/LzZb0qfu0MNOGheV1bD/K1FMM lp001K6xIqLGNuuQzn+X9bKjAUslJCYZSaQiz+Q1hs1hAHIl05+aeTyNXHfCAbjmZs4VNXwm STdZRqq0uY9IyeSpL9QMmZMkZFYg1WqNoW26RkB2PSw5cEPAc7lW24/wSvKs5MSHM7ZUDjA5 o5+gfl8XpJDuBZSN9geMg8Ej0TrFHeztkLqhrq40ltc72juaWEyCRfofJY18V3ttRfzDLBtP n59+vPmWiySr4DX1mXb+JC/JeKwF0XexwD7Hr0V0rqp91R7OHz/2Fd4fQnkFGBO4kP7XZuUj eWytZ+gaLBEZRQRdxurtd7NGDwW0pmpcuMFmAbjaLFMyDPSGCAxdFehpGVAfu3C3Jh3ooLdV s+KIb83GPfG8/+UbQtzBpCHHhKmZVcEqGTdZAw5CBIcbEQRl1MlbZDV2nJQSELUtwZ5IkysL 47P02jGuCBDzTW8rONTZXfH0E/pkPEszjvka+MocOOOYRHuyH6BqqCnAc1OEPImYsPhOU0O7 QPUyfA4HeJfpf43LXsw5K7UF4vt1g5PrgxnsT9KpQFjxH1yUul/T4LmFU4v8EcOOHKBB915U t9a4VBP8SnQ1DFZkCbkkG3Ds7Q5ANGHoiiRGdPRjb33k7BQWYDUPJw4B10ZwuOwQ5LRQIWqd V/8eMoqSHHwgd0wKyovNos9t0/YarbfbZdA3thuIqQhI52IA2VK5RTK32eqvOPYQB0oQ0cFg WHTQlVWrnnSwXW5OqFvlYF8ke+ilJIlVZh4moBIrwiXNQ5sx/VarewSLxT2BiQN0BakaiEIG 6uUDibPOFyEN2YmQ5sdgbj92Haxq1Mm6lmvcEiG5ZgpH7lUVLKN47dSRjIOt2pssSPZB7JFZ daCoE+rkZMe5mQVMLyJFG26c9PHdxoBgqyMaJTcaI8TUh2yh1ywJiJ8dDdCaQq64pTtzl5Fe qKUt9GJ3QsNFLw+5oHU1cfh5gqYc6Uqjag+eZ4cD3D8SpuvI+sJoGSm0w/7KNURENo3RmQVU zaRQ/2D3vkB9VBXEVDnARd0fB2ZaRevXl7eXTy9fh+WULJ7qf+hISA/7qqrB/qP2uzMLJ7rY eboOuwXTs7jOBufhHC4f1dqvdRLapkJLL9L3gbN50F0ABXQ4cpqpEzrAlhk6BTOq2jKzjkF+ juckGv765fm7rboNEcDZ2BxlbVuOUj+wNUMFjJG4x2MQWvWZtGz7e30fgCMaKK3lyTKOCG1x w4I2ZeK35+/Pr09vL6/ueVBbqyy+fPoXk8FWzb0rsCydV7ZxIoz3CXIGiLkHNVNb91jglHK9 XGDHheQTM4DmQ3Enf9N39Dhu8Nk9Ev2xqc6oebISHSla4eEU73BWn2F1VohJ/cUngQgjLjtZ GrMiZLSxF50Jh0dHOwYvEhfcF8HWPkIY8URsQTn2XDPfOKqQI1HEdRjJxdZl3AVuYj6KgEWZ kjUfSyaszMojugwd8S5YLZhcwrNVLvP6VV/I1IV5OuXiju7mlE945eTCVZzmtj2rCb8yrSvR TmFCdxxKT/Mw3h+XforJ5kitmd4CG4qAa3pn/zFVkr5cxMLwyA0OcdEAGjk6ZAxWe2IqZeiL puaJfdrktoEIe1QxVWyC9/vjMmZaEMnwFqiEqzNLbO1lGeFMljT+wOMPnngeOmasaS0Opshm byrq7YJp84GNa2T6h7DRhusUwz04M6LsczwLDFd84HDDDVjJlF3UD6oUXIcHYssQWf2wXATM fJn5otLEhiFUjrbrNVNLQOxYApyOBsywgS86Xxq7gGknTex8X+y8XzCz9UMslwsmJr2t0IIR to6Jebn38TLeBNxiI5OCrTaFb5dM5ah8o2fkE07VpUeC3u9jHDrxLY7rA2rjUx+4ImrcM0sp EgQCDwvfkVsGm2q2YhMJJisjuVlya9dERrfIm9EyLTCT3GQ5s9zaPrPxrW83TMecSWa8TuTu VrS7Wzna3aj7ze5WDXIDbyZv1SA3Mi3y5qc3K3/HDbWZvV1LvizL0yZceCoCOG6sTJyn0RQX CU9uFLdhZbKR87SY5vz53IT+fG6iG9xq4+e2/jrbbD2tLE8dk0t8JmKjag7dbdm5Eh+PIPiw DJmqHyiuVYYbqiWT6YHyfnViZxpNFXXAVZ+asruMhZdZLzihQ1Er/ou1+iLi9ggj1TcsuVUk 110GKvJT24iRB2fuZnp+8uRN8HTjq0vErHGK2kFe+Ho0lCfK1UKx7Oo3cTe+PHEr90BxHWuk uCjJdSeCA24sm8M2rvOYb7j52lygdtjX38hlfVYlaW7bYB859+yNMn2eMOlNrNoi3aJlnjBr of01U9Mz3UlmXrBytmaKa9EBM5wsmpuc7bShIxv9rufPX57a53/d/fjy/dPbK/N8OM3KFmto TpKqB+yLCt2V2FQtmowZDnAEvWCKpK8rmFGncWayK9ptwO13AQ+ZWQ7SDZiGKNr1hlvkAd+x 8aj8sPFsgw2b/22w5fEVu41o15FOd1Y78zUc/fQjs0kzN9UB03+JBgqC+2O3Z3rlyDHHJZra qn0Ht1HUn4mO2RhM1K0vj0HIzD15FZ9KcRTMsC9AkZL5RG2rNjm329ME15s0wckVmuBEOENY HQQ2G+g2cAD6g5BtLdpTn2dF1v6yCqaHOdWBbFHGT7LmAZ/imSNKNzAcstveojQ2HHQSVDv/ WMxqoM/fXl7/e/ft6ceP5893EMKdKPR3m2XXkVtejdMLeQOSEzID4mt6Y3/IMkya2mcoxpxW XPT3VUljd1TfjHYqvfM2qHPpbaxxiYtqwIyiV1HTaNOMKhoZuKAAsl9glNBa+Ac98LYbhlG6 MnTDNPApv9IsZBWtL+ekeETx41XTD/bbtdw4aFp+RPOpQWviZcWg5MbZgPjMy2Ad7YR1vljT L/XFj6e2B4Um1ONFIVZJqAZi5SQos4pmVpZws4K0gg3uJqaGad8h7y/jEIvtGVSDRFCascDe gRiYWMc0oHMTqWFXxDF24rrtakUw8o5jxnpJuzK9izRgTnsR3C1SiH4liqQ/4FueGzPJpEqr 0ef//Hj6/tmdYRxnUjaKH1MNTEmzfrz2SBvTmvFozWs0dPq0QZnUtAp6RMMPKBsejLjR8G2d xeHWmRFU3zA3DUhNi9SWma8PyZ+oxZAmMJiRpBNpslmsQlrj+2S32gTF9UJwapF9BmmfxKo/ Gvogyo992+YEpuqzw4QV7exd7QBuN071A7ha0+SpPDC1LL5vsuAVhekd1DALrdrVlmaMmF41 7UndMBmUeWE+9Aowl+rOGIPBQw7ert2upeCd27UMTNujfSg6N0HqBGpE1+gplJmiqMlujVJz 2xPo1PB1PD6fJxC3aw/PHbJ3ujx9jmBaNu/2BwdTq+aJtnXsImr7mag/AlpD8AjIUPYu2PSO RC2zuuzWazAn55Omxs0SKWErWNMEtPWOnVO7ZnpzSh9HEbppNtnPZCXpqtKp1Wq5oN26qLpW +1CZ3+y6uTa+FOX+dmmQwu4UHfMZyUB8bytaXW2/zdq0zSjDBn//95dB69ZRe1EhjfKpdqBn iwUzk8hwacv2mNmGHINkGvuD4FpwBBbpZlwekRoxUxS7iPLr0/9+xqUblG9OaYPTHZRv0PPU CYZy2VfmmNh6CfA7n4C2kCeEbRkcf7r2EKHni603e1HgI3yJR5GS/GIf6Skt0mWwCfQEBBOe nG1T+3YPM8GGaf6hmccv9CPpXlxsh+uDggecklWFQDfrOnSTStsDkgW6iiwWB1srvOOiLNp4 2eQxLbKSe9GNAqFhQBn4s0V62HYI/JLZZvDVtEXoG9K64mtnUBC5VVX6ado7RcrbONytPPV5 s0AXtePFjgJtlgj2NgUGntvKx9KNisu9U6KGPsCxSXsr0KTwkJXYix6SYDmUlRgrp5Zg8vDW Z/Jc17aiu43SRweIO10LVB+JMLy14g07cpHE/V6ASr2VzmhgnHwzGDKG2RAtUwZmAoOCF0ZB 5ZJiQ/KMty7QWjzCRKAkfLR9Hj8RcbvdLVfCZWJsXHmEYdKyL7dsfOvDmYQ1Hrp4nh6rPr1E LgOmZF3U0fAaCeqpZcTlXrr1g8BClMIBx8/3D9AFmXgHAj/ApuQpefCTSdufVUdTLYydaE9V Bq6vuComm6yxUApHOhhWeIRPnUSbQmf6CMFHk+m4EwKq9tyHc5r3R3G2X3yPEYHvpQ3aFhCG 6Q+aCQMmW6P59QK5vhkL4x8Loxl1N8amWwVueDIQRjiTNWTZJfTYt2XjkXC2SiMBW1L7AM3G 7cONEccr4pyu7rZMNG205goGVbtERjGnnqMtiVZDkLX9ltv6mGyCMbNjKmDwrOAjmJIadaXC vmkYKTVqlsGKaV9N7JiMARGumOSB2Nhn+xah9uRMVCpL0ZKJyezKuS+GjfnG7XV6sBiRYMlM lKNNYKa7tqtFxFRz06oZnSmNfsmotlC2wvBUILWy2lLyPIydRXf85BzLYLFg5h3niIgspvqn 2uElFBoeK5rrC2Md9enty/9+5swYg4l3CU5QIvTAY8aXXnzL4QU4h/QRKx+x9hE7DxHxaexC ZDdmItpNF3iIyEcs/QSbuCLWoYfY+KLacFWC9XJnOCbPzEYCDMnG2IKrzdQcQ26JJrztaiaJ RKLjuxkO2BwNzisENkVrcUyps9U9mM91iQNoUq4OPLEND0eOWUWblXSJ0esMm7NDK9v03ILg 4JLHfBVssc3PiQgXLKHkO8HCTC8xl1aidJlTdloHEVP52b4QKZOuwuu0Y3C4ysIzyES1242L foiXTE6VuNIEIdcb8qxMhS2vTIR7fzxRerpmuoMmdlwqbazWK6bTAREGfFTLMGSKoglP4stw 7Uk8XDOJa3eY3LwAxHqxZhLRTMBMcJpYM7MrEDumofTp5IYroWLW7AjVRMQnvl5z7a6JFVMn mvBni2vDIq4jdpko8q5Jj/xAaGPk82z6JC0PYbAvYl/nVmO9Y4ZDXtg2eGaUm3oVyofl+k6x YepCoUyD5sWWTW3LprZlU+NGbl6wI6fYcYOg2LGp7VZhxFS3Jpbc8NMEk8U63m4ibjABsQyZ 7JdtbE5VM9lWzKRRxq0aH0yugdhwjaIItatmSg/EbsGU03nQMRFSRNzsV8VxX2+p8WOL26mN MDM5VjHzgb7BRPrbBbG8OYTjYRCRQq4e1NrQx4dDzXyTlbI+q+1YLVm2iVYhN2IVgZ+OzEQt V8sF94nM19sgYvttqLaUjDCoVwN2BBlidm/GBom23LowTM3cnCK6cLHhFhkzp3EjEZjlkhM/ YVe23jKZr7tUrQDMF2qTs1S7eKa/KmYVrTfMxH2Ok91iwUQGRMgRH/N1wOHg0oydgW2NIc9k K08tV9UK5jqPgqP/sHDMhabGxiaRskiDDdefUiXvoes1iwgDD7G+hlyvlYWMl5viBsPNrobb R9z6KOPTaq1NmBd8XQLPzY+aiJhhIttWst1WFsWak0HU2hiE22TL7+XkZhv6iA23EVGVt2Un iVKgd7o2zs2xCo/Y2aaNN8xwbU9FzEkmbVEH3KSvcabxNc4UWOHsRAY4l0v3cmFiMrHerpld waUNQk58vLTbkNvrXrfRZhMxWx8gtgGzswNi5yVCH8FUk8aZzmRwmDpAPZPlczV1tky9GGpd 8gVSg+DE7P8Mk7IU0YWwca6nkAsfLXyI3AHUABOtEkqQY8CRS4u0UdGAL6/hiqfXWvR9IX9Z 0MBk+hxh2wjJiF2brBV77cosq5l0k9RY3DtWF5W/tO6vmTQGv28EPIisMX6Q7r78vPv+8nb3 8/nt9ifgPq6XtYj//CfD7WmuNoCwNtvfka9wntxC0sIxNFho6rGZJpues8/zJK9zoLg+ux3C GFtw4CS9HJr0wd+B0uJsnNG5FFbw1Y4mnWjgobUDjupVLqPtR7iwrFPRuPB0se0yMRseUNXj I5e6z5r7a1UlTA1Vo8qEjQ5vq93Q4M00ZIrc2pVvdBy/vz1/vQNrdN+QwzZNirjO7rKyjZaL jgkzKQHcDjd7KuSS0vHsX1+ePn96+cYkMmR9MB/glmm44WeIuFC7Dh6XdrtMGfTmQuexff7P 009ViJ9vr39808ZVvJlts15WMdOdmb4JxqaYrgDwkoeZSkgasVmFXJnez7XR73r69vOP77/5 izQ8dmZS8H06FVrNLRXtdsYyrsrdb69PN+pRv7dSVUmUhWZDllyGbsY9RmHfn5O8Pfzx9FX1 ghudUd8LtbAKWpPG9PS9TVW+RG7ejE+58sY6RmAewrhtO72VchjXQ8GIEJOLE1xWV/FY2b6f J8o4ZdB2vvu0hJUzYUJVdVpqu0kQycKhx0cduh6vT2+ffv/88ttd/fr89uXb88sfb3fHF1Xm 7y9I3238WAl/Q8ywsjCJ4wBKCsln60++QGVlvznwhdKeJOzFnwtoL9EQLbMuv/fZmA6un8Q4 b3WtR1aHlmlkBFspWVOcuQJjvh2uGDzEykOsIx/BRWWUZW/D4CLopDYsWRsL23XYfCzpRgAv PRbrHcPoKabjxoNRbeGJ1YIhBm9KLvExy7SjapcZ/VczOc5VTInVMPpmqQYP525gze2l4KnR hgrHymIXrrnCgJ3QpoBjDA8pRbHjojRPVZYMM7xZYphDq4oKDiBd6qRrKIrDJUv7meTKgMYo J0Nou40uXJfdcrHgR4N+U8W1ablq1wH3jX6MzuCjSxemdw6aIkxcaiscge5N03Id3ry/YYlN yCYFlwp83UzSLuPWpuhC3E2NYSIH25zzGoNq7jlziVUdeNJCQWXWHEAo4moBHnxxxdTLvIvr pRZFPr8JZecNIDlciQltes91jMl/l8sNT9bYEZULueF6kxI2pJC07gzYfBR4jjDWtZgZyAgI XAXCS7SAYSbZgclTmwQBP/jBigQzjLRZIa7YeVZsgkVA2jteQW9DXWgdLRap3GPUPKghdWNe JmBQCe5LPcIIqPcFFNSvMP0o1b5U3GYRbWmXP9YJGQZFDeUiBdMG79cUVJKSCEmtgPssBJyL 3K7S8fnI3//59PP58ywixE+vny3JQIWoY2ZVS1pjOXZ85fBONKCNw0QjVRPVlZTZHrlas1/n QRCJ7X0DtIf9PbJqDFHF2lkvH+XIkniWkX7Ssm+y5Oh8AA6LbsY4BiD5TbLqxmcjjVH9gbRd WQBq/CFBFrVfVD5CHIjlsCqd6oSCiQtgEsipZ42awsWZJ46J52BURA3P2eeJAh2rmbwTo7Ya pJZuNVhy4FgphYj72LZzh1i3ypD1U+0D59c/vn96+/LyffBp5O7gikNC9kiADL5B1S6mODaE cjSVNSqjjX3+PGLosYI2D0vfOOqQog23mwWXEcbAu8HBIzVYE4/toTdTpzy2dXRmQhYEVjW3 2i3sawSNui8pTenRlZeGiFrujOHLXAtv7BlEt8Dg3ACZ+AWCvoecMTfyAUcGh3Xk1JbCBEYc uOXA3YIDaeNqzeiOAW21aPh82H05WR1wp2hU6WvE1ky8tlrGgCE1a42hV66ADMc6OfbKq6s1 DqKOdo8BdEswEm7rdCr2RtBOqUTOlRJjHfyUrZdqzcTWAQditeoIcWrBfYfM4ghjKhfojS6I l5n9ZhIA5NUJktAPfuOiSuwJBgj65BcwreBNx4QBVwy4pkPF1X4eUPLkd0ZpYxrUfhE7o7uI QbdLF93uFm4W4O0IA+64kLbatAZH6zA2Nm7qZzj9qF2k1Thg7ELoJaaFw84DI65i/YhgvcUJ xSvJ8DqYmYxV8zkDQW9BmprMwYzlS53X6Z2tDRL1aY3R59oavN8uSCUPu1OSeBozmZfZcrOm Xsk1UawWAQORatH4/eNWddaQhpaknEZVm1SA2Hcrp1rFPgp8YNWSLjA+VzcH1W3x5dPry/PX 509vry/fv3z6ead5fbvw+usTe44GAYiKkYbMNDafZP/5uFH+jGOmJqa9gbxqA6zNelFEkZrJ Whk7sx81I2Aw/ApjiCUvaPcn7/9B4z9Y2C8UzOsAW3HGIBvSM923/TNKF0T3XcGYP2L8wIKR +QMrElpIx2jAhCKbARYa8qi7Kk2Ms5ApRk3rtu7AeHzjDqGREWe0ZAzWB5gPrnkQbiKGyIto RScDzvaCxqmlBg0S4wh66sS2V3Q6rkqxls+orQ0LZKS5geAlLtvKgC5zsULaJCNGm1BbV9gw 2NbBlnTdpXoLM+bmfsCdzFMdhxlj40CGlM0sdV1unUm+OhVwGo9tHNkMfqoyTHdRqAYK8c4w U5qQlNFHQE7wA0l21LGByQmZFhoPsYe+iV2K+rZT08euGuEE0ZOWmThkXapyVOUtUn+fA4D7 6LMwXuLPqDLmMKCfoNUTboZSMtgRTSWIwoIcoda2gDRzsB/c2hMZpvBW0eKSVWT3aIsp1T81 y5htIkvpJZNlhkGaJ1Vwi1e9Bt4cs0HI5hYz9hbXYsiucGbc/abF0XGAKDx4bMrZq84kESWt 7kg2a5hZsaWi+zDMrL3f2HsyxCC7o4Rha/wgylW04vOABbYZN3spP3NZRWwuzFaLYzKZ76IF mwnQTg43Advp1eq25qucWY8sUklDGzb/mmFrXb9l5ZMiAglm+Jp1pBVMbdkem5sF2ketN2uO cveDmFttfZ+RDSPlVj5uu16ymdTU2vvVjp8PnW0jofiBpakNO0qcLSel2Mp3N8WU2/lS2+Cn DhY3nG1gsQ3zmy0fraK2O0+sdaAah+fUJpqfB4AJ+aQUs+VbjWzJZ4buGSxmn3kIz7Tq7r4t 7nD+mHrWqfqy3S743qYpvkia2vGUbc1oht0Nu8udvKQskpsfY89gM+ls6C0Kb+stgm7uLYqc GcyMDItaLNguA5Tke5NcFdvNmu0a9EW2xTinARaXH5W0z7e0EV73VYUdq9IAlyY97M8Hf4D6 6vmaSMA2pUXz/lLYR1AWrwq0WLNLl6K24ZJdNuBNSbCO2HpwN9+YCyO+y5tNNj/A3c065fhp z924Ey7wlwFv7R2O7aSG89YZ2dMTbscLRu7+HnFkx25x1OaFtXFwDJZaGw+siW8RzhOFmaOb UMzwyzDdzCIGbTFj53QPkLJqswMqBKC1bVyrod814BDZmsPzzLY0tq8PGtH2jEL0VZLGCrN3 nlnTl+lEIFzNfB58zeIfLnw8siofeUKUjxXPnERTs0yhton3+4TluoL/JjOmIbiSFIVL6Hq6 ZLH9GF5hos1U4xaV7bVQxYGeT2QgenerUxI6GXBz1IgrLRp2O67CtWpTnOFMH7KyTe/xl9jM OiAtDlGeL1VLwjRp0og2whVvn6nA77ZJRfHR7mwKvWblvioTJ2vZsWrq/Hx0inE8C/tsSkFt qwKRz7H1HF1NR/rbqTXATi6kOrWDqQ7qYNA5XRC6n4tCd3XzE68YbI26zujuFAU0lsJJFRjb px3C4FWiDTXg0x23EvauAkjaZOj5xAj1bSNKWWRtS4ccyYlWyESJdvuq65NLgoLZltm0Npa2 f2bci86X+d/AvcDdp5fXZ9dbqPkqFoW+Ap4+RqzqPXl17NuLLwBoe7VQOm+IRoABVQ8pk8ZH wWx8g7In3mHi7tOmge10+cH5wLijzdGhIGFUDe9vsE36cAYDbsIeqJcsSSt8BW+gyzIPVe73 iuK+AJr9BB2XGlwkF3oOaAhzBlhkJUi3qtPY06YJ0Z5Lu8Q6hSItQjC9hzMNjFYr6XMVZ5yj K23DXktkpU+noIRNeA3AoAlor9AsA3Ep9IMnzydQ4ZmtTHjZkyUYkAItwoCUtk3HFjS5+jTF Olb6Q9Gp+hR1C0txsLap5LEUoHug61Piz5IU3M3KVHubVZOKBAMjJJfnPCXKNHroudozumOd QWkKj9fr8z8/PX0bjomxotnQnKRZCKH6fX1u+/SCWhYCHaXaeWKoWCGf5Do77WWxtk8L9ac5 8oc1xdbvU9ts/IwrIKVxGKLObH91M5G0sUQ7s5lK26qQHKGW4rTO2HQ+pKCF/oGl8nCxWO3j hCPvVZS291GLqcqM1p9hCtGw2SuaHRh5Yr8pr9sFm/HqsrJNsyDCNotBiJ79phZxaB82IWYT 0ba3qIBtJJmi58gWUe5USvb5M+XYwqrVP+v2XoZtPvjPasH2RkPxGdTUyk+t/RRfKqDW3rSC lacyHnaeXAARe5jIU33t/SJg+4RiAuQ6yabUAN/y9XculfjI9uV2HbBjs63U9MoT5xrJyRZ1 2a4itutd4gVyz2AxauwVHNFl4DT4Xkly7Kj9GEd0MquvsQPQpXWE2cl0mG3VTEYK8bGJ1kua nGqKa7p3ci/D0D4xN3Eqor2MK4H4/vT15be79qKtpjsLgvmivjSKdaSIAaYugjCJJB1CQXVk B0cKOSUqBJPrSybR02JD6F64Xjh2JhBL4WO1Wdhzlo32aGeDmLwSaBdJP9MVvuhHPSirhv/x +ctvX96evr5T0+K8QEYpbJSV5AaqcSox7sIIOfhGsP+DXuRS+DimMdtijQ4SbZSNa6BMVLqG kneqRos8dpsMAB1PE5ztI5WEfYg4UgJdIVsfaEGFS2Kkev068NEfgklNUYsNl+C5aHuk4TMS cccWVMPDBsll4eVYx6WutksXF7/Um4VtycrGQyaeY72t5b2Ll9VFTbM9nhlGUm/9GTxpWyUY nV2iqtXWMGBa7LBbLJjcGtw5rBnpOm4vy1XIMMk1RIouUx0roaw5PvYtm+vLKuAaUnxUsu2G KX4an8pMCl/1XBgMShR4ShpxePkoU6aA4rxec30L8rpg8hqn6zBiwqdxYJvpm7qDEtOZdsqL NFxxyRZdHgSBPLhM0+bhtuuYzqD+lffMWPuYBMghCeC6p/X7c3K092Uzk9iHRLKQJoGGDIx9 GIeDwn7tTjaU5WYeIU23sjZY/wOmtL8+oQXgb7emf7Vf3rpztkHZ6X+guHl2oJgpe2Ca6YWz fPn17d9Pr88qW79++f78+e716fOXFz6juidljayt5gHsJOL75oCxQmahkaIndy6npMju4jS+ e/r89AM7VNHD9pzLdAuHLDimRmSlPImkumLO7HBhC05PpMxhlErjD+48ahAOqrxaI9O5wxJ1 XW1tw2kjunZWZsDWHZvoP54m0cqTfHZpHYEPMNW76iaNRZsmfVbFbe4IVzoU1+iHPRvrKe2y czE40vCQVcMIV0Xn9J6kjQItVHqL/I/f//vP1y+fb5Q87gKnKgHzCh9b9OzDHBeaR0CxUx4V foXsdCHYk8SWyc/Wlx9F7HPV3/eZre5uscyg07gx2KBW2mixcvqXDnGDKurUOZfbt9slmaMV 5E4hUohNEDnxDjBbzJFzJcWRYUo5Urx8rVl3YMXVXjUm7lGWuAy+roQzW+gp97IJgkVvH2rP MIf1lUxIbel1gzn34xaUMXDGwoIuKQau4d3mjeWkdqIjLLfYqB10WxEZIilUCYmcULcBBWz1 ZVG2meQOPTWBsVNV1ymp6RIbFtO5SOhjUBuFJcEMAszLIgMHaCT2tD3XcAHMdLSsPkeqIew6 UOvj5Ph0eIXoTJyxOKR9HGdOny6KerieoMxlurhwIyN+YRHcx2r1a9wNmMW2DjtaOrjU2UEJ 8LJGfsqZMLGo23Pj5CEp1svlWpU0cUqaFNFq5WPWq15tsg/+JPepL1tg1SHsL2BK5dIcnAab acpQY+3DXHGCwG5jOFBxdmpR22piQf52o+5EuPkPRbXGkGp56fQiGcVAuPVkNF8SZK3eMKMV gTh1CiBVEudyNN207DMnvZnxnXKs6v6QFe5MrXA1sjLobZ5Y9Xd9nrVOHxpT1QFuZao21yl8 TxTFMtoo4bU+OBT1GmujfVs7zTQwl9Ypp7bVBiOKJS6ZU2HmsW0m3RuwgXAaUDXRUtcjQ6xZ olWofT0L89N0I+aZnqrEmWXAyMclqVi8th1bD8NhtJbxgREXJvJSu+No5IrEH+kF1CjcyXO6 5wO1hSYX7qQ4dnLokcfQHe0WzWXc5gv3xBAso6RwU9c4Wcejqz+6TS5VQ+1hUuOI08UVjAxs phL34BPoJM1b9jtN9AVbxIk2nYObEN3JY5xXDkntSLwj98Ft7Omz2Cn1SF0kE+NoQ7E5uud6 sDw47W5QftrVE+wlLc/uZTJ8lRRcGm77wThDqBpn2v+ZZ5BdmInykl0yp1NqEO83bQIueJP0 In9ZL50EwsL9hgwdI8b5xBV9Gb2Fa2A0cWrtg/dknOG1PpNxY2JHVH7uGITCCQCp4tcL7qhk YtQDRe33eQ5WSh9rLAq5LKhwvFd8PeUr7jBuKKTZgz5/viuK+B9gPoQ5fICDIaDwyZDRJ5lu 8QnepmK1QcqjRv0kW27oVRrFsjB2sPlregtGsakKKDFGa2NztGuSqaLZ0ivORO4b+qnq55n+ y4nzJJp7FiRXVvcp2iaYAx04uS3JrV4hdkg5eq5me9eI4L5rkdVWkwm10dws1if3m8N6i94B GZh5wmkY8xJ07EmukU7gt/+5OxSD8sXdX2V7p435/G3uW3NUW+TE+f9ddPb0ZmLMpHAHwURR CDYeLQWbtkEqazba6/O0aPErRzp1OMDjR5/IEPoIJ+LOwNLo8MlqgcljWqCrXRsdPll+4smm 2jstKQ/B+oC0/y24cbtE2jRK4okdvDlLpxY16ClG+1ifKltiR/Dw0awehNnirHpskz78st2s FiTij1XeNpkzfwywiThU7UDmwMOX1+cruAL+a5am6V0Q7ZZ/8xyvHLImTegN0gCaS+uZGnXY YHfSVzUoL00GRsGcKjxKNV365Qc8UXWOvuGUbxk4u4H2QnWr4kfzMlZlpLgKZ8OxPx9CcqIx 48wRusaV8FrVdCXRDKcoZsXnUzALvUpp5EacHvj4GV6G0kdqy7UH7i9W6+klLhOlmtFRq854 E3OoR87Vmnpml2ad2z19//Tl69en1/+O2mh3f33747v693/c/Xz+/vMF/vgSflK/fnz5H3e/ vr58f1Oz4c+/UaU10GdsLr04t5VMc6QtNRz/tq2wZ5RhU9QMao3GaHYY36XfP7181ul/fh7/ GnKiMqvmYbDze/f789cf6p9Pv3/5MVvV/gMuQeavfry+fHr+OX347ct/0IgZ+yuxMjDAidgs I2d7quDddunePyQi2O027mBIxXoZrBhxSeGhE00h62jp3s3HMooW7nG3XEVLR1cE0DwKXUE8 v0ThQmRxGDknPWeV+2jplPVabJHzohm1HXUNfasON7Ko3WNseGWwbw+94XQzNYmcGsm54BFi vdJH+zro5cvn5xdvYJFcwBcfTdPAznESwMutk0OA1wvniHuAOVkXqK1bXQPMfbFvt4FTZQpc OdOAAtcOeC8XQeiczRf5dq3yuOYP7d07MgO7XRQe1W6WTnWNOCvtX+pVsGSmfgWv3MEBegoL dyhdw61b7+11h5zsWqhTL4C65bzUXWT8AVpdCMb/E5oemJ63CdwRrC+hliS25+834nBbSsNb ZyTpfrrhu6877gCO3GbS8I6FV4FzHDDAfK/eRdudMzeI++2W6TQnuQ3ne+L46dvz69MwS3s1 pZSMUQq1Fcqd+ikyUdccAxZ0A6ePALpy5kNAN1zYyB17gLp6dtUlXLtzO6ArJwZA3alHo0y8 KzZehfJhnR5UXbCvwzms2380ysa7Y9BNuHJ6iULRW/8JZUuxYfOw2XBht8yUV112bLw7tsRB tHWb/iLX69Bp+qLdFYuFUzoNuys7wIE7YhRcozeQE9zycbdBwMV9WbBxX/icXJicyGYRLeo4 ciqlVBuPRcBSxaqoXGWE5sNqWbrxr+7Xwj0DBdSZXhS6TOOju9yv7ld74d6y6AFO0bTdpvdO W8pVvImKaQefqznFfScxTlmrrStEiftN5Pb/5LrbuDOJQreLTX/RFsZ0eoevTz9/905hCZgW cGoDjEy5GqtgnEPL+dbC8eWbkkn/9zOcHUyiKxbF6kQNhihw2sEQ26letKz7DxOr2q79eFWC LhgSYmMFqWqzCk/TBk8mzZ2W8ml4OK8Db4NmATLbhC8/Pz2rHcL355c/flK5m64Km8hdvItV iLyuDlOw+5hJbcnh7ivRssLs3eb/bE9gyllnN3N8lMF6jVJzvrC2SsC5G++4S8LtdgGPNIez yNnGk/sZ3hONb7DMKvrHz7eXb1/+n2fQoTB7MLrJ0uHVLq+okfEyi4OdyDZE9rYwuw13t0hk s86J17YaQ9jd1vb8ikh97uf7UpOeLwuZoUkWcW2IjewSbu0ppeYiLxfa4jfhgsiTl4c2QMrB NteRFzCYWyFVbMwtvVzR5epD26G4y26cDfjAxsul3C58NQBjf+2obtl9IPAU5hAv0BrncOEN zpOdIUXPl6m/hg6xkhB9tbfdNhJU2j011J7FztvtZBYGK093zdpdEHm6ZKNWKl+LdHm0CGxV TNS3iiAJVBUtPZWg+b0qzdKeebi5xJ5kfj7fJZf93WE8zhmPUPS74J9vak59ev1899efT29q 6v/y9vy3+eQHHznKdr/Y7izxeADXjvY1vDDaLf7DgFT1S4FrtYF1g66RWKT1nlRft2cBjW23 iYyMR02uUJ+e/vn1+e7/e6fmY7Vqvr1+AR1fT/GSpiOK9ONEGIcJ0UyDrrEm6lxFud0uNyEH TtlT0N/ln6lrtRddOnpyGrQNm+gU2iggiX7MVYvYTlpnkLbe6hSgw6mxoUJb53Js5wXXzqHb I3STcj1i4dTvdrGN3EpfIDMsY9CQqrZfUhl0O/r9MD6TwMmuoUzVuqmq+DsaXrh923y+5sAN 11y0IlTPob24lWrdIOFUt3byX+y3a0GTNvWlV+upi7V3f/0zPV7WW2QTccI6pyCh81TGgCHT nyKq+9h0ZPjkat+7pU8FdDmWJOmya91up7r8iuny0Yo06vjWaM/DsQNvAGbR2kF3bvcyJSAD R78cIRlLY3bKjNZOD1LyZrhoGHQZUH1P/WKDvhUxYMiCsANgpjWaf3g60R+I+qd57AEP4ivS tuZFkvPBIDrbvTQe5mdv/4TxvaUDw9RyyPYeOjea+WkzbaRaqdIsX17ffr8T355fv3x6+v6P +5fX56fvd+08Xv4R61UjaS/enKluGS7ou66qWWFPyiMY0AbYx2obSafI/Ji0UUQjHdAVi9r2 tgwcoveU05BckDlanLerMOSw3rlUHPDLMmciDqZ5J5PJn594drT91IDa8vNduJAoCbx8/l// r9JtY7BOyi3Ry2i6sxhfPFoR3r18//rfQbb6R53nOFZ0mDmvM/DAcEGnV4vaTYNBprHa2H9/ e335Oh5H3P368mqkBUdIiXbd4wfS7uX+FNIuAtjOwWpa8xojVQKGSJe0z2mQfm1AMuxg4xnR nim3x9zpxQqki6Fo90qqo/OYGt/r9YqIiVmndr8r0l21yB86fUk/1COZOlXNWUZkDAkZVy19 m3hKc6MlYwRrc2c+W7T/a1quFmEY/G1sxq/Pr+5J1jgNLhyJqZ7eprUvL19/3r3B3cX/fv76 8uPu+/O/vQLruSgezURLNwOOzK8jP74+/fgdLPK7L3+OoheNfSNgAK1Hd6zPtpGUQf+rkq19 WWCjWg/hinxSgkJsVp8v1HB7YrukVT+MRnSyzzhUEjSp1eTU9fFJNOh5vubgYrwvCg6VaX4A JUTM3RcS2hm/oxjww56lDtquD+NYeyarS9oYPYRgVhKZ6TwV9319epS9LFKSWXjQ3qvtX8Ko UwzFR5c7gLUtieTSiILN+zEteu25ylNkHwffyRNoFHPshSQv41M6vbaH473hPu3uxbnXt74C Vbn4pOSuNY7NqNDl6JnSiJddrc+mdva9r0Pq0zJ03ujLkJEYmoJ58q4iPSW5bT5mglTVVNf+ XCZp05xJhyhEnrkPNHR9V2qbL+yc2QnPHnUhbCOStCptv7mIFkWixqtNj17I7/5qlCbil3pU lvib+vH91y+//fH6BHo/xB35n/gAp11W50sqzoxPX901jrSDX+5tqz46920Gr6qOyGkXEEZD fJqAmzYmDWICrJZRpO0JltznahrpaIcdmEuWTD7/xhNofdy8f/3y+Tfa+sNHzoQ04KAb60l/ ftb7xz//7q4Qc1Ckh2/hmX25YuH4hYlFNFWLvQpYnIxF7qkQpIuv+92gXj6jk8K5sX2QdX3C sXFS8kRyJTVlM+6MP7FZWVa+L/NLIhm4Oe459F6J0Gumuc5JTvolXSyKoziGSMZQYJypQS/7 h9T2K6PrTqs9syCtg4nBJZngi6wZ9NpkbYoNHOrZF97FMBCT5oy7i4rhIPq0TBxqzazMCt5m fOEMxYxEQ7QK6ZETB+AeOtIg+yo+keoBTxegZ1qTei4kFTFkAaHU7lC0qUs16TED88pg2u2Y lUfPx+ekchldf6ckrl3KqaMBJNsHiwi3ZQGygYdd3GTh2+1uvfAHCZa3IgjY6LWUx0DOM9iJ UJXsVmItyjSf91s/f3x9+u9d/fT9+SuZDHVA7dUbFKnV6pCnTEzMWDE4vT2bmUOaPYry2B8e 1RYtXCZZuBbRIuGCZvD+7l79s4vQPskNkO222yBmg6gpK1eiar3Y7D7GggvyIcn6vFW5KdIF viqaw9yrmhwEiP4+Wew2yWLJlnt4+5Enu8WSjSlX5H4RrR4WbJGAPi5XtleBmQRzxWW+XSy3 pxwdd8whqot+kVa20W4RrLkgVZ4VadeDyKT+LM9dVlZsuCaTqdZEr1rwMbNjK6+SCfwvWARt uNpu+lXUsh1C/VeAYbm4v1y6YHFYRMuSr+pGyHqvhLhHtQy11VnNNnGTpiUf9DEBIw1Nsd4E O7ZCrCBbZ9kYgqhVSZfzw2mx2pQLclxuhSv3Vd+A8aIkYkNML3/WSbBO3gmSRifBdgEryDr6 sOgWbF9AoYr30toKwQdJs/uqX0bXyyHgporBHHX+oBq4CWS3YCt5CCQX0eaySa7vBFpGbZCn nkBZ24D5QTV7bTZ/Ish2d2HDgEasiLvVeiXuCy5EW4NC8SLctqrp2XSGEMuoaFPhD1Ef8ZXL zDbn/BEG4mq12/TXh+6I9hlk8kVLLDUVMMU5MWj+no9DWJl5EhJF2W2QFQwtOiUlI08n52Kv jyISQaZVmPH7tCSGw/UClh4FSHdKum2TugOnI8e0329Xi0vUH644MOwL67aMlmun8mCf1ddy u6aTvtqAqv9lW+QxxhDZDhvpGsAwIrN0e8rKVP03XkeqIMEipHwlT9leDIq5dLdL2A1h1Xx1 qJe0N8DrzHK9UlW8JfMxK72PG2dHuZQQ1G8foqPI/50jZLLC4gD24rTnUhrpLJS3aC4ta3/h DAa3J6NSFPSAAR57CzjlUWOD3d9DiPaSumCe7F3QrYYMbHlkpBCXiIgrl3jpAJ4KSNtSXLIL C6p+mTaFoDugJq6PRLI+ZUpQVF2R7jw1fp81GT0AGV6q8yhT7o+OfN5JBzjsaXySbv/N81m2 hx2LIDxH9lBus/JRl6LbRqtN4hIg6IX2cbtNRMvAJYpMTfHRQ+syTVoLdIg2EmpZQe6qLHwT rcicV+cBHaOquzmCRkflFwX0B7WMtc6+TklnrqClgtJ9sLEP0h8PZEwUcUKaLod5mW4nEvpd E9gKVDqmI8nIJSOAFBfBL1RKeEzLVp/N9g/nrLmXtJTw2LVMqlkn9PXp2/PdP//49dfn17uE nvwd9n1cJEpctVI77I0HkUcbsv4ejm71QS76KrGNvKjf+6pq4cqTscEP6R7geV+eN+i51UDE Vf2o0hAOoVrxmO7zzP2kSS99rTbhOdgL7/ePLS6SfJR8ckCwyQHBJ3eomjQ7lmq5VgO9JGVu TzM+HSYCo/4xBHvUqUKoZNo8ZQKRUqDHg1Dv6UHJ9dp8Gy6AEjRUh8D5E/F9nh1PuEDg1mU4 /cZRw/4Uit+aHa/bo35/ev1sjPnRoz9oFn18hCKsi5D+Vs1yqGCZUWhJW0ftlGN0MA3R5rXE r4F0x8C/40e12cG3ZjbqdFahpCBV7S2JVLYYOUN/Rshxn9Lf8MLzl6VdykuDi13VIOo1Ka4c GSTaqRzOGNiIwaMTznYFA2G95BkmZxkzwfeGJrsIB3Di1qAbs4b5eDP0rAK6nVBbjo6B1Pqi ZI9SbTBZ8lG22cM55bgjB9Ksj/GIS4pHr7mKYCC39Ab2VKAh3coR7SNaDibIE5FoH+nvng4Q BYFdtCaLezpQNEd706MnLRmRn84QocvSBDm1M8AijknXRYahzO8+ImNUY7Zp2sMeL5Hmt5ox YC6H9/fxQToseGYsarVS7uE0C1djmVZqXs9wnu8fGzx9RmgtHwCmTBqmNXCpqqSynewC1qot Fq7lVm0805JOeffod13gb2I1J9IFe8CUDCCU2HvRsu60tCAyPsu2KvjVpe4E0paCxjipxUFV YQqdCxexLch6A4CpH9LoUUx/D/fWTXrUB/2YLpDDA43I+EwaA91owOSyV6Jv1y5XpDdRs18w Q1d5csjkCYGJ2JKJd3A0PWNauNSX3K6ICbNKCgcoVUHmpb1qdBLzgGlzi0dSqyPnzFkd7gX7 phKJPKUpGcXkgBggCaptG1Kjm4CsSGAxz0VGBQNGgDN8eYabf/lL5H6pPbdk3EeJlDzKzJmE O/i+jMGbkZoPsuZBX4R4U7CdFiFGrQaxhzKbTmINbwixnEI41MpPmXhl4mPQ0RFi1FjuD2Aw JQUHq/e/LPiY8zSte3GAex8omBprMp3MnkK4w94ckulb4eGK+C5hxDgT6XA2pUQXEa25njIG oIc1boA6CUK5IFO8CTPIgOD2+sJVwMx7anUOMHn4YkKZ3RTfFQZO7fjjwkvnx/qkZpZa2rcO 07nL+9U7hmS3Z7qJ9k+f/vX1y2+/v939X3dq7h2UJ1xNJ7hwMG6SjIvBOcvA5MvDYhEuw9Y+ 7dZEIdUO/niwleI03l6i1eLhglFzQtC5IDpoALBNqnBZYOxyPIbLKBRLDI+GpTAqChmtd4ej rSozZFitC/cHWhBzqoGxCux9hStLZphkHk9dzbyxyYhXu5kdRC2OgpeU9gHhzCDvwzNMnc5j xlYInxnHo7aVSrHdLYP+mtvmTWeaeiK1SpzUq5XdjojaIj9ZhNqw1Har8rJesIm5LqGtKEUb eqLU3uIXbINqascy9Rb5rEcMctRu5Q9OTxo2IdfH8cy5fnGtYsloY59mWb0JmbmzsndR7bHJ a47bJ+tgwafTxF1clhzVqK1OrxUtppnnnflljONyFEStQL8+5U8Mhjl50Cn9/vPl6/Pd5+EM ejDI5MxfRulT/ZAVutm2YVjcz0Upf9kueL6prvKXcDVN1krSVcLC4QCvY2jMDKmmg9bsJbJC NI+3w2r9I6Qcycc4HMq04j6tjIXNWan1dt1MU1ll+8uEX72+We6xLTuLUK1l305bTJyf2zBE 7+wc7dnxM1mdbdlW/+wrSW13Y7wHLwK5yKypTqJYVNg2K+yjYYDquHCAPs0TF8zSeGebTwA8 KURaHmFz48RzuiZpjSGZPjgTP+CNuBaZLYkBCNtHbfqrOhxAcRWzH5Bq0ogMzrWQ7q40dQQ6 tRjUGkNAuUX1gWCJXZWWIZmaPTUM6HMGqTMkOtgrJkqYD1G1GeG/V9sm7PJTJ6623/2BxKS6 +76SqbM3x1xWtqQOifQ/QeNHbrm75uwctOhUCoE9yg/tfwZz6C5sphNPaLc54IuhemGgg68m NwB0KbUXR9t7m/N94XQUoNRm1P2mqM/LRdCfkXKp7m91HvXo6NdGIUJSW50bWsS7TU+syOoG oTYgNehWnwAXxSQZthBtLS4UkvYVsakD7Wr4HKxXtn2AuRZI11D9tRBl2C2ZQtXVFR5Di0t6 k5xadoE7Hcm/SILtdkewNsu6msP0UTuZqcR5uw0WLhYyWESxa4iBfYteO06Q1tuP84pOW7FY BLaorTHtH4F0nu5Ryb5Mp9I4+V4uw23gYMgH64z1ZXpV262acqtVtCJ34JpouwPJWyKaXNDa UvOkg+Xi0Q1ovl4yXy+5rwmolmJBkIwAaXyqIjI/ZWWSHSsOo+U1aPKBD9vxgQmcljKINgsO JM10KLZ0LGloND8Ml3pkejqZtjOqMy/f/z9v8NTrt+c3ePTz9Pmz2tx++fr29y/f73798voN 7orMWzD4bBB8LBMuQ3xkhKgVO9jQmgfr7/m2W/AoieG+ao4BMsagW7TKSVvl3Xq5XqZ0Zcw6 Z44ti3BFxk0ddyeytjRZ3WYJlTeKNAodaLdmoBUJd8nENqTjaAC5uUUfYlaS9KlLF4Yk4sfi YMa8bsdT8nf9VIK2jKBNL0yFe+BRrk6KLHaDEN3bEWYEN4Cb1ABcUiB07VPuq5nTtfNLQANo hzmOq82R1eufShrcP937aOopEbMyOxaCrSLDX+h0MVP4iAtz9G6VsOCsWlDJw+LVrE+XHMzS DkpZd8a2QmgNGH+FYKdTI+scrUxNxC3J0y5m6qpuak3qRqay7W1toTbLJXieL+gkDGzaUc9N Uwahg6ilVRXtY2oZ6NdzQidgaDrrpqSCtGg3URzaD+ttVG0jG/DvtM9asBT9yxIeF9sBkRfB AaAqZAhWf6WTIeWybeD4vHHDnkVAFwTtxlFk4sEDU2vNU1QyCMPcxdfwutKFT9lB0J3aPk7w nf4YGFRY1i5cVwkLnhi4VWMGX3KMzEUo4ZPMufpFqJPvEXXbO3F2nVVnK2/qtUviW9kpxgop +uiKSPfV3pM2uGJFb/kR2wqJPDcjsqjas0u57aC2XjEd4ZeuVtJlSvJfJ7q3xQfS/avYAYwA vqezGjDjDfeN/T4EG/fsLtNWdaUmabrFg0SdnZgBe9FpPUw/Keskc4sFDxZVSejRw0DEH5W8 uQmDXdHt4Nxabbptu9IkaNOCmU0mjDmkdipxglW1eynk6QRTUnq/UtStSIFmIt4FhhXF7hgu jP3lwBeHYncLumGzo+hW78Sgz/YTf504YshMsi1dZPdNpY8xWjKNFvGpHr9TP0i0+7gIVev6 I44fjyXt52m9i9RK4TRqkqppodQqd05cFlfPdiDlSzzYEwdB+/D6/Pzz09PX57u4Pk/GsoYn /3PQwVI+88n/wlKg1Ac+eS9kw4xhYKRghpT+5KyaoPN8JD0feYYZUKk3JdXSh4yeo0BrgGpz XLh9dSQhi2e6qyrGZiHVOxyckjr78j+L7u6fL0+vn7mqg8hSuY3CLZ8BeWzzlbPGTay/MoTu WKJJ/AXLkEeQm90ElV/18VO2DsH7Je2BHz4uN8sF39Pvs+b+WlXMbG8zoOMnEqH2p31ChSSd 9yML6lxlpZ+rqAwykpNquzeErmVv5Ib1R59JcBYAflHAP5naHODXHlNYvUOSsoXFKU8vdItg VsQ6GwIW2LMnjoVfRQy3T656Idn4FpshGCiUXNPcF5mr6z4xbbihMuKM69Og5ZLp7QMP0/6a 6e5Fu97sNj4c/olWbKrbYBP5cDjk3m0XOzY9HQCqih4xOjT8swroGSUXar1Z86G2njxuI1O0 bd/KSIThJjV5VsICM2UNXxiZ4nbA+37fxhc5Ga8QMP7tGUx8+/ry25dPdz++Pr2p399+4slr cOfVHbXCLlkOZ65JksZHttUtMilAs1r1c+fgHgfSw8qVSVEgOnYR6QzdmTV3Wu4saoWA0X8r BuD9ySshhKO0J7S2gh1/iybpP9FKKLZO8rK1JtilZdihsl+B0zwXzWtQoYjrs49yNTswn9UP 28WaEQQMLYAOmHEjWzbSIXwv954iOKpbE5nIev0uS3d5MycOtyg1LBnxZKBpP5ipRvUu9MKc fCm9Xwp46+5Nk+kUUs299NxRV3RSbG37/iPu2sygDC/vTqzT/RHrkW4m3j95zyYwWuyZYApw rySu7fD4jjmwG8JEu11/bM7OFfhYL+bpLyGG98DulnR8KMwUa6DY2pq+K5J7WB6RNWBfoN2O WY5kIZr24Z2PPbVuRczvtmWdPkrncNvstvdpU1QNs93eKwmDKXJeXXPB1bh5FAPvAZgMlNXV RaukqTImJtGU4HRP95Ao6EUew7/+ummLUBV/Zc5Jbwj+zfP3559PP4H96Yr78rRU0jkzJMHM CS+NeyN34s4art0Uyp38Ya53j7qmAGd6tKuZ6nBDUAXWuTMcCZBieabi8g/45NONIcuKuZYm pKuxbAeSbZPFbS/2WR+f0pgero3BGL2CkVKrW5xOiemrBX8URktBtvQ+HAcaFSOy2lM0E8yk rAKpFpQZVkRyQ6el2OfpqDqtBBtV3lvhId5DDjszbE/OCsl/rl8E3+weKgSzCdCM3oC887UO 4+9Jhvd2QUOflGTWp7W/iodU2qoYw94K55MbIMRePLaNgJf1tzriGMrDTluy25GMwXi6SJtG lSXNk9vRzOE8o7iucrgwvU9vxzOH4/mjms3L7P145nA8H4uyrMr345nDefjqcEjTPxHPFM7T J+I/EckQyJdCkbY6jtzT7+wQ7+V2DMns5UmA2zG12RG8rL9XsikYT6f5/UnJIu/HYwXkA5i7 Pf/IAz7PSrXdFTLFT5vtYF2blpLZKMuaO0EDFN6Ac5lup2tz2RZfPr2+PH99/vT2+vIddCu1 6+k7FW5w4ebov87RgI9q9kDTULyoaL4CCa5h9lOGTg5Si92zrPHn82mOCr5+/feX7+Byx5FS SEG0YTVueda20G4TvFx+LleLdwIsuYsaDXOirU5QJPreFl6gFQLpRd8qqyPnuhoMExwu9H2W n00Ed081kGxjj6RHYNd0pJI9nZlz1JH1x2z2TsxWw7Bw9bJiDq0mFvk+pOxuQ5VvZlZJY4XM nQvSOYCR1b3f+7eFc7k2vpawT0UsT6y2EO66zuZl/VYJDOCJl90tgb2amfR4+Fabdztl5vog EZesjDOwU+GmMZJFfJO+xFz3gUdLjKbORBXxnot04MzG3lOB5jLk7t9f3n7/05UJ8UZ9e82X C6r0OCUr9imEWC+4XqtDDCo08+j+s41LYzuXWX3KHNVhi+kFt+Oa2DwJmM3mRNedZPr3RCvB WLDTpwpknrjyA3vgzJbPc7pqhfPMLF17qI8Cp/DRCf2xc0K03HGPtpoEf9fzYxEomWtDYtq6 57kpPFNC97HRvOHPPjramUBclXR/3jNxKUI4ek06KjC3tfA1gE9VWnNJsI2YEzaF7yIu0xp3 1YMsDj0NtjnumEgkmyjiep5IxLk/txl3GgNcEHG3KJphb3sM03mZ9Q3GV6SB9VQGsFTN2GZu xbq9FeuOWyxG5vZ3/jSxG2GLuWzZzqsJvnSXLbfSqp4bBFT3WxP3y4DqVYx4wGzJFb6kD20G fBUxR6uAU4W+AV9TfbYRX3IlA5yrI4VTPWWDr6ItN7TuVys2/yBFhFyGfOLFPgm37Bf7tpcx M9vHdSyY6SN+WCx20YXpGXFTyV4rbLKzRyyjVc7lzBBMzgzBtIYhmOYzBFOPcHGbcw2iCe7u dSD4QWBIb3S+DHCzEBBrtijLkKq5T7gnv5sb2d14ZgngOu40ayC8MUYBJ8sAwQ0Ije9YfJMH fPk3OdWTnwi+8RWx9RGcSG0IthlXUc4WrwsXS7YfKQI5ax6JQanEMyiADVd7H50zHUbfjzNZ 07gvPNO+5p6dxSOuIPohN1O7vJg9WJlgS5XKTcANa4WHXN8BFSPuCtWnemRwvuMOHDsUjm2x 5papUyI4BXaL4hSwdI/n5jttIh/M23MTVSYFXCsx28e8WO6W3KY1r+JTKY6i6anKI7AF6Idz ShR6o7nldFn8aiWGYTrBLW0NTXFTlmZW3HKumTWnMAMEMhpAGO5m2DC+2FjZcMiaL2ccAffP wbq/gt0Hz6WsHQY0m1vBnHOrTXWw5mRBIDb0eZ5F8B1ekztmPA/Eza/4cQLkllN5GAh/lED6 oowWC6YzaoKr74HwpqVJb1qqhpmuOjL+SDXri3UVLEI+1lUQ/sdLeFPTJJsY3O5zM1+TKxGP 6ToKj5bc4GzacMOMPwVz0qiCd1yq4HaZS7UNkHM8hLPx8IpoBvfURLtac2uDuRnnce6Exatr AdpvnnhWzFgEnOuuGmcmGo170l3zdbTmxELfueCgLemtuy2zQPnVdmW23HADXz8MY08bRobv 5BM7nV07AcAGWC/Uf+E+jzntsdQAfFfpHp0QWYRs9wRixUlMQKy5ne9A8LU8knwFyGK54hY6 2QpWCgOcW5cUvgqZ/gj6u7vNmlVAy3rJntsLGa64zY0iVgtuXgBiEzC51QR9pDwQan/MjPVW iZ9LTixtD2K33XBEfonChchibnNrkXwD2AHY5psDcAUfySigD1kx7bzed+h3sqeD3M4gdwRn SCWkcvvrUSmXY8zuz8NwJyTe023vofY5EUHE7QM0sWQS1wR3MqgEql3E7QmveRBy8t21WCy4 TdS1CMLVok8vzJR/Ldz3egMe8vgq8OLM8JoUtBx8yw55hS/5+LcrTzwrboxonGkGn7YeXJ5x yz3gnJStcWY65d4/TbgnHm57qC/zPPnk9kuAc0uoxplBDji3TCp8y21eDM6P54FjB7K+duTz xV5Hcm/MRpwbb4BzG3jfowWN8/W9W/P1seO2eRr35HPD94sd96JA4578c/tYre/pKdfOk8+d J11OIVXjnvxwisga5/v1jhOrr8Vuwe0DAefLtdtw8ozvwlrjTHk/6ju23bqmdhWAzIvlduXZ Sm84gVgTnCSrd9KcyFrEQbRhn5Tk4TrgZir/+xl4fOLiJbjN5oZIydmvmQiuPgzB5MkQTHO0 tVir/Y9AVjbxpSH6xEjA8IyDveKaaUwYkfjYiPrEsLxzCevRsjGdkSWubszJVkhWP/q9vod9 BE3UtDy2J8Q2wlJrPjvfzoYSjNLRj+dP4NIbEnZuUCG8WIIbLhyHiOOz9gJG4cZ+/DhB/eFA 0BqZGZ6grCGgtJ+5auQM1hJIbaT5vf1kxmBtVTvp7rPjHpqBwPEJPJtRLFO/KFg1UtBMxtX5 KAhWiFjkOfm6bqoku08fSZGovQuN1WFgTyAaUyVvM7DEuF+goaTJR/J0HUDVFY5VCR7jZnzG nGpIwbMzxXJRUiRFz3oMVhHgoyon7XfFPmtoZzw0JKpThY2lmN9Ovo5VdVSD8CQKZKROU+16 GxFM5Ybpr/ePpBOeY3D9FGPwKnKkew3YJUuv2nEeSfqxIcYdAc1ikZCEkNVyAD6IfUP6QHvN yhOt/fu0lJka8jSNPNZ2TgiYJhQoqwtpKiixO8JHtLdNRyFC/bB970643VIANudin6e1SEKH OiqhyQGvpxS8sNAG1yb3i+osU4rnYDidgo+HXEhSpiY1nZ+EzeAWtTq0BIaZuqGduDjnbcb0 pLLNKNDYxoYAqhrcsWFGECV4l8ore1xYoFMLdVqqOihbirYifyzJ1FurCQz5dLDA3vbJY+OM dweb9sanuprkmZjOl7WaUrSzwJh+AfZTO9pmKigdPU0Vx4LkUM3LTvU67600iGZ17ZOQ1rJ2 4gRKwARuU1E4kOqsaj1NSVlUunVOF6+mIL3kCD40hbRn/wlycwWvsT5UjzheG3U+UcsFGe1q JpMpnRbA/96xoFhzli21g2mjTmpnED362nYFouHw8DFtSD6uwllErllWVHRe7DLV4TEEkeE6 GBEnRx8fEyWA0BEv1RwKJuDPexY3Pi6GX0T6yLXzpFkTmhGetFR1lntelDOmiZxBZAFDCGMF dkqJRqhTUftdPhXQkTOpTBHQsCaC72/PX+8yefJEo9+pKNqJjP9uMqplp2MVqzrFGfZThYvt aPZro1BEWV/bawLLyGiC1Rai8jrDBoDM92VJTGVrK1YNrGFC9qcYVz4Ohp4E6e/KUk3A8HoL 7E5qc8CT8F58+fnp+evXp+/PL3/81E02mEXB7T+YIQMXDDKTpLg+E7u6/tqjA/TXk5r4cice oPa5ns1li/v6SB/sp8BDtUpdr0c1uhXgNoZQYr+SydUyBNZjwLFjaNOmoeYR8PLzDaxVv72+ fP3KuYfQ7bPedIuF0wx9B52FR5P9ESlKTYTTWgZ13pPP8avK2TN4YdsWntFLuj8z+PAYk8JE vx/wlC2URhvwd6faqW9bhm1b6HBS7VS4b51ya/QgcwYtupjPU1/WcbGxT6ARWzUZHYbprVKm 3WNZSU9kfJNU3TkMFqfaraFM1kGw7ngiWocucVA9HEzOOIQSMaJlGLhExbbNiPZ5DTcCnYd1 WmBiJJ1SKl/tVLdr58zm7wzWFB1U5tuAKeIEq3qrOComWWq2Yr0GT8lOVE1aplJNn+rvkzuJ 6jT2cSFc1KkPAOG5KHkH6yRizyzG18ld/PXp50/32ELPVDGpPm0xPCXj9JqQUG0xnYyUShj5 X3e6btpKbRzSu8/PP9QK9/MOLF/FMrv75x9vd/v8HpaBXiZ3357+O9rHevr68+Xun89335+f Pz9//v/d/Xx+RjGdnr/+0O8Hvr28Pt99+f7rC879EI40kQHpw2KbcmyNDoCeuOvCE59oxUHs efKg5FEkqtlkJhN0D2Nz6m/R8pRMkmax83P2kbnNfTgXtTxVnlhFLs6J4LmqTMmuzWbvwYYU Tw3nKr2qothTQ6qP9uf9OlyRijgL1GWzb0+/ffn+2+Apg/TWIom3tCL1xhQ1pkKzmlgUMdiF mxtmXD/Xl79sGbJUgrAa9QGmThWRJyD4OYkpxnRFcF0eMVB/FMkxpcKdZpzU1Pp7jn6xnNCN mA7KekCdQphkGBd1U4jkLHK13OapmyZXoEJPUok2V4eT08TNDMF/bmdIy3xWhnR/qQfrPHfH r3883+VP/7WtXE+fqT1mlzF5bdV/1uiudU5J1pKBz93K6X16Ei2iaNXBWWg+GX4q9PxbCDV1 fX6ec6XDKylbDTX73FMneo0jF9HiOq1STdysUh3iZpXqEO9UqZFE7yS3PdPfVwUVMDXMLdsm z4JWrIbhtBcswzLUbLmJIcHKBPHFN3HOjgHAB2eOVnDIVG/oVK+unuPT59+e3/6R/PH09e+v 4FwGWvfu9fn//uMLmFyHNjdBptdvb3qBe/7+9M+vz5+HZ1g4IbW/yepT2ojc31KhbzSaGKhU Zb5wx6jGHTcfE9M24F6lyKRM4QDo4DbV6KoQ8lwlGRGRwTZQlqSCR5EdEkQ4+Z8YOpfOjDsZ goy7WS9YkJeI4dmTSQG1yvSNSkJXuXeUjSHNQHPCMiGdAQddRncUVjw7S4m0lPR8pr10cJjr hsniHMvfFscNooESmdq27X1kcx8FtpKjxdHrJjubJ/QSw2L0Lv2UOhKRYUEz2fg+Td099xh3 rbYzHU8NQkqxZem0qFMqLxrm0CaZqiO6FTDkJUPnXxaT1bb1bpvgw6eqE3nLNZJ9m/F53Aah rdOPqVXEV8lRe6315P7K4+czi8McXosSbFHf4nkul3yp7sEtbi9jvk6KuO3PvlJrT7E8U8mN Z1QZLliB+VJvU0CY7dLzfXf2fleKS+GpgDoPo0XEUlWbrbcrvss+xOLMN+yDmmfgSJAf7nVc bzu6exg4ZG2PEKpakoQerUxzSNo0Agyc5+iG1Q7yWOwrfuby9GrtSh67AbPYTs1Nzp5rmEiu npo2Rq94qiizkore1mex57sOzsCVXMxnJJOnvSPajBUiz4GzMRwasOW79blONtvDYhPxn42L /rS24MNWdpFJi2xNElNQSKZ1kZxbt7NdJJ0zlWDgSMl5eqxafPGqYboojzN0/LiJ13R39AjX faS1s4TcdQKop2t8I68LAKoTiVqI4TwWFyOT6p/LkU5cI9w7LZ+TjCvJqYzTS7ZvREtXg6y6 ikbVCoGx6S9d6SephAh9xnPIuvZM9q+D54IDmZYfVTh6GPlRV0NHGhVOTdW/4Sro6NmSzGL4 I1rRSWhklmtboU9XAVj/UVUJvoadosQnUUmk26BboKWDFW4QmROHuAOFGIydU3HMUyeK7gwH KIXd5evf//vzy6enr2ZHyPf5+mQ7oJS5rhh8czBuStzwZVWbtOM0s7yqjdtA4+gDQjicigbj EA3cuvQXdCPTitOlwiEnyMil+0fXKd4oaEYLIl2BXVpUAtMBwTCLAw/7TYJoVY5hZUO3bZ7K RuVjTjQGiZnZowwMu0uxv1JjJE/lLZ4noaJ7rf0VMux4WgUe142zUWmFc+XsudM9v3758fvz q6qJ+SoH97mxm5HZajiBd7Y6x8bFxoNmgqJDZvejmSajG6wSb8jkUVzcGACL6LJfMmdsGlWf 67N5EgdknJR9n8RDYvjwgT1wgMDuPWORrFbR2smxWsfDcBOyIPZLMBFbsmgdq3syBaXHcMH3 Y2PZhWRNz279xblUNF51zY4UjyW2D+FJdw/uV8AmJV303KP8g5Iv+pwkPvZhiqawulKQGDgd ImW+P/TVnq5Ch750c5S6UH2qHKlLBUzd0pz30g3YlGpNp2ABFq7Z24GDMy8c+rOIAw4DuUXE jwxFx3B/vsROHpAXToOdqArDgb9wOfQtrSjzJ838iLKtMpFO15gYt9kmymm9iXEa0WbYZpoC MK01f0ybfGK4LjKR/raeghzUMOjppsRivbXK9Q1Csp0Ehwm9pNtHLNLpLHastL9ZHNujLN50 LXSQBapB3lMuPQt4zrXSlohuCuAaGWDTvijqI/Qyb8Jmcj1Ib4DDuYxhO3cjiN073klocP/m DzUMMn9a4FrYPXQnkQzN4w0RJ8bHlp7kb8RTVveZuMGrQd8X/oo5Gi3NGzzoJ/nZZH+sb9DX dB+Lguk17WNtv4XVP1WXtG9dJ8xe7Q3YtMEmCE4UPoBsYz9dG6KopRI6tp0tqLX//fH89/iu +OPr25cfX5//8/z6j+TZ+nUn//3l7dPvrpqXibI4Kyk+i3R6qwg9lfg/iZ1mS3x9e379/vT2 fFfAzYKzdzGZSOpe5C1WBDBMecnA2eDMcrnzJIJkRiXe9vKaIXc4RWE1XH1twGd2yoEy2W62 Gxcmx8zq036PvSVP0KjZNV3GSu1OEXmIhcDD3tPcuRXxP2TyDwj5vlIVfEy2HwCJplD/ZBjU 7i2SIsfoYBY2QTWgieREY9BQr0oAx9dSIp21ma/pZ00WV6eeT0DJ2O2h4AiwD90IaR+AYFJL pj6ytZ+gISqFvzxcco0LybOg11/GKUfpGMFoOUcSlSmr4J24RD4i5IgD/GsfmVltUjcVyfZw 59hxKLgHQ0IxUMYKJmlSOIBtuBQLSVoN6ZrpTp0dlBxFWuhY5ckhkycSZe30NNNpYraHYcPL Oq1CGyho3PZxu7D6/lHC9slt58xyxOXwrl1PQOP9JiBNclFzFzOgYnHJ1Ia8PZ3LJG1IuyRX +psbGQrd5+eUmF4fGHpfPcCnLNrstvEFKe8M3H3kpkpHL/gEc3y5DMRH2uX1MLfNQej6OKtl hiR+dobZGep/raZsEnLUanKnlYFAB0w6F1hXQtf9gzOZtZU8ZXvhxju4ZCS9u73neuK+URNG S9PXVJeWFT93IXWDGRfF2n75X6Qq5gwtKwOCz8eL528vr/+Vb18+/ctdaadPzqW++mhSeS7s QaKGUuUsX3JCnBTeX5HGFPXwLyST/Q9a26nso23HsA06YJlhthtQFvUF0NrGb1W00rN2/clh PXlHpJl9A+fVJRzon65wJFwe00k/RoVw61x/5tqa1bAQbRDar4sNWiqxb7UTFJbRermiqOqe a2SdaEZXFCVGJg3WLBbBMrAtAWk8L6JVRHOmwZADIxdEJjkncBfSSgB0EVAUXhOHNFaV/52b gQElmv6aYqC8jnZLp7QKXDnZrVerrnNeIUxcGHCgUxMKXLtRb1cL93MlYdI2UyCygDaXeEWr bEC5QgO1jugHYOsi6MBqTXumQ4DawdAgWCV0YtGmCmkBExEH4VIubBMCJifXgiBNejzn+IrJ 9OEk3C6cimuj1Y5WsUig4mlmnZft5o1DLNarxYaiebzaIasyJgrRbTZrpxoM7GRDwdjmwDQ8 Vv8hYNWi9dd8npaHMNjbcoLG79skXO9oRWQyCg55FOxongcidAoj43CjuvM+b6fD6XnCMtbW v375/q+/Bn/T+6rmuNe82u3+8f0z7PLcF093f53fkP2NTHl7uEyjba1ErdgZS2pqXDhzVZF3 jX0Nq8GzTGkvkfDw59E+OTYNmqmKP3vGLkxDTDOtjXW2qWba1y+//ebO5cMrGTpgxsczbVY4 mRy5Si0cSIkZsUkm7z1U0SYe5pSq7eMeaRchnnnViXjkjBExIm6zS9Y+emhmlpkKMrxymp8E ffnxBsqCP+/eTJ3Ovap8fvv1C+zd7z69fP/1y293f4Wqf3t6/e35jXapqYobUcosLb1lEgWy wonIWqC324gr09Y8vuM/BMsLtDNNtYWvFcyWONtnOapBEQSPSoYQWQ5mJKYbt+mcKVP/LZUY WibMKVMK5k+dh3Ip8hGsw5jTWxhs9iGwpsjpgAkOF95SiQYpIdy9iYZBtrKr1wJhp2Y/lLWp KvZS+qIGnYbbbIn8+9kMuvSyCST42cQD2lvinKMtmqlstYWq5SOtxA70DgmGtXA1xOzNmhYc E+4xQCRQgE6x2o888uDw9PCXv7y+fVr8xQ4g4XLf3khZoP8r0iUAKi9FOqkfKODuy3c1Qn99 Qo8XIKDaHx9oP5twfAgxwWiE2Wh/ztI+Lc45ppPmgk7E4Dkr5MmRtMfArrCNGI4Q+/3qY2o/ XpiZtPq44/COjylG2k8j7OwMp/Ay2timbkY8kUFkiykY72M1+51twyU2b9t/wnh/tR1RWdx6 w+Th9FhsV2umUqikOuJKAlrvuOJr0YgrjiZswz2I2PFpYCnLIpRUZltMnBh9ynVp2tjlmvvt gkmlkas44uokk3kQcl8YgmvKgWEy1imcKXsdH7DxOEQsuBbRTORlvMSWIYpl0G65RtQ434X2 yUZtAphq2T9E4b0LOwYMp1yJvBCS+QCuPZAdZMTsAiYuxWwXC9vq3dS88aplyy7VXna3EC5x KLAJ/ikmNQ1waSt8teVSVuG5/p4WatPP9OrmonCug162yJnHVIBVwYCJmjO24wSqlsDbEyg0 9M7TMXaeuWXhm8OYsgK+ZOLXuGfO2/GzynoXMOOq2SFPM3PdLz1tsg7YNoRJYOmd55gSqzEV BtzILeJ6syNVwbgzgqZ5+v75/TUukRFSEsd4f7qibQ/Onq+X7WImQsNMEWKdpneyGITcbKzw VcC0AuArvlest6v+IIos5xe8tT5lmIRoxOzY+1wryCbcrt4Ns/wTYbY4DBcL22DhcsGNKXKq gnBuTCmcm+Vlex9sWsF14uW2ZVdLhUfciqzwFSMJFbJYh1zR9g/LLTdImnoVc8MTehozCs0p FY+vmPDmnIPB69S21WCNCVhSWdEvYmW5j4/lQ1G7+OCSZxwlL9//rjbXt8eIkMUuXDNpDB73 GCI7gnWliilJVnQJ8wWoaB7aAh5JN8zaoIUjF8bXEicBxuci0FVgZChFMAtavYvYZjgxLd8s Ay5snfMyQs4u6nDL26j65NoMOCkKpvs6b8imTLXbFReVPJdrpprJNdMkg3TLXcSNmguTyaYQ iUD3IFPfovfNU+u26i9WAomr024RRFxNyZbrv/h2YF65AtWOTJaMrx1ucxCHS+4Dx4zGlHCx ZVMgl+VTjjqmtRTYX5jJRpYXRpoEp+OSi6XqkDbGhLfriN1ztJs1J/KTE4Jp5ttE3MSnlS6Y BuQbpGmTAB37zpPJoAIxmROVz99/vrzenoIs81dwdMkMEOeOPgE3N6P5IwejBwoWc0FXlfCS PKEmEYR8LGM1akYH9HDFVqa5o7cDHlHT8oi8NAN2yZr2rN9j6u9wDtFz3eHcp5BHdIwkCrgF zhf2KBRdRjQA9qAUqgI2wlZoHIac7c4AUnWukAGE4WPvsgCTIgg6iuHpJrkyuTFzLT4Og2k/ dZAHhGTFEexP9ATsXEBixFgHU9h66aBV3QsU+j7C8al5INia7Bb266siPpAcF0Xd1w7SYkSN NqSTon+juQCeiuBvuqjP7IPvAeiz5kH+shzRcl8fhsqeg1bXHAM1mMpEQB5FCwwN7rRZCNWB QQscElyIYyTSUyzpBZP36HqPgxsiWJB2UcOdBJy8xhY4Zj2d4aCD31cOM/IRpj6SoEV735+k A8UPDgTqcapICNe6a3tR9C56gl7ZF0f76eJMoHEEZSRaQgPqBkN6BqBdQyMb/DdnthFDecYZ HB+t4LbUvSfVTucd1Po2Fg3Jm/UGhvaEjGYQ5j4k0bW6W2uZVc1jjT0nx1+/gDtjZk6mceJH cvOUPE6LY5T788G1h6cjhQdPVqmvGrU6pPkYpaF+qwUrP0DiyCQjSWjK/blzXkiekiWefWEm FDLOMmLntA3W9/beYHhDDbdIaW7DsEaND6wXBG4qXcwVho3yCMjfEmn5G3YPNuFG7i9/mbec 6rNGm2vN1Wp2YHeldpCS2ZNaPNFxIcUaAlrtgZ7OgJKdrd0FQD3I1GomxURSpAVLCFt1GgCZ NnGFDAlBvHHGmHtQRJm2HQnanNG7CAUVh7VtNv5yUFhWFcVZqxgHhFEyxMMhwSAJUlb6c4Ki WWJE1JplD7wJVstlR2HH+puGQSTxhFQbg7xLE9EdYZZqUvRKBYcURdId9+ntQEpUOeRpp/7i ghXo7maCxrulmVFCmJIdswu6JgcUVaT+DXoPZwfENTlhzsOUkSrsdzYDuBd5Xtl72wHPyvrc utkouLxpRdICLAKnrsnPT68vP19+fbs7/ffH8+vfL3e//fH8881Ssp9mpveC6rDd8/dRGcPR 0wcPAk5xLBBU36rmsT9VbZ3bwjeEkXFz3quhfdSyOXlfCwGgCdOLEq+dyON75LJAgfZNH4SB Vx2i5Ri4qjyp0dUQayLAqf/Bk1XXKQKQxxLfws9YT5cDTTWibHUZoC5iliwEJdV+omrzPQTC X9QXsN/vy9vIclXTg2VAnqnVWFDdCINgmK/v1MhLMa5T7utjkjVKDjDlnboS00vGb49N+ohe XA9An0rbl0Yr1BJtdRGVN1mE+MpctWpqnyWZ33RnN6FG3UMvzNnHtL/f/xIultsbwQrR2SEX JGiRydidPwZyX5WJA2JJZAAdgycDLqXqSWXt4JkU3lTrOEd+mCzYXllseM3C9oHWDG9tlw82 zEaytXeYE1xEXFbAm5+qzKwKFwsooSdAHYfR+ja/jlheTZTIgKENu4VKRMyiMlgXbvUqfLFl U9VfcCiXFwjswddLLjttuF0wuVEw0wc07Fa8hlc8vGFhWzV2hAu1HxRuFz7kK6bHCBAWsioI e7d/AJdlTdUz1ZbpZzrh4j52qHjdwZFz5RBFHa+57pY8BKEzk/SlYtQ2LgxWbisMnJuEJgom 7ZEI1u5MoLhc7OuY7TVqkAj3E4Umgh2ABZe6gs9chcDTw4fIweWKnQky71SzDVcrLABNdav+ cxVqoU4qdxrWrICIg0XE9I2ZXjFDwaaZHmLTa67VJ3rdub14psPbWcO+/Rw6CsKb9IoZtBbd sVnLoa7XSKcDc5su8n6nJmiuNjS3C5jJYua49OAQPgvQEyLKsTUwcm7vmzkunwO39sbZJ0xP R0sK21GtJeUmr5aUW3wWehc0IJmlNAahLfbm3KwnXJJJGy24FeKx1Mc6wYLpO0clpZxqRk5S 283OzXgW12aSYLL1sK9Ek4RcFj40fCXdgwbpGb+KH2tBey/Qq5uf8zGJO20apvB/VHBfFemS K08BZqcfHFjN2+tV6C6MGmcqH3Ck5GfhGx436wJXl6WekbkeYxhuGWjaZMUMRrlmpvsC2TaZ o1Z7TLQtmFeYOPPLoqrOtfiD3kOiHs4Qpe5m/UYNWT8LY3rp4U3t8ZzeJrvMw1kYT1LioeZ4 fXLpKWTS7jihuNRfrbmZXuHJ2W14Ax8Es0EwlPaL7XCX4n7LDXq1OruDCpZsfh1nhJB78y/S A2Zm1luzKt/s3lbzdD0Obqpzi7aHTau2G7vw/Ms3C4G8k9993DzWakMbx0Xt49r7zMtdU0xB oilG1Pq2lxa03QShdXTUqG3RNrUyCr/U0k+8CzStksjsyqriNq1KRgn90q7Xql2/od9r9dvo IWfV3c+3wbL7dLuqKfHp0/PX59eXb89v6M5VJJkatqGttzdA+iJ92uST702c35++vvwGtpc/ f/nty9vTV3gwoRKlKWzQnlH9Duy3Q+q3MQo1p3UrXjvlkf7nl79//vL6/AlO2T15aDcRzoQG 8LvuETSee2l23kvMWJ1++vH0SQX7/un5T9QL2nqo35vl2k74/cjMbYbOjfrH0PK/399+f/75 BSW120aoytXvpZ2UNw7jfOL57d8vr//SNfHf/+f59X/cZd9+PH/WGYvZoq12UWTH/ydjGLrq m+q66svn19/+e6c7HHToLLYTSDdbe9IbAOx0eQTlYNp96sq++M3jguefL1/hMOvd9gtlEAao 57737eSyihmoY7yHfS+LDfXfkBbdZF9F/nh++tcfPyDmn2Ad/eeP5+dPv1vXWHUq7s/WYdIA wE1We+pFXLZS3GLt6ZmwdZXb7jUJe07qtvGx+1L6qCSN2/z+Bpt27Q1W5febh7wR7X366C9o fuND7J+RcPV9dfaybVc3/oKAwbpfsEM3rp3Hr4tD0pcX+6pKlUgL7QQGe0qVxvraPnc1CDYY azDxETkiN+ezPSzI9q1PlqQVHGKnx6bqk0tLqZN2rcijjMkGQ4Nqx5iQeaj3P4tu9Y/1PzZ3 xfPnL0938o9/um5L5m9jmTFRbgZ8qttbseKvh6caiV2jhoHr6yUFidKdBfZxmjTI/Kg2DXpJ JguXP18+9Z+evj2/Pt39NHpSdBX//vn15ctn+x78hO6ZRJk0FbiElfbNAjLFrH7oF1hpAS81 a0zEhRhRa/0zidLuoLva/Hnepv0xKdSuvptH4yFrUjBW7RjOO1zb9hEO3fu2asE0t/YJs166 vPZ8behoshE6aoDRR45H2R/qo4Cramv+LDNVYFkLvC0toLz5fd/lZQd/XD/axVHTcGsPc/O7 F8ciCNfL+/6QO9w+Wa+jpf3UaSBOnVpuF/uSJzZOqhpfRR6cCa8k911g61pbeGTvCBG+4vGl J7ztTMDCl1sfvnbwOk7UguxWUCO2242bHblOFqFwo1d4EIQMfgqChZuqlEkQbncsjl6DIJyP Bymv2viKwdvNJlo1LL7dXRxc7XIekW7DiOdyGy7cWjvHwTpwk1UwemsywnWigm+YeK76GXHV 4t4Ol+5O0MMe/ksv10GNL6mFCBkINjHSsh10zXJ4j7hwEWLxaYZtGX1CT9e+qvagsmBr2iF3 JfCrj9HFrYbQjkojsjrbN3ga0zM3wZKsCAmEJE6NoGvLe7lBqtDjBSidtwYYJq7GfrY7Emoi La7CVgwbGWS/cgTJ+/oJtg/pZ7Cq98j4/8gQ2WCEwaqzA7pW2acyNVlyTBNsA3sk8Zv9EUWV OuXmytSLZKsRdZkRxFbtJtRural1mvhkVTWo1urugFXzBiXa/qLkGOv0UJaJq19r5AAHrrOl 3igNbo9+/uv5zRVuxgX3KOR9qsZgI4r0WjW2fDqEEHXaDcdX9gpOIh6/6rIcNHehcx2sStQP xLX5bnvknAowAwS1I7FbW1VX3cDos+5G7RCQ73f1odY3Q8Puvo7x0fIA9LiKRxQ16AiiXjKC RiHQHIfIpLyLRZ25quaA9uJidSgIbHTWL8U+6PcBOpTl2MvyJg/npd4A6r/o9JHQ7c3UYy7h Y6a6h13DA6CL6qJYt3NEi8BeDi00cFGieXF6VDmZBT/9c0x73vc6LTLJaGqPez1Tm/1Xbal1 Lw4emLNsf2U9k56ugoDXPfoBITBwRRbZAMmC5XZhHe+l3UG0yKyxQRLQlingJqS/HOyr8oHO ZIxE5wEGF8bgEgzpmxruHs4Bc8dWxvAd2OEvJEMY9Za4SlLQtfplGW34EFkFepXQff7yx9uv 28kYw0Nuq4G6zy4mMbzObFMdsDOdn56NQ+6kFrZ00uuzj9edoAbAA3wEmxoVdQorT23twmji GEE1HbWVC0MdoDlvJPRqukfbh4G57Jkc6gY5uAWkZik0rDpnncDCfESGG9M8F2XVMfqXxgyR q1c34PZyWOV1jCpWA10V2LL2jOE2yO9BgU0JB+goST+7g11T3ag+1eArpGFHNc6/8cu3by/f 7+KvL5/+dXd4VRtbOAO0JuF5D0ZfVFoUXMWIFillAyzrLbqT1iE749imkrggoNd/z0buWmjA pNrFrFiOGGmwmFO2RobQLErGReYhag+RrdC+i1ArL0W0fyxm6WU2C5aJkzjdLPgqAg4Zy7A5 aRb0mmWPaZGVfKGp4Vw7l2FRS6TDoMD2mq8XSz7z8FhG/Xu0dSoBf6ia7IH9gjyUs5hczZKl OHqOEaiZCJuyJVcLr7rS88Ul5ut0n2zgoRLLHbJOrR5EPwiqQBtvlxiEN0MSa92M6IZFdxQV pVCz1j5rZX9t6jxXYBluTzUZeo7IO4D9Gr3FtVEl6LapS91XpWALTmwLj+Hjx2N5li5+akIX LGXNgUxI2WCsUd11nzbNo2cInzI1TNfxJVrwPVTzOx+1Xnu/WnvGK2tPF09QIXrVDmr1CrUP TmV73rOBLcKbt30FHp2slamLh2UBA2raO+O6zIpua3vTm7CSwR5c7KHjJxvX822bqdQznK0Z AwlhD+7Gq6LXnsDMeqYXMss6oT46bp//dSdfYnZZ0wfZyGu2TbbhZsFP4IZSYxlZ3HIDZMXx nRBwbv1OkFN2eCcEHOHcDrFP6ndCiHPyTohjdDME0bzA1HsZUCHeqSsV4kN9fKe2VKDicIwP x5shbraaCvBem0CQtLwRZL3Z8BOGoW7mQAe4WRcmRJ2+EyIW76Vyu5wmyLvlvF3hOsTNrrXe 7DY3qHfqSgV4p65UiPfKCUFulhO/2Heo2+NPh7g5hnWIm5WkQvg6FFDvZmB3OwPbIOLFGaA2 kZfa3qLMEeqtRFWYm51Uh7jZvCZEfdanUvxiRwL55vMpkEjy9+Mpy1thbo4IE+K9Ut/usibI zS67pSrZmJq726zNcnP1ZBdPuHhVe1r0WNEJAL6+E9tBpBOiUNLpDbo+obMwl7/5tYQ/b6d/ yRKI5J1QooIf8Y0QafpeiFj1nuSx9CV07PZ7lhAd350UTm8q7OiC0LZSoU3FgHJbXPenNK/t 84yBjMDcM5K5pq+2i7Vji3kg4zoIFg6pn9AfE3urr6GmLmK+jrBBVB1YrCLUvBrUJa9jCXak tsia20Q3NY1Jy7NF4mEUah2bifqhP8Zxv11slxgtCgfOhsDLhb1LyKYobAOEgOYsasLad9Oq cAZFYvyEonLPKA2bu2hiwu7W9lMjQHMXVTGYIjsRm+RohofAbDl2Ox5ds1FQeAi8tRtPDhVv xSsTeOCso1iuMAxhUV1CBO25gYsZJ44jG0N95mBz9cQQYESAw/NaSOkQQ6JI6VDWRdar/+n9 GJo2jIWKAxod97WUfReTvfZg9IEFndfRwKVFeiEb6+ajIIc6zUbuQnrC12zFJhJLF0Rmn2Yw 4sAVB27Y751MaTTmwm62HLhjwB33+Y5LaUdrSYNc8XdcoewuboFsULb8uy2L8gVwsrATi/UR P66COfKkWpBGAJZEjmlJizvCagU48lTkocABsPoFHs4kMh9hdU31pRr5znEOYtuaZ9VQ4cUf qQTOc4muYsDpESxl6yU+IycBlMAkdRRoldN2dYIF+6XhQj+3jFhO5zM7ZBd6pK6x/nBeLRd9 3di3X9rgD5sOEDLebdcLJhGsCzdBpmUkx6hkC2pgymW3N9mdnXGTnn3QpKDs0h8C0CORDrVa ZL2ApmLw09oHNw6xVNFAu9HwbmbWKmQUOPBWwWHEwhEPb6OWw09s6Evkln0LT+JDDm6WblF2 kKQLQ2gMQgsZXcd9bVv5M5iWnw8eGbuFZ39YAM/vGUdn1ieTLcx558HfQ43fnq6yzkrsYWrG qNnJmcDipEUM3t+sM0P58sfrJ87PJHjmQCbgDKKPH1GZZROTo/1R+4R49xhPyik+mO904NF4 p0NctdUugh7atmgWql8TPOtqsP5F0FHHl+J6s7KmKFwz0AgSpxxmaLmgGlgnSWDTwQhojGhS tKzjYuOWYDBy2bdtTKnBUKrzhWmrZN9BKjAloZFQy00QOMmINhdy41RTJylUN1khQifzqus1 KUXHQ2+nrUpdL61qc+E0zZD9OpOtUE1XOYwakch8+tg3kWa5aIbqkhzWr5f7rLWZQmtcObWC cLAHI9smtT12kBBVlfegGCUarM+nDQ82qshnFXyx2K7sS124+MjVGCinIME6WOj/RwmpNWEM oCLY2eqnwzow0ufyvqyuJf58yKJUG90lIi6bQutjI096oi3ATBeqJQ2hJ4Om6gcBoohdapBG 8AXkaH2XDj+4jFQbVafPgdWcwceLBCtwsW3IDuzh0fAgErwTR4tHhc7sBzg/w2WWY8uiNCe0 aM+2kdJBNqtkWzCBUZLp1B5t5mSE1zjQw6KzDjxO2wjmkaLZMpi9ex7A2i0yPFg41lbRTKa0 eUtVY3HrjkzZgrVKu1vEqsoCd0ZT2860zOZpixzEkSVpak+R5fuqw123OFlZ1w80UJDJVBcK V+dRuCAh7WOg5qr6IKZhqQ3r/CwZXEP9PagqapM+v4SrtbPOkNQGc6oIHJdNjLbZaNlO1UAp kC6OuekkH5h7UQIOlUdM/5iDJjhPyuyGM4vTSdJcG8uWMs8K8HzpZL6vk5hBBxNpJD9gv7JI Hgg8WMPM6owQxv5cVl0ExZAOoYFmt09GeRXe0335dKfJu/rpt2ftX+tOUsNhYyJ9fWzBnq6b /MjAOcZ79GR38UY4PcnKdwPYUc2qs+8UC8fpaH6NsFGzg2OZ9qQWp6N1GFgdemK4b/gI2ekc ezgJajrR0CA4khqwSyHxES0JNSJwlKSrYv8ImVT/uHbZprDIK7TqYiRPur9TW4SDnbsBHR5a fnt5e/7x+vKJMQWdFlWbYr0OmHg4fDj1VdiwDSDUw/qyusGIxFb9mPHCttg4w7Vg4WvsBFcz uJvkNS5V9dZZ/gt6NurUhKmhH99+/sZUDtaA1D+18iLFzBE5eD3sS7Wg2ft9JwA6t3ZYiV6Z WbS0bUUYfDKqOJcPlWNamUFIg8dhY4dQS9L3z9cvr8+WDW5DVPHdX+V/f749f7ur1Ebu9y8/ /gavIT99+VUNTcfDL2wk6qJP1LKRldK5i8D0mLj49vXlNxWbfGEskw+3K6K82K0/oPr2Rcgz 8u09+DZXhYyz0taunxiUBUSm6Q2ysOOc3+gxuTfFgkejn/lSqXgcXTvzG0QMkD5ylpBlVdUO U4di/GTOlpv6LLfsAp2D2Szv/vXl6fOnl298bseFmzxKsdSvKAWxO17OBqDX3X3KKJu0efve 1f84vD4///z0pKb9h5fX7IHP3/jiCQvagKixmcb3yIQFUHslaRBRAcF40dWm0vkvHv7EF/BE xNbcBvJ4biVGwGk6epBjnnDFllvI8UH/O9UyPd3lK8sIvvElZHu68YVw7s0jVvRm100Ejh7+ 8x9PMuZY4qE4umcVZY0KxEQz+Bafb6mZiWGQsMiCWB4aga7oAdXXLNcG+VZvte4vuSlnk9SZ efjj6avqpZ4RYgTNSq0vyBmMuYRU6x94dkr2hIBNQm/ff9uzvn04bnC5zwiU5zFdjGVSbJcr jikStX2pRJLSiB+K7P/f2pc1t7Hr6r7fX+HK0zlVa9Bs6VblodWD1HFP7kGW/dLl5WglqhXb ObZzdrJ//QVIdgsg0Up21a3ae8X6ALI5EwRBwCzU9jZapnWEoYjta1V+pdpDReCCDla52cl3 t8ioolHbDVSlcFJxsMpJby//RAjg66s5JbCTmtjddHVzrt6UMqS/HLFx506LwPRS6wTTSx2C LmRUZr6Uc17K8GoApjeZt5XvXvARVOal5SAwbQ8C+yI3vdA7oSuRdyVmTO/0CDoTUbEitPUp KjPLtWatT+CBmrA4cbCZ4AizGQUozddMi9KfYjZlJKDSVoCjfOhODRPFgQMXTNHTY+r84rj2 6unCp9XVUVVyhSMqG9WhazydtMzLAqFhZIsh2ni5GKatZpyG1dekqGHBGE54kt/wleREK1Ix KyUmoY29dR+jCnI1bb1UKiEQPlxOxqFQQLIlGBtqqT0NKc5qDHETG4YTvVEacy4S7o9fjk8D m7uJ7bGjV01GtWEJgh1KC3VyX+1+glbuji79d/vJanE5kNGvnVK6rDCPcBeV4XVXV/PzYvMM jE/PtKqG1G7yXVvFaQEH9TwLwpSFoaZMsI+iRs5jAboYA7ZQ5e0GyBjWviq8wdReVenjJCu5 cxLDKWdmmHlQbCpM6HpMDpMmI5lYXk2nq1UboMxq00+N24Y7FpWdwV3Zspw+UhJZCraqcJZ+ AQsiGsl7X/unAJXh97eH5ydzsHUbSjO3XuC3H9hT/I5Qxnfs+YvBo8pbzehabnD+rN6Aqbcf z+aXlxJhOqXuAk/45eWCxl2lhOVMJPBQyAa3H0d1cJ3NmT2SwbXshLZJ6HfdIZf1cnU5dVuj Sudz6jvbwPj+V2wQIPju61MduIAPtiIZX07alC2oeGCKIwLo+FltFlIuJeLTZ3/dnQwL7a4H WcVcP+iJQdliWocY40k0UcR0/j3W+msR3t6o01yT2sm0Zp2FMkC4LmN8mQrne+lb+k+m8Dyl cVjVVytcm3qWCWWpbhzPIgYWczwVrZvjv+TpkIq/BlpRaJ+wKNsGsD0FapA9UIaD+5hORfjN nk6tUx/Geuv5PrVIoqidH6GwzwfehMVp86b0SWSQemVA32tqYGUB1LaORNzTn6O+h1TvmRfM mmob9V3tq2Bl/bRcNiiIO2zY+x+uxqMxVSb7U+ZBGY6sIMzPHcByumJA9kEEuWFr6sGZdMKA 1Xw+brnDCYPaAC3k3p+NqJsEABbM2Wrle9xzc1VfLaf0/RICa2/+/83DZqscxqIHgZqq+4PL MfVWjZ42F9wT52Q1tn4v2e/ZJedfjJzfsAaCnICRLdAVXDJAtqYPbCsL6/ey5UVhwbDwt1XU S7ovoZPR5SX7vZpw+mq24r9pwEqjw4T9l2BKQ+ml3jyYWJR9MRntXWy55BhezKnHqRYcliC5 Wnn6yq3R2AIx3iaHAm+Fq8Km4Ghi5xdmuzDJC4wRVIc+c8zTWRxSdrQ1SUqUPxislIL7yZyj 2xj2fmpCsWeBSLqbZ5YGnfBZDZwUy0u7ybpIjDaIYVotsPYns8uxBVDLDgVQYQQFIBbSHoEx i6iskSUHptS1GnoFYG63Ur+YTqh7bwRm9EUXAiuWxLwLxedhIJBhQDjeG2HW3o3ttjEPTryS oZnXXLKwJmjKxBNq6cseM0rI2mGXi5djOgRuu8/dREoyiwfw3QAOMNUiKB3VbZnzkvaitF1L HUKbM6vw2Rakhhi6V24S7o1Kh7HUtaULfo/bUBApW3+BWVPsJDDVGKRMF/3Rcixg1Ci6w2bV iNoUaXg8GU+XDjhaVuORk8V4sqxYgHYDL8bcAbyCIQP6EENjlysqi2tsOaUOIwy2WNqFqmCn Yf6+EU3hVLF3WqVO/NmcOrWob5LZaDqCmcU40avD1FnpdtFChQ1l3jhBpNSOTxluFARmav3n 7qWjl+ent4vw6SO9UQBhqAxhh+fXIW4Kc6n49Quc/q3dejldMD/PhEvbjH4+PB4f0A2zcgJK 06KdYFtsjbBGZcVwwWVP/G3LkwrjHnH8isUPir1rPuKLFP1BUDUrfDkulRPRTUGFtaqo6M/d 3VJtsCezI7tWknyp61VZ007gOEtsE5BnvWyT9BqK7fFjF3oafS9ri+BTuxL5V59V+HpokU+n kb5ycv60iGnVl073ir7ZroounV0mdfSpCtIkWCir4ieGbbOmBXIzZslqqzAyjQ0Vi2Z6yHgg 1/MIptS9ngiymDofLZg4Op8uRvw3l/nms8mY/54trN9MppvPV5PScm1mUAuYWsCIl2sxmZW8 9iBLjNl5AoWLBXeqPmeOhPRvW/CdL1YL20v5/JKeHtTvJf+9GFu/eXFt0XjK3fkvWeSwoMhr jHlGkGo2o+eEPho2ZUoXkymtLohB8zEXpebLCReLZpfUNRACqwk7Band1HO3XicKcq3DtC0n sMfMbXg+vxzb2CU7EhtsQc9geiPRXyd+8M+M5D7Gwsdvj48/jLaYT1jlw7sNd8zfkJo5Wmvb +fgeoGhNhj3HKUOvhWG+5FmBVDGjl8P/fDs8Pfzoffn/G6pwEQTVn0WSdIY12hRU2bjdvz2/ /BkcX99ejn99w9gGLHzAfMLc+Z9Np3IuPt+/Hn5PgO3w8SJ5fv568V/w3f+++Lsv1yspF/1W BEcLtgoAoPq3//p/mneX7idtwpayTz9enl8fnr8ejCduR5E04ksVQuOpAC1saMLXvH1ZzeZs 596MF85veydXGFtaor1XTeAoQ/lOGE9PcJYH2eeUaE61QGnRTEe0oAYQNxCdGn2LyiRIc44M hXLI9WaqHRo5c9XtKr3lH+6/vH0mMlSHvrxdlPdvh4v0+en4xns2CmcztnYqgD4r9vbTkX1g RGTCpAHpI4RIy6VL9e3x+PH49kMYbOlkSgX1YFvThW2Lp4HRXuzCbZPGQVzTGON1NaFLtP7N e9BgfFzUDXvuEF8yBRj+nrCuceqjl05YLt6O0GOPh/vXby+HxwMIy9+gfZzJNRs5M2m2cCEu 8cbWvImFeRM78+Yq3S+Y7mKHI3uhRjZTt1MCG/KEIAlMSZUugmo/hIvzp6Odya+Np2znOtO4 NANsuZbFeaLoaXtRHZYcP31+kxbADzDI2AbrJSAcjKjusQiqFXN5phD2zH+9HbM4J/ibvTgG WWBMvcsjwN4TwwGTBRhMQaCc898LqsylZwXl1BNf2pGu2RQTr4Cx7I1G5B6kF5WrZLIaUeUQ p0wIRSFjKv5QHXtSiTgvzIfKg+M/feBSlHC+H7ufT9LpfEraIalLFo0s2cEKNaP+hmHVmvFQ eAYh8nSWe9w9fl5gREKSbwEFnIw4VsXjMS0L/mYGOfXVdDpmyvG22cXVZC5AfHKcYDYvar+a zqi/SwXQO5yunWrolDnV5SlgaQGXNCkAszn1+d9U8/FyQjbGnZ8lvCk1wrx/h2myGFFTnF2y YJdFd9C4E3051U9pPv20NeL9p6fDm74jECbmFXeNoX7To8XVaMX0kOaKKfU2mQiKF1KKwC9b vA2sBvJ9EnKHdZ6GdVhygSL1p/MJ9dtgFjiVvywddGU6RxaEh67/t6k/Z7fWFsEabhaRVbkj lumUiQMclzM0NCssldi1utO/fXk7fv1y+M5tW1Gp0DAVC2M0W+7Dl+PT0Hiheo3MT+JM6CbC oy9n2zKvvVqHlCG7j/AdVYL65fjpE4rZv2PEq6ePcKh6OvBabEvzQk+65cXXqmXZFLVM1gfG pDiTg2Y5w1DjToBREAbSo9dmSekjV40dI74+v8E+fBQuo+cTuswEGA2cXzLMZ/Zxm0Va0QA9 gMPxmm1OCIyn1ol8bgNjFp6iLhJbmB2oilhNaAYqzCVpsTKxPgaz00n0mfHl8Iqii7CwrYvR YpQSE8B1Wky4+Ie/7fVKYY4Q1UkAa69kpu7VdGANU16lCaVgXVUkY+bTSP22rqg1xhfNIpny hNWc3yup31ZGGuMZATa9tMe8XWiKijKnpvCddc5OQ9tiMlqQhHeFB+LYwgF49h1oLXdOZ58k zicMi+eOgWq6Unsq3x8ZsxlGz9+Pj3j6gDl58fH4qiMoOhkqEY3LSXHglfDfOmypg6J0PWZi ZxlhqEZ6AVOVEXPwtF8x18pIJhNzl8ynyWhvx5n8Sbn/4+CEzJJaBSvkM/EneenV+/D4FXU8 4qyEJShOW4xRmuZ+3hTU1JfMnjqkRqZpsl+NFlRc0wi7EkuLETU0UL/JCK9hSab9pn5TmQwP 5ePlnN2ySFXpRV36Qgh+oH0qB+Kg5kB1E9f+tqaGYwgXcbYpcmqsjGid54nFF1ITaPNJ622P Sll6WWXe2XbDJw1NBBbVRfDzYv1y/PhJMCtE1rrCsBU8eeRdhSz98/3LRyl5jNxwKJtT7iEj RuRFw1FyQKB+B+CHHQEBIe3XYJv4ge/y9xYULszdgRvUiq6DoDK2sDD7URiCnW8OC7WtAxE0 HhQ4uI3XNAQiQjHdsTSwHzsINUgwEOzDVu5JMV1RyRUxZQ9gQfWV8gpnM9puqBEtfG+1WFrN xc34FWLcKjD/BYrgRHBUPWwb6yvQ8jalsIKGQFEICmoCBJV30MLODd3CcEjZT1pQHPpe4WDb 0hl49U3iAG0SWiW+62OyxuX1xcPn49eLV+e9e3nNWwntSTex7wBtkboYRkDMyvdjG99NBGb6 MPuEtTG9UeA4Dz1v0fSLQEJOYHUL+drowUygdYE5eDmaLttkjBUnuHl2mUw4btwMxX5N2vvk kgV4YfuN2XVKis/HPJ7NB+U7xKMl6cYtHCB8ZC7oKtAToXNcFL0RWqS6mi3xPEc/2nvY8BtO 6PLZLvXnSZLu3SOpzi5cN9jshY3F9GWDhvKAmhJrrKC11lAV0qtLkOr8aMP7rfDg0IWnONyJ fDq1sck7B1vQogELlqcskJCD21NrgyHL3Av5qjpkDpn6JyClOy/o+5AT8XTEtGdY/6nC8694 TDJtDFLD4J7wwzkGIYUEuV/TYKTqfcsWO16FQvCFKGY/o3j1lr4NM+C+GlPlvEbtHcmg9p5k wjKwyDUaQ1M6G0u8rI6vHVTf5NqwtXEQUHv7hQZxCiJ4hNKE/tWpSGCDQuM8Co7B1B2ng+Lq nxbjuVPdKvcxzqsDc4eDGtTjSkItj8Ka4DqX43i7SRqnpPjC6IQZb3RdYA0xUEZHlGJxMGd5 +kyzvcUQxa/qddFpb0FXMSXuHCy04glsU3TyEjAywt0NP76MyOsNJ1oBcBDSTtdYeDYDL+Kh b2gPgU4aNcyWa+WhU6C0m33yM9pUpI0n3nBCQ5zifmfVTYeJEQg62AuvQe9dTzkYdeqsg8YI xTgRrMJn1UT4NKLYNwETkTAf5eLSo1bePew0tamAUGXj1S4ohnC7Yh2litHJGaepdzAqIIvQ 2/EehPuBEWJ8KDmJjMMlAUcJAubPWsiqwp0jy4W210tjuyv3E/TI57SGoZewi/PE2lvV9HKu HgolTYW6UbfP1XIudYomuG2itmjIV0W7TJ0MKb2p6VpJqcv9mcTaY7pEL/ZeO1lmcFypqNjA SMIsQi9v7rcAbdhxzoD7yh1AypLdbQuvKLboozANUujzEafmfpjkaHJWBqH1GbXfuvmZV/TX y9FiJnSJdk2kyPshMg6QiYAznwon1G0shTvt0qHteJalEgmDVIppFMHurNJTHhqcBhBcKVNY WgBPNLcujGYtXadnj8UAIUxTu9i9Hyucq9vAHt2cLpSnfyvuVqN3NnpbhEOfddrLvIUICjve MyGq5WuY7Bale+Lnll8nUQuKs7b3AoabjJKmAyShGLU2kR9PYTGASjg7dE+fDdDj7Wx0Kez7 6lSOkSu3t1ZLa9Fl7yRROD5vLyYNp3jpYj5z5rhy+WfEbb7mKgpvIpDlMACp1TI1MI2ZC3mF xu0mjWPjFvykfGUCVp8AX0kzjUEcJCEMzg8h9baZ0seW8IOfqhHQLhu1KHd4+fv55VHpdh+1 dZCrNMCTuK/e0VvO2gCc4S4m4PPv3yWcx9NwOYKq4WC3n7dBUHKKdk3o5ACDyICn5jxTyV7W pQ+C622TBWjFn5wecj59fHk+fiSNkgVlTh0+GKBdx5iWu1fkNLoaW6n0rWb1/t1fx6ePh5ff Pv/L/PG/Tx/1X++Gvyf6DOwK3iVL4nW2C2Ia2G6NTq/DHTQbdUSDgcOpD3X47SdebHHUZOSx H3lk56e+qhwBn8DAIyHCTxj5AeWSgPbKytz9aet3Nah0AbHDi3Du59TFvkXgAQI1sTu6hOgF 0Mmzowq54gs363Moq4TcsYbe1COe92lD48w6YxSzxXroZRKjHrvtpH2L0MHcL+TiR7S1sl1+ 7S6O8/du4sR8qmxXQSttCuZCbYcPNJ0mNW+uxHx6L+vafvHm4u3l/kFdxdlLGffGW6c6+jJa 6ce+REDHtzUnWFbTCFV5U8J5xO89k7m0LWxt9Tr0apEa1SVzb4F2BgksQy7CV/Me3Yi8lYiC OCDlW0v5djG+T8aUbuP2SzXTgeCvNt2UrnbEpmBoArIgaj+5Ba5olt29Q1LOfoWMO0brBtmm +7tCIOJgGqwL9FMd722HOj3dPPKSvwoL+8y2k+5oqedv9/lEoK7LONi4jRCVYXgXOlRTgAJ3 En0LWlr5leEmpnomWKdFXIFBlLhIG6WhjLbMtR2j2AVlxKFvt17UCCibAqzf0sLuOapmhh9t Fiq/Dm2WByGnpJ46UnNdMiHoN00uDv9t/YiTKhaNQSHrEH1acDCnLunqsL8FhT9dD0N5oTno z7bapm3W4GoVoyOcDYgOY3LLTPLpV+QmqWMYF/uTZS2x1BKcCjb4aHJzuaLh1QxYjWfUlABR 3nyImEARkl2YU7gCNq+CTMoqpjao+Eu57uEfQe/UTOGOgHE0yH1R9Xi2CSyasuyCvzMmS1PU CrHhkDDCFjPPdzm0K8KzHLbjP5jEyMR2jd6AzM9qm9AZnzESOti/brwgCPn7In51rp/qHL8c LvTBg7p88mF9CjGcQaC8blD9+s5DS5UaNrEKL3LYlTtAMQ9ZEu7rSUulMgO0e6+mDuY7uMir GMaan7ikKvSbkj0pAMrUznw6nMt0MJeZnctsOJfZmVy67dNgH9bBhP+yOdC55Fo1NpGIwrjC QwMrUw8qd64Crjw9cHePJCO7uSlJqCYlu1X9YJXtg5zJh8HEdjMhI5p1YhwKku/e+g7+vm5y qjjby59GmFqt4O88S/ACufJLurATShkWXlxyklVShLwKmqZuI4/d4m2iio9zA7QYlAeD8AUJ meUgCFnsHdLmE3qe7+HeJ1prdMECD7ahk6WqAe5dV0m+kYm0HOvaHnkdIrVzT1Oj0gR3Yd3d c5QNqqkzICpDI+cDVktrULe1lFsYYaSMOCKfyuLEbtVoYlVGAdhOEps9STpYqHhHcse3oujm cD6hnm8zwV/no/zza70Ol4sqfhYeWpPQRIsvYBqBA70KIlXQgsQYvCC3XEKjMz90WXE7QIe8 wswvbwungNgLrP4dJCx1hrBuYpBJMvQblHl1U1LVW1Rlec26NbCBWAOWtVfk2XwdYnYwtDVI 4wqECvqO3VpP1E8QGmul4Fb7dcQ6DASvrDZsN16ZsVbSsFVvDdYlFeauo7Rud2MbmFipmF2K 19R5VPGdSmN8oEGzMMBnB2gTC4EtPdAtiXc7gMFUC+ISBZaALo4Sg5fceHB+jvIkyW9EVlRd 7UXKHnpVVUekpiE0Rl7cdhKsf//w+cDcn1t7qAHsJbGD8TIv3zDnqh3JGbUaztc4O9skZjGQ kIQTppIwOytCod8/vWvWldIVDH4v8/TPYBcoCc0R0OIqX+E1JduG8ySm9jJ3wETpTRBp/tMX 5a9o6/q8+hP2uD+zWi5BZK2haQUpGLKzWfB3F43Eh/MYnl/ez6aXEj3OMaZEBfV5d3x9Xi7n q9/H7yTGpo7IkSSrremgAKsjFFbeMNFYrq3Wmb8evn18vvhbagUldbHbNgSuLDcmiO3SQbB7 2xI07JYPGdBKhC4CCixUpKAc9lLqhUXHINnGSVBSg7WrsMxoAS0laZ0Wzk9pk9EEa4PcNhtY Kdc0AwOpMpLBEaYRnMDKkPky7y2fNvEGr8F9K5X+p+vQk3rf7Y/+O3Hlqx0MY5qFKV3QSi/b hNbg8AIZ0IOjwyKLKVT7oAyZQE5sV9ha6eG3CjPFhCy7aAqwZSK7II4cbss/HWJyGjn4DWzI oe1c80QFiiNmaWrVpKlXOrA7RnpcPCF0kqtwTEASGhHgyxA0FcyV7OFU7o69J9ZYcpfbkHrl 5YDNOtYvyfhXU1ic2izPwovj68XTMz6DfPs/AgsIA7kptpgFhgqjWYhMkbfLmxKKLHwMymf1 cYfAUN2hg+VAt5HAwBqhR3lzneCqDmzYwyYjkbbsNFZH97jbmadCN/U2xJnucTnSh62QySzq txZfYXF0CCktbXXdeNWWrXEG0cJsJxr0rc/JWngRGr9nQ9VqWkBvGqdObkaGQ+naxA4XOY31 67lPW23c47wbezi5m4loLqD7OynfSmrZdqYuDNcqTPNdKDCE6ToMglBKG5XeJkVP1UYiwwym vYxgn/HTOINVgomiqb1+FhZwne1nLrSQIWtNLZ3sNbL2/Cv0O3yrByHtdZsBBqPY505Geb0V +lqzwQK35lGACxARmcCgfqPck6D2rVsaHQbo7XPE2Vni1h8mL2eTYSIOnGHqIMGuDQn81rej UK+OTWx3oaq/yE9q/yspaIP8Cj9rIymB3Gh9m7z7ePj7y/3b4Z3DaN1DGpxHajOgffVoYHYW Aulpx3cdexfSy7mSHjhqTa+wtM+nHTLE6SiGO1zSfHQ0QR3bke6olX+P9gaVKEoncRrXp1cu cPrHOL6yHJnZ5wtUa0ys31P7Ny+2wmb8d3VDteaag/okNgg1zcq6HQwOyXlTWxR7NVHcSbin KR7t77XKEh5Xa7VBt3HQBcp498/h5enw5Y/nl0/vnFRpjCGd2Y5uaF3HwBfX1D1zmed1m9kN 6RzjEUR9hvb53QaZlcA+2EVVwH9B3zhtH9gdFEg9FNhdFKg2tCDVynb7K0rlV7FI6DpBJJ5p sk2pPF2DNJ6TSioJyfrpDC6omyvHIcH2NVk1WUntmPTvdkNXboPhvgZH9CyjZTQ0PpgBgTph Ju1VuZ473F30zzhTVQ9R04hmlO43bYVKWGy5qksD1iAyqLSAdKShNvdjln1slMc02rgCPdR4 nSpgu6hXPDehd9UWN3jg3VqkpvAhBwu01kGFqSpYmN0oPWYXUiv7UclgGWVp6lA53PZEFCcw gfLA4wdp+2DtFtST8u75WmhI5mR2VbAM1U8rscKkbtYEd5PIqCsk+HHaaV2dE5I7pVU7oy4P GOVymEKd4TDKkvqhsiiTQcpwbkMlWC4Gv0O9kFmUwRJQX0YWZTZIGSw1dclvUVYDlNV0KM1q sEVX06H6MBf9vASXVn3iKsfR0S4HEowng98HktXUXuXHsZz/WIYnMjyV4YGyz2V4IcOXMrwa KPdAUcYDZRlbhbnK42VbCljDsdTz8fjkZS7sh3DA9iU8q8OGul7pKWUOMoyY120ZJ4mU28YL ZbwM6YP3Do6hVCxqVk/ImrgeqJtYpLopr2K6jyCBq8LZhTP8sNffJot9ZhRlgDbD2F1JfKdF QMnGmBmNaFfSh4dvL+g95PkrumElGnK+1eAvdbChdnwKLMPrBkPFWms6xuSMQQbPamQr42xD laRO/nWJcn1goebq0sHhVxts2xw+4lnKxV4iCNKwUk8j6zKmpkLubtInwWORkmi2eX4l5BlJ 3zGnjmFKu4/KVCBDU5JxkFQpRo0pUJHSekFQvp9OLhfLjrxFa9utVwZhBq2BN6h4rabkF5+H LHCYzpDaCDJYs9BhLo+yVivoYI5AHsX7WW0US6qGpw9fpUQNqR1CWyTrZnj35+tfx6c/v70e Xh6fPx5+/3z48pWY0PdtBoMaptxeaE1Dadcg32BUGanFOx4juJ7jCFUclDMc3s63LykdHmVN APMDTZTR/KoJT5r8E3PK2p/jaI6ZbRqxIIoOYwzOJNzwjHN4RRFmgb6zT6TS1nma3+aDBOVM Am/iixrmY13evp+MZsuzzE0QY8DezfvxaDIb4szh7E6sY+z4vjZ7L6P3RghhXbPrmj4F1NiD ESZl1pEsYV6mE53WIJ+1Ng8wGHsYqfUtRn0NFUqc2ELMHYVNge6BmelL4/rWSz1phHgRPh2n DwpIpnAizW8yXJl+Qm5Dr0zIOqOMVxQRLzHDpFXFUhcz74l+cICtN0YSVXIDiRQ1wCsK2AF5 UpNQsHHqoZNFi0T0qts0DXEbsbahEwvZvko2KE8saAKP0TXP8aiZQwi00+AHjA6vwjlQ+GUb B3uYX5SKPVE22qihby8koC8t1NZKrQLkbNNz2CmrePOz1N19fp/Fu+Pj/e9PJ20TZVLTqtp6 Y/tDNsNkvhC7X+Kdjye/xntTWKwDjO/fvX6+H7MKKI0pHFFBarzlfVKGXiASYGaXXkxteBSK d+fn2NUCdz5HJXPFqBOOy/TGK/FyhopXIu9VuMdYJz9nVGGQfilLXcZznJAXUDlxeK4AsZMV tdFXrSamuYUx6z4slbAI5VnAbrEx7TqB/Q4NfeSscZVs93PqrBhhRDoh5PD28Oc/hx+vf35H EMbxH/QhH6uZKVic0Qkb7lL2o0VVUBtVTcMiTu8wvm1demaHVgqjykoYBCIuVALh4Uoc/veR VaIb54JI1U8clwfLKc4xh1Vv17/G2+19v8YdeL4wd3F3eoeBJT4+/+vptx/3j/e/fXm+//j1 +PTb6/3fB+A8fvzt+PR2+ITHnN9eD1+OT9++//b6eP/wz29vz4/PP55/u//69R7kTmgkdSa6 Uhrzi8/3Lx8PylHk6Wykn2EcgPfHxfHpiK7Tj/++54EvcEigaIjSmbXjbXwf9oFmg+ILTAO/ TlC3iEKQUDPGjCMbeJkwrSFlmXqljg3qinY8Grk8evuqpORlkyl7AUcoVvVA5z54xui7g2qd Ow5848QZTo9I5LbqyMNN3Ycksg+o3cf3sBAoLT7VVla3mR0ERmNpmPr0KKTRPRUSNVRc2wjM 92ABa56f72xS3Z8lIB1K+Bgk9QwTltnhUkdclL+1AeHLj69vzxcPzy+Hi+eXC30QOg0uzQx9 svFYRC4KT1wc9igRdFmrKz8utlQStwhuEksxfgJd1pIuyidMZHTF767ggyXxhgp/VRQu9xV9 wdTlgDoOlzX1Mm8j5GtwNwG3cebc/XCw7OkN1yYaT5ZpkziErElk0P18of51YPWPMBKUdY/v 4Ep99GiPgzh1cwgzWKb6Z3HFt7++HB9+h03o4kEN508v918//3BGcVk506AN3KEU+m7RQl9k LAOVpfYE8O3tMzqLfrh/O3y8CJ9UUWAJufjX8e3zhff6+vxwVKTg/u3eKZvvp27PCJi/9eB/ kxHIQrc88EE/zTZxNaZRHiyC3KJVeB3vhBpuPVh1d10d1yqkEqpMXt0arN1m86O1i9XuSPWF cRn6btqEGlwaLBe+UUiF2QsfAcntpvTceZlthxs4iL2sbtyuQfvDvqW296+fhxoq9dzCbSVw L1Vjpzk71+aH1zf3C6U/nQi9gbD7kb24oIJ0exVOhO4r/Xo8CuLIHa5iPoPtmAYzARP4YhiE yj+XW6MyDaShjjDzZtfDk/lCgqcTl9scG60BGK/NcVHiH4DnY2Hf23pTF0wFDF+ErHN3H6s3 5XjlZqwOnf3ufvz6mb3aJdXwQnc6DGBtLez9WbOOXW6Vc+m7XSuCIFDdRLE4+jTBsTzoRqGX hkkSu+u5r55dDyWqand8Iep2G9YjEFpDwiJ597vaeneCHFR5SeUJ461b2YWlOZTW67IIM/ej Veq2ch267VTf5GLDG/zUhHocPT9+RVf47ODRt0iUMHP9rgWpNanBljN3wDJb1BO2dWe7MTrV Pubvnz4+P15k3x7/Orx0Qf6k4nlZFbd+IUmCQblWUawbmSIuyZoiLXSKIm1uSHDAD3FdhyUq uNmVCRHnWkni7ghyEXrqoFTdc0jt0RNF+d26fSByt/WcuKO4WzU6WIDj3U2cZULZkKp9eFbS vDsRW7k3NccSetsdjJToWMLYLMOfV8Qz6VOv3MG6BB+RRM0QjSWB6Hnp0BLFecwIRr+UYSWM RcrsqZ74Jd7zGQ3Xrmf5IHdeT1cqNVQOrM5xcafTQxza00Fbb5Pg/WQ+/ym7Ui5obnJvdL55 f7kbrn/C2nfCebbiyv85Ex5JzzEFhedNhvuziP1874fCEU6NZShpKQ9R4zBwcIrNXWlZzWsV IWHoaEc4xE21o9byntuRQWo6Q40FmfdElY51LGcYL3Luvi9XGfA2cBdK1UrF2VT653CmOAUj uSHQQ1gwlDWTQrxd3KQWduLN4poF8nNIrZ9l8/leZjGZM6NpQr4eWIKVL5OhkRWnmzr0BzZX oLuhHGizONEjaGm3YVJR1zAGaOMCLU5j5dfhXMq2TuTe0M+kRZJybFwIsoWaflGIk3NgBLA3 4ISiHAhXoTyOFfFaXgwUbaizFHFblPI3vTTJMdzCZi+XltAdy012kalcnorEolknhqdq1oNs dZHKPOo2wg/RSARfjIWOuxlYb6ul8oWEVMzD5ujyllJedrfkA1RUW2HiE24ua4pQ292rl5Gn t2xaosZAqH8rZdHrxd/oePL46UnH/Xn4fHj45/j0ifha6q/I1HfePUDi1z8xBbC1/xx+/PH1 8HiyXlFvEYbvvVx69f6dnVpfGJFGddI7HPo+YDZaLXrO7uLsp4U5c5fmcKg9Vj2wh1Kf3qj/ QoN2Wa7jDAulfDRE7/s4sn+93L/8uHh5/vZ2fKJ6G62Rp5r6DmnXsNnBOYHaY2GgB1aBNSyn IYwBejWr7KvU3axE7Zzjw9k/89FsqlQulunQoyxJmA1QMwwJUMds8crLgPlpLlFgypp0HdLL P23oxjzXdB77MfwFd96EoW7M43Qyc7F2+CjDT4u9v9WmFGUYWRz4rjvCQ7txQMaCGsSZcRlR 8EXWR1eyNdvY/PGCc7haKljp66blqbhCDH5SQ0aOwxoVrm9R29RfsDHKTLxXNCxeeWPZNFgc MA6ESzmgLdjxmCtRfGJvm8RrV+/nE+WYrejTdlOmW21Y9Y02wBxiGaKWXhbkqdiS8tNARPV7 V47j41U8W3L1wp1WzVio/JoRUSln+Xnj0LtG5BbLJ79lVLDEv79rA7p569/tfrlwMOXTuXB5 Y48OBwN61N7zhNVbmNQOoYJNzM137X9wMN51pwq1GyZJEMIaCBORktzRK0hCoK+LGX8+gJPq dyuSYJUKElTQVnmSpzx2yglFY9/lAAk+OESCVHShsZNR2tonk62G7bIKcVZJWHtFPXoQfJ2K cERt5NbcZ5ByRoS3vhzee2Xp3epVlopXVe6D4Byr7QgY6BalnPRRt8AawudhLVv/EWd3zJlq lg2CLexOzAutoiEBrY9RqWTvGUhDi+S2bhezNbV3CZThlJ946jHrVunPhO2kCuumUMzMo1VP r6ERlUnfMIu6SUdy1IcU/hkXi0/VsyAVhm5xrrzI05FbvDKJqNXlTZzXyZo3Qhmy9lftojdK geKn/R1lcPj7/tuXN4yg+Xb89O352+vFo7aYuH853IPI9O/D/yUaVGWRdxe26fq2Rg+iC4dS 4cWMptJtkZLReQE+FN0M7H4sqzj7BSZvL+2UOGoSELzxVer7JW0ArRRjRxMGt/T5c7VJ9ILC Tov+lWSzCV2ODvPaPIqUgQujtCXviWsqSyX5mv8SNsss4S/7krKxXz34yV1beyQrjHpW5FTp kxYx9wHhViOIU8YCPyIaSRS9yaMr3qou2foAa0a3BO+CiizYHbpBm+k0zKOALixRntXuM1NE K4tp+X3pIHSFVdDiO41HrKDL7/QFkYIwhEQiZOiBPJwJOPqXaGffhY+NLGg8+j62U6Oq2C0p oOPJ98nEgmG5Hi++U0EUVs4KJOGaIQULz9ovHuhMn+sJe1JjHNpFSVNtrZGjxmsQFvR1ZgWL LRuzaC5HH2Lk6w/ehs6VGo9q4tMf5zTFTd26A65Cv74cn97+0QGFHw+vn9zHQeqkdtVy3zwG xKeo7DZBeznABwEJPqvo7XouBzmuG3SI1j8d6I77Tg49B7766L4f4AttMpluMy+NT2+Q+xYZ rGV/w3b8cvj97fhoDqyvivVB4y9um4SZMupJG7zw5M5eo9KDMx26HXy/HK8mtLsK2PIxAgL1 VYAmxSovj4oVrs/PbYhvJtA7H4weusZ0BKsY6IkpxVVbKdjYmdisu9qRJbrjSr3a5y8kGEVV Bh2w3lrj/MaDGaTrW+RK9KnsdjC4UzNlyK9fW4fd9n1SJ/xqf/SDxkMtWHVb0RibBOwNFnW/ vYdVQ+LS0R/tsuq3BzaKXsy6nd0YPgaHv759+sSUR+o5KYiOYVYxzws6D6Ra251F6AaaYx6n MgYximnElJosj6uc9zfH2yw3Pl4HOe5CFva+L1LLNAgaL/PAQ9eZ1nkFSdodYzUAC5sup0dM hOY05U97MGf+Ro/TMIjbll2xcrp29+S6+OZcVrf0o6lKmnXHSuVIhK07XLWFmxEG2wi3+P01 HC1d1dZkrIEXo5M9sMXJzfssYm/OGznd2/Og28+28j1nEGvr56ZiXgE1aeesaLtUmVDx7bAn 0ZiiPVhsosTbSOcEwxKXdePO2gEYqoMOdLkpvwGVJ1oVX6Us4Uxhx3Ay80AvV3iAsjtTHya9 iraRRYATBciMtDa+unQxVEedY+V2jqvNm9pcpfSiuyboKxZBbDdFUtJzP4S1Rl1999Gx7T4t cU5vXDGbaVMtyAVg7VC5pSoVzo2/1M5WNsoLGdvgzDDb6gDK5igFxbhInh/++fZVbw3b+6dP ZH9GdSceQ8MaupC9DsyjepDYvyelbAWslf6v8JhXn2P6rAG/0G4x0lsNZxWhC26uYReFPTbI mbwyVMHTgo0fRIeL7AjN4L48jKjOBE1NHqfCXAzsI5oGuWmJwuxnsIpPLwH48tQSQnTX4Sev wrDQm5LW96Mpaz+YLv7r9evxCc1bX3+7ePz2dvh+gD8Obw9//PHHf/NO1VlulORrn2KKMt8J brFVMiy3s3Wh3rsO96GzkVRQVu6ayaweMvvNjabAOp/f8Kfe5ks3FXNQpVFVMGv/184Ui/fs hU7HDARhCJlXp3WOkm+VhGEhfSjWFg39rltZDQQTAQ+m1kZ+qpl0zPgPOrFfXdRKAFPZWtTV ELK8nimxE9qnbTI0w4OBprXbzh6ld+UBGIQW2MCc+x/NA//fYUy5ytmOhincvbTZFSSwcmTu bodxhoJfhuZBa9VNERBURIlSDfKShj3rIatocpciH2xikQAPJ8AdT507+vVjMmYpec8hFF6f jLX6IcMrZc2ia3MsKC19nukQNUxBlkaVIL0ggqJtYU1OtCyi/BSqoJAnFnFjZ/J4kf5s988j 9SxoOD/yubDW0YzOckVNpo9Zg4UaDjngxUmVUNUTIlpEt9YTRUi9q7Dz3WGR0LzC9CgnRDjt B8siHFBNqkwoa5umvvR9nuVpCWhtNwd43ZT5tzX10pDlhR52zB8GTIS+Yc9TN6VXbGWeTo1g u2HUGegipto0DscEDdOqWNAhuJoryKlOwLao6JuEOhcyZVVxlGcF69v6qz7flZQGyPYMHe6U Khv42TaIswJnT3UT45nerjjJynhK4w7iCjiNpUWNOk6xWs73Oj2k/SHDKCgh7bAbQ/34ky4k JVVNQd8rl9cgtUVOEi3GOGPhBsad+3XdE6aPK6fvqgxOBtvc7dSO0B8heAOvYXPD5+JlruxW 7OekHe5lsK54aM6hE4SV5JpYCWR2ybuQom6EkyvIfR06zdXI8LqIHKybMjYu5zA0wfqeNbUt +UdNMTHmRBmzUHFn52TXY46+oSPUXomXVpx4mka/wqFOTfKYwMHOb+zQkKYu482GSQKnaSVZ ttD5+ROyXFoyLZTW1FIJ6GqEeHeJd4PY+mQu4/msG4F2p3WPijE/VVdt1H/y4nEV1Kl4s6Qa TZkVVbASDLMMUvWAqGjMIpFv3e8sOAiG+Up1nevQOyq9b+6F4W5poTe/w18w6qWBL2ghHgPT U3G7I5IXyoP5q/bahnv0IHmmQfXdgfbKJC0gHVelH1Lz1FdAqHPpHlCRe8suCva3GzwrgEFE SmTf3IoD3SkMU/XF+jAdl4oINrNhjhLtcpQnsDPtCSzD1Djwhon6FmeoqZKrVClZKLZLlQg3 lES9E1Guvh55AxeRjaDR3jZXasod/UwUY5DomCwzQx/rfI5YndkHPLG6Sq0rw6NJeQRTFo+8 oFdpHliQrcPjH8IH/rAzS4dh3evWVVn3fTwFU71fl5mjDeQrp9bmtkrPDTtL2XQBtk6RAzx0 ySxNJKL/2wREYHd/mdsH11G4IlpH9hOmnNIzP6+Epq7K9GR//243jsaj0TvGdsVKEazPXJQg FTpvnXt0b0UUJcs4azCIQ+1V+KhqG/snBdPpSnSt1I24VuPFFFPyKZr1E28qTlYFvNc0/6Pz DRjqKkC4cffLgh0o54CGg8iE+RAFpi4sxUWtvPFajiYoyXkxUMSoO+sk7jgo7YRaj4GNoERy NGEIHfXBzd5GVGOYGxcnyxCvi6xX/FDmKt5smRNgA7UYPK3CgPUYM4M61uAsPUdbp77EBJ3e SLhOU8TDxLBe7+iNPiHrCNxhnc72Ir1OxaLAzuqoHKxr7y6VUi6pUHPofSL3leIZW+H/ARI9 9GlzUwQA --aajvmco7yeehmz6r--