From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pg0-f71.google.com (mail-pg0-f71.google.com [74.125.83.71]) by kanga.kvack.org (Postfix) with ESMTP id 418096B0007 for ; Thu, 1 Feb 2018 23:31:17 -0500 (EST) Received: by mail-pg0-f71.google.com with SMTP id 79so14678989pge.16 for ; Thu, 01 Feb 2018 20:31:17 -0800 (PST) Received: from mga17.intel.com (mga17.intel.com. [192.55.52.151]) by mx.google.com with ESMTPS id a61-v6si1015980pla.689.2018.02.01.20.31.15 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 01 Feb 2018 20:31:15 -0800 (PST) Date: Fri, 2 Feb 2018 12:30:42 +0800 From: kbuild test robot Subject: Re: [PATCH] socket: Provide bounce buffer for constant sized put_cmsg() Message-ID: <201802021254.Mc6eJJF3%fengguang.wu@intel.com> References: <20180201104143.GA10983@beast> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="8t9RHnE3ZwKMSgU+" Content-Disposition: inline In-Reply-To: <20180201104143.GA10983@beast> Sender: owner-linux-mm@kvack.org List-ID: To: Kees Cook Cc: kbuild-all@01.org, syzbot+e2d6cfb305e9f3911dea@syzkaller.appspotmail.com, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, Eric Biggers , james.morse@arm.com, keun-o.park@darkmatter.ae, labbott@redhat.com, linux-mm@kvack.org, mingo@kernel.org --8t9RHnE3ZwKMSgU+ Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Kees, I love your patch! Yet something to improve: [auto build test ERROR on linus/master] [also build test ERROR on v4.15 next-20180201] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system] url: https://github.com/0day-ci/linux/commits/Kees-Cook/socket-Provide-bounce-buffer-for-constant-sized-put_cmsg/20180202-113637 config: i386-randconfig-s0-201804 (attached as .config) compiler: gcc-6 (Debian 6.4.0-9) 6.4.0 20171026 reproduce: # save the attached .config to linux build tree make ARCH=i386 All error/warnings (new ones prefixed by >>): In file included from include/linux/skbuff.h:23:0, from include/linux/if_ether.h:23, from include/uapi/linux/ethtool.h:19, from include/linux/ethtool.h:18, from include/linux/netdevice.h:41, from include/net/sock.h:51, from include/net/bluetooth/bluetooth.h:29, from net/bluetooth/hci_sock.c:32: net/bluetooth/hci_sock.c: In function 'hci_sock_cmsg': >> include/linux/socket.h:355:19: error: variable or field '_val' declared void typeof(*(_ptr)) _val = *(_ptr); \ ^ >> net/bluetooth/hci_sock.c:1406:3: note: in expansion of macro 'put_cmsg' put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data); ^~~~~~~~ >> include/linux/socket.h:355:26: warning: dereferencing 'void *' pointer typeof(*(_ptr)) _val = *(_ptr); \ ^~~~~~~ >> net/bluetooth/hci_sock.c:1406:3: note: in expansion of macro 'put_cmsg' put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data); ^~~~~~~~ >> include/linux/socket.h:355:26: error: void value not ignored as it ought to be typeof(*(_ptr)) _val = *(_ptr); \ ^ >> net/bluetooth/hci_sock.c:1406:3: note: in expansion of macro 'put_cmsg' put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data); ^~~~~~~~ -- In file included from include/linux/kernel.h:10:0, from include/linux/list.h:9, from include/linux/random.h:10, from include/linux/net.h:22, from net/rxrpc/recvmsg.c:14: In function 'rxrpc_recvmsg_new_call', inlined from 'rxrpc_recvmsg' at net/rxrpc/recvmsg.c:539:7: >> include/linux/compiler.h:330:38: error: call to '__compiletime_assert_119' declared with attribute error: BUILD_BUG_ON failed: sizeof(_val) != (0) _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^ include/linux/compiler.h:310:4: note: in definition of macro '__compiletime_assert' prefix ## suffix(); \ ^~~~~~ include/linux/compiler.h:330:2: note: in expansion of macro '_compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:47:37: note: in expansion of macro 'compiletime_assert' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:71:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^~~~~~~~~~~~~~~~ >> include/linux/socket.h:356:3: note: in expansion of macro 'BUILD_BUG_ON' BUILD_BUG_ON(sizeof(_val) != (_len)); \ ^~~~~~~~~~~~ >> net/rxrpc/recvmsg.c:119:8: note: in expansion of macro 'put_cmsg' ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NEW_CALL, 0, &tmp); ^~~~~~~~ In function 'rxrpc_recvmsg_term', inlined from 'rxrpc_recvmsg' at net/rxrpc/recvmsg.c:562:7: include/linux/compiler.h:330:38: error: call to '__compiletime_assert_77' declared with attribute error: BUILD_BUG_ON failed: sizeof(_val) != (0) _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^ include/linux/compiler.h:310:4: note: in definition of macro '__compiletime_assert' prefix ## suffix(); \ ^~~~~~ include/linux/compiler.h:330:2: note: in expansion of macro '_compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:47:37: note: in expansion of macro 'compiletime_assert' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:71:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^~~~~~~~~~~~~~~~ >> include/linux/socket.h:356:3: note: in expansion of macro 'BUILD_BUG_ON' BUILD_BUG_ON(sizeof(_val) != (_len)); \ ^~~~~~~~~~~~ net/rxrpc/recvmsg.c:77:10: note: in expansion of macro 'put_cmsg' ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ACK, 0, &tmp); ^~~~~~~~ -- In file included from arch/x86/include/asm/atomic.h:5:0, from include/linux/atomic.h:5, from include/linux/rhashtable.h:20, from net/tipc/socket.c:37: net/tipc/socket.c: In function 'tipc_sk_anc_data_recv': include/linux/compiler.h:330:38: error: call to '__compiletime_assert_1565' declared with attribute error: BUILD_BUG_ON failed: sizeof(_val) != (8) _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^ include/linux/compiler.h:310:4: note: in definition of macro '__compiletime_assert' prefix ## suffix(); \ ^~~~~~ include/linux/compiler.h:330:2: note: in expansion of macro '_compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:47:37: note: in expansion of macro 'compiletime_assert' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:71:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^~~~~~~~~~~~~~~~ >> include/linux/socket.h:356:3: note: in expansion of macro 'BUILD_BUG_ON' BUILD_BUG_ON(sizeof(_val) != (_len)); \ ^~~~~~~~~~~~ >> net/tipc/socket.c:1565:9: note: in expansion of macro 'put_cmsg' res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data); ^~~~~~~~ include/linux/compiler.h:330:38: error: call to '__compiletime_assert_1601' declared with attribute error: BUILD_BUG_ON failed: sizeof(_val) != (12) _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^ include/linux/compiler.h:310:4: note: in definition of macro '__compiletime_assert' prefix ## suffix(); \ ^~~~~~ include/linux/compiler.h:330:2: note: in expansion of macro '_compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:47:37: note: in expansion of macro 'compiletime_assert' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:71:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^~~~~~~~~~~~~~~~ >> include/linux/socket.h:356:3: note: in expansion of macro 'BUILD_BUG_ON' BUILD_BUG_ON(sizeof(_val) != (_len)); \ ^~~~~~~~~~~~ net/tipc/socket.c:1601:9: note: in expansion of macro 'put_cmsg' res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data); ^~~~~~~~ -- In file included from include/linux/skbuff.h:23:0, from include/linux/if_ether.h:23, from include/uapi/linux/ethtool.h:19, from include/linux/ethtool.h:18, from include/linux/netdevice.h:41, from include/net/sock.h:51, from include/net/bluetooth/bluetooth.h:29, from net//bluetooth/hci_sock.c:32: net//bluetooth/hci_sock.c: In function 'hci_sock_cmsg': >> include/linux/socket.h:355:19: error: variable or field '_val' declared void typeof(*(_ptr)) _val = *(_ptr); \ ^ net//bluetooth/hci_sock.c:1406:3: note: in expansion of macro 'put_cmsg' put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data); ^~~~~~~~ >> include/linux/socket.h:355:26: warning: dereferencing 'void *' pointer typeof(*(_ptr)) _val = *(_ptr); \ ^~~~~~~ net//bluetooth/hci_sock.c:1406:3: note: in expansion of macro 'put_cmsg' put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data); ^~~~~~~~ >> include/linux/socket.h:355:26: error: void value not ignored as it ought to be typeof(*(_ptr)) _val = *(_ptr); \ ^ net//bluetooth/hci_sock.c:1406:3: note: in expansion of macro 'put_cmsg' put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data); ^~~~~~~~ -- In file included from include/linux/kernel.h:10:0, from include/linux/list.h:9, from include/linux/random.h:10, from include/linux/net.h:22, from net//rxrpc/recvmsg.c:14: In function 'rxrpc_recvmsg_new_call', inlined from 'rxrpc_recvmsg' at net//rxrpc/recvmsg.c:539:7: >> include/linux/compiler.h:330:38: error: call to '__compiletime_assert_119' declared with attribute error: BUILD_BUG_ON failed: sizeof(_val) != (0) _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^ include/linux/compiler.h:310:4: note: in definition of macro '__compiletime_assert' prefix ## suffix(); \ ^~~~~~ include/linux/compiler.h:330:2: note: in expansion of macro '_compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:47:37: note: in expansion of macro 'compiletime_assert' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:71:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^~~~~~~~~~~~~~~~ >> include/linux/socket.h:356:3: note: in expansion of macro 'BUILD_BUG_ON' BUILD_BUG_ON(sizeof(_val) != (_len)); \ ^~~~~~~~~~~~ net//rxrpc/recvmsg.c:119:8: note: in expansion of macro 'put_cmsg' ret = put_cmsg(msg, SOL_RXRPC, RXRPC_NEW_CALL, 0, &tmp); ^~~~~~~~ In function 'rxrpc_recvmsg_term', inlined from 'rxrpc_recvmsg' at net//rxrpc/recvmsg.c:562:7: include/linux/compiler.h:330:38: error: call to '__compiletime_assert_77' declared with attribute error: BUILD_BUG_ON failed: sizeof(_val) != (0) _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^ include/linux/compiler.h:310:4: note: in definition of macro '__compiletime_assert' prefix ## suffix(); \ ^~~~~~ include/linux/compiler.h:330:2: note: in expansion of macro '_compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:47:37: note: in expansion of macro 'compiletime_assert' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:71:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^~~~~~~~~~~~~~~~ >> include/linux/socket.h:356:3: note: in expansion of macro 'BUILD_BUG_ON' BUILD_BUG_ON(sizeof(_val) != (_len)); \ ^~~~~~~~~~~~ net//rxrpc/recvmsg.c:77:10: note: in expansion of macro 'put_cmsg' ret = put_cmsg(msg, SOL_RXRPC, RXRPC_ACK, 0, &tmp); ^~~~~~~~ -- In file included from arch/x86/include/asm/atomic.h:5:0, from include/linux/atomic.h:5, from include/linux/rhashtable.h:20, from net//tipc/socket.c:37: net//tipc/socket.c: In function 'tipc_sk_anc_data_recv': include/linux/compiler.h:330:38: error: call to '__compiletime_assert_1565' declared with attribute error: BUILD_BUG_ON failed: sizeof(_val) != (8) _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^ include/linux/compiler.h:310:4: note: in definition of macro '__compiletime_assert' prefix ## suffix(); \ ^~~~~~ include/linux/compiler.h:330:2: note: in expansion of macro '_compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:47:37: note: in expansion of macro 'compiletime_assert' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:71:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^~~~~~~~~~~~~~~~ >> include/linux/socket.h:356:3: note: in expansion of macro 'BUILD_BUG_ON' BUILD_BUG_ON(sizeof(_val) != (_len)); \ ^~~~~~~~~~~~ net//tipc/socket.c:1565:9: note: in expansion of macro 'put_cmsg' res = put_cmsg(m, SOL_TIPC, TIPC_ERRINFO, 8, anc_data); ^~~~~~~~ include/linux/compiler.h:330:38: error: call to '__compiletime_assert_1601' declared with attribute error: BUILD_BUG_ON failed: sizeof(_val) != (12) _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^ include/linux/compiler.h:310:4: note: in definition of macro '__compiletime_assert' prefix ## suffix(); \ ^~~~~~ include/linux/compiler.h:330:2: note: in expansion of macro '_compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:47:37: note: in expansion of macro 'compiletime_assert' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:71:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^~~~~~~~~~~~~~~~ >> include/linux/socket.h:356:3: note: in expansion of macro 'BUILD_BUG_ON' BUILD_BUG_ON(sizeof(_val) != (_len)); \ ^~~~~~~~~~~~ net//tipc/socket.c:1601:9: note: in expansion of macro 'put_cmsg' res = put_cmsg(m, SOL_TIPC, TIPC_DESTNAME, 12, anc_data); ^~~~~~~~ vim +/_val +355 include/linux/socket.h 343 344 extern int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr); 345 extern int __put_cmsg(struct msghdr*, int level, int type, int len, void *data); 346 /* 347 * Provide a bounce buffer for copying cmsg data to userspace when the size 348 * is constant. Without this, hardened usercopy will see the dynamic size 349 * calculation in __put_cmsg and try to block it. Constant sized copies 350 * should not trigger hardened usercopy checks. 351 */ 352 #define put_cmsg(_msg, _level, _type, _len, _ptr) ({ \ 353 int _rc; \ 354 if (__builtin_constant_p(_len)) { \ > 355 typeof(*(_ptr)) _val = *(_ptr); \ > 356 BUILD_BUG_ON(sizeof(_val) != (_len)); \ 357 _rc = __put_cmsg(_msg, _level, _type, sizeof(_val), &_val); \ 358 } else { \ 359 _rc = __put_cmsg(_msg, _level, _type, _len, _ptr); \ 360 } \ 361 _rc;}) 362 --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation --8t9RHnE3ZwKMSgU+ Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICArmc1oAAy5jb25maWcAlFxLl9u2kt7nV+g4s7h3kbhfVpwzpxcQCIqICIIBQLXUG552 W3b6pB+eftzE/36qAD4AEFRm7iLXQhVAsFCPr6rA/vGHHxfk7fXp4eb17vbm/v774uvh8fB8 83r4vPhyd3/470UmF5U0C5Zx8zMwl3ePb3+/vzv/uFxc/Hz64eeTxebw/Hi4X9Cnxy93X99g 6t3T4w8/AiuVVc7X7fJixc3i7mXx+PS6eDm8/tCN7z4u2/Ozy+/e7/EHr7RRDTVcVm3GqMyY GomyMXVj2lwqQczlu8P9l/Ozn3BL73oOomgB83L38/LdzfPtH+///rh8f2t3+WJfoP18+OJ+ D/NKSTcZq1vd1LVUZnykNoRujCKUTWlCNOMP+2QhSN2qKmvhzXUreHX58Rid7C5Pl2kGKkVN zD+uE7AFy1WMZW0mSIus8BaGjXu1NL225JJVa1OMtDWrmOK05ZogfUpYNevpYHHF+LowsTjI vi3IlrU1bfOMjlR1pZlod7RYkyxrSbmWiptCTNelpOQrBZuHQy3JPlq/ILqlddMqoO1SNEIL 1pa8gsPj154A7KY0M03d1kzZNYhiJJJQT2JiBb9yrrRpadFUmxm+mqxZms3tiK+YqohV7Vpq zVcli1h0o2sGxzpDviKVaYsGnlILOMAC9pzisMIjpeU05WryDKvGupW14QLEkoHRgYx4tZ7j zBgcun09UoKlzLE1tZIrpkdyznctI6rcw+9WMO9867Uh8H6gfVtW6svzfnwwXTg1DSb+/v7u 0/uHp89v94eX9//VVEQwPG1GNHv/c2TDXP3eXknliX3V8DKDl2Qt27nn6cCATQGHjq+fS/hP a4jGydaHra03vEe/9fYNRvoVldywqoXX0aL2vRY3Lau2IBDcueDm8vysJ1IFp2ktlcOJvns3 eshurDVMpxwliJqUW6Y0aAzOSwy3pDEy0usNaBkr2/U1r9OUFVDO0qTy2jd5n7K7npsx8/zy +mIkhHsaBOBvyBdAzIDbOkbfXR+fLY+TLxLCB00kTQnmJrVBtbt896/Hp8fDv4dj0Hu95bVn DN0A/j81pf+aYM5gCeL3hjUsuROnImAhUu1bYiDmFEm+RjPwh0kSabJktLVHYu3UcuDmwIh7 NQebWby8fXr5/vJ6eBjVfAgCYFLWqBPxAUi6kFdpCi185cORTAoCcSwY0zzh8pGgmGZq61yl AAwQToP4T8FrOesN3JauidIMmXzx+ytbV5brhKAoYgAtG1gb3KihRSZjh+izZMR4luJTthCz MgxZJcFIsKdlQnzWK23H04jjHq4HvrEy+igRsUFLst8abRJ8QqJTzlzst+dt7h4Ozy+pIy+u MY5xmXHqy66SSOFZmVZcS05SCsADeI72TVUgcAcS6+a9uXn5c/EKW1rcPH5evLzevL4sbm5v n94eX+8ev457M5xuXJCmVDaVCc4cT9VKMyAO+1jpDFWYMjAw4DDJzaLnR4w03aaizUJPpQVP 2bdA8yANBaCwAxH64DHgsHOiIXxut86wGVwJNlOWGB+ErJI7RiYH49iarjBYJlTaxj8Ah9WZ 56b4pgPHkxErp3G4lLhCDlbOc3N5djLEbsUrs2k1yVnEc3oeeJ0GsLyLugDDMqe2KbyyQmsD hqZCrAqIpc3LRnuYlK6VbGrtCwl8JV2nrNiyuif6/DnhqvVoaaGaOZZw9ZpnwWa6YZXNRKmO nivGrpmaXzdjW05ZYmXQ/Vnd7ffEVH6MvqqPkq1fTDJoicbXcYHTS2wf4yO4XsoCqTTgniqd XBPDZJVywhDgFFA8oMgz93t0OczMLev0DCGR3W6aZ69zRLS1YhQcY+qUVZhqrMoNnowFeSoL QZ8iAlZzjt+DaCqbQB0YmsCckRTiLhiwcMufPAdiLCkFYCgdED5GTKsgmDhXkYZFbJgoJVYb QE1vvRWEZl5BbPYOy1k9z069hN5NBNdIWW3juU2mozk11fUGtlgSg3v0ZF/n44/YvUZPEgDX OCqQ/3oaUiABXrbtQu0RnfgHDnyLBEvvXwpSZX6gd5jPBT9v1PrO+HdbCe5nLUEAY2UOgUCl DmUqtjHsQYbU5k16r41hXrpsf4KheYKupQ9KNF9XpMw91bevlQcO1uKRPGVOunCp3whVuUyw kWzLYc+diGNnvyJK8dB3jipcMLqpJUgSAYdJy2qDi+6Fdxb9SOsQ2JgWDOMrLUsQDpoOeOAj izpxo98wfMsC9W0nGA9V1OYWvkRtjSFjWWwYwNoOOHBMKOjpycUEq3QFufrw/OXp+eHm8faw YP85PAKoIgCvKMIqAH8jiJlZvMv2kQhbbbfCJv1JyW+Fm99a5BXBvP50uhKVn5jrkqwCKy2b dFajSzlHICvQC7VmfaaW0jxkwqiL+KhVYKFSBJ7JMGFjWgvpNM85tRmHb50y52WANq33srrm aRJVRBfWSP2Md8doNCbdguzyYXyRfqwTpHVidcl2c6ncsMZkVfQizjIDbXZFmaQQf2tEDVnK iqWdXnNkqt2LrfCC+YB/wLhLEWTP7ZvlIF+Or9hU4YwIEqLOIXAFuAzg/YrERQwOIkWcCJsz EWkTF6DcqGImSYC4l57gRrHKk6eiVd5UrkDNlIKIyavfGA0Vx7IFTn1Mw+2KhZSbiIjFWPht +LqRTSLr03BWmId1eW+i3AkxwPB838ORKYMG6OSKDAkYDqBoD0AOc1MbL20ZPtqjYmtwi1Xm yuLd+bWkjl+Ulqm3Az7nXCJacQXegRHnwiOa4DtQlJGs7R5iyIGoEU65URVkpCAD7ncNYkea OJiCqAyzEwuEDZxmh5dSiySe3/tK1ckla0SstVbMo73FcoVszqVK6K0mJ+eUyWVcVNRYN48F 7kZdbXCGlslmpqSMcNxVTvpqY2LzmlF05S24GjMR7xpgZF02ax5idW94zi8AhxUamrMVvOdW EyQft4ZEOPlqpro2YYUzbEqSzMQmvGAIMogABZZcQCIQ6WNFcCLllsWpQq4wN4pdWLJkkfIU FVa0WFf1xwJ8is92BCBMxzonZNYdXc0ohjcPK8usKcHFobNFgKl8lRz8haXYqDntnkz7WRED 20FsSPqqcNbHUB1kve/r8iZEgd4LQ7hNnB22rFZN5I9oCWoB+IxursDIvU3KMkNk27VczicE 0vv0UY/qBgteYyTL8yPB0e5023Xf6CZdtEUeafMiUvb1aHW1+38xHwFAo+c3EEKMN8mDQfOk eLrTmuT0FGmYXhd73RoZ9hMHqsKeT2M9/5jVdmOTFMY1Z6jc/vTp5uXwefGnw7zfnp++3N27 oqHnfeS2e69jsrFsPYYKkLpzbV38dfG5YGiOXqqOkA3yJ9/GbTKgETZfnkYGF1ugq2WD2/aN pCM1VXLYzRiIY5Iks857p5Wym64VHXpHM8luz8lTBbaOiKFAOfAWz+tJtgTyzysEnaXeLxkI gyAVCRE5yGoxSKfOUlenXoJV2YYmvEENfhglNak7Dj1LYiRCHiWuIg70jLZhk9llbH1/nkVd 9QxjxXFa7bPKWT8/3R5eXp6eF6/fv7nK95fDzevb88FLza7RaTlzGVMekZIm3qbIGQHsw1wd zp9iidiF6Dmw05gKxWtwejn3a64ImiVK0S94GfQQmaf++AC2M+BAsQ+eqEMgQ794UtmQwS1c 1jqtuchCxLh+VydNRQCp81asPPffj8TAE9dUGT0/O93F2z0/gwDNj1UYQWWMi+ytBaXJmm6x B1i45RogxLphfn8GQjrZcpUYiXe5gQS7nzxmdFvR5egz4WdYLcIYqQpSzxoV5yHMraQ0UeFG XHxcpj3GhyMEo9PFA6QJkY51Yjm3IARrwxvB+T+Qj9PFUepFmrqZ2dLml5nxj+lxqhot01BV WHDBZpo+4opX2Fmly5Rb7YjnYVRgJZlZbM1kxta70yPUtpw5HrpXfDcr5C0n9LxNd/QtcUZg WC2ZmYV+esb7dQE6tG1rlVie7i4BuQbV0mcpT+dptkIhEOP5FebRV2Gyh1A1pGFAqAFJuIqk bkRIBkMIB7rMbHkRDgtecdEIizdzyMjL/eUHz7pdMxMzE1YymoJ9OBEinNurB4W7YXt4wRW8 ngJeNsEOYiCNmhJsfiKYIcm1GkGD8aJmZihP+WNMQC5mADsaTzyZn6PrKy6Di0xcCtG0BStr f7XKXsPSALo8YTEmajPJDSPyVpbgIomti8Rzj0ybwFarBDUmIHRGWYVfmOkGsIlaMkg4InUi lUsz3BwHHrza7sPT493r03PQKffLHJ2mVrYG+TDPoUhdHqNTd3swyWHDsryCU3gITMu+DWQ/ /tXO7lcgrNNl+o6okWCUKy9b4B83oXAUwwCV851rDPd+glMwD3djZHQe/aB7obSDGXjglVLe daBjemi9S04mZ6lVZOB1wwN3XEm8FwFhdfbOBNAuUpG6oy0vgubQVui6BDBynu7d9uSz1Io9 8dQDHPYKo4S8lpnLk78vTtz/oj2E71iTuKZk0z2SZao1rkQc0W0tcJ6MORk8pWUVVfvao9r7 DtanA9km1kFZwk7OwZW4ySRxvdIWuebJ1p/217Dw3pHnPHmJSl32gA9v+TTschBNeu6YDHTb EqRqSCobHbfmWDzn11Pi6o57FOZQQUY6roR268fFftoqxHrBcCffSS2pz4LXTR2fJteUqMxf OCyEdEDSXbPE5WeQj32dQhosGCYlhMpaG7tL6+cvgn24I+3Z0C+Z8D1tIyoq1Au+VnHTZ157 HaiWWGTylhBNoui80d559XcJrdK6G1uZurw4+XXpXUFKFPvmy0CuYG8KsIErkkoLg4vJG28v tGQQVxD3BKUtkbrXcV1L6YWG61XjwYPr8xxcoUfVrlHoBYruki+8dR2UOHtWq6HjcK9j9spw 3+e5DDqTOVMKM3LbnHDeCq9hpFJBbJVYBmy4bILnu9RtO6kpuz5vO7kJ1u8Pr9GAVyoE8ZuZ 6BVrE4UCiwDbFaSf2ANUTR0qGbKgXWD+JXrdHxnd9Djg4Z1IrIpcXS4vAmhcdBiKz+UNRqU7 51aXXIV3Bq/owBV4AFj4FzxZzoMfIMImbPC65kEqrl23pycngdO4bs8+nKQD5HV7fjJLgnVO kk+4BEqcwxcKbxWmevrYuPXsxfZ2w44OughOIRiApigMlKdhnFQM+zCmCzFjUbMvpdsK4YzA reHaBXTigTYvgQeeBc/rWuzbTMvQqDNbBgNFS4UcCFLYLSwzM72j4HvU0DMPSPTpr8PzApDo zdfDw+Hx1RayCK354ukbfgn04ldiuyJ7Ckr7HwWIof4xmqTAiyF4aSk7ckctA7b+zm7yIV1H cphw9buDrV4x/0gVnfoNBfzVA1x7xHosVPrSE/hBTNcKwCm1/wGMHekuILiNWJCtvY+MRiOl fd90PXMBxq0P+DTXbrV5LsW2rdyCF+UZGz4zmXnnltH+vrR/Y8GSSLqmY2krYgAh7Y8wNMaE rsqn5qQaY4h7+bCAi0M2N1YMjjG4QNALwiXINPruKSLz4MJWSJy8MK8Fn9vxuCRZrxWohpEq egVTMAVBb7IsbbSRoPc6O9q/cWtYc2xqgCxZvPFjtIlRuU1Tjtdr0pdK3d4k5MTgQFLVTafA Kx29ZuHfYPJfUDBTyGzy+qu1OrIBCPUNGj62568AGrWyKvcpDz8YGanZ5NJFPx72/RPsI+e6 COvoI4Xx6rf5DTsW/ABs4qsGT2XyLmMOnzv95KDGxoQEfL8OoYPzFzPU/uDg37lnGDZRE9Pb QToPlLq/mb/Inw//83Z4vP2+eLm9iftqve0lZ/LP94exHoGsoZn1I+1abtsSgDBTM0TBquBe vDUGDI965KOyqcuZ29wOqMSfLtiNrt5e+jC1+BcYwuLwevvzv70yCuVBEAJTWUsEc8lLmEgU wv2cTsu4YjNXtx0DqVI6jTQ31dMIGPMe5HPar2t0OEir1dlJiT0q7uNVIDGMMUEW00V3Ow8Z ovdgZCaoWJquU/ARSaB0k6XABtLBw00wM2u51n6YlwWSFDrloJFiBaBj/jkTRZpyXzr2ECj8 ys56TgdwvRFiIvFj9lky++nf9MC43Mb7qdXc/muieRYtHt0iGo8vgNLeqVpslvCdHgt102co 7bX58OHDyRGGSSXe59BFjbmhtb/s8HL39fHq5vmwQOujT/AP/fbt29MzqEOHL2H8j6eX18Xt 0+Pr89P9PaDNz893/3E3WAcW9vj529Pd42tgu3BsWX+ZLBBxPz54yBmBszq3rdIB7MKTXv66 e739I72d4CH6CgvW4M0NS+t5d09l5gZLd1POqzxprw7KJr/abblC3RFBimsp9lXchOHhbgpX poF0QsmZ+G+5bDt5pg2KGUg6DpY8dXe1YqA8J6f+TtYs6U+xpFwFtoXlJf+3oJz4SMKN2EsU LZ1p3OIakcy7k/3p9ub58+LT893nr34Hfo9djxHd2J+t9PoZbgTUXRb+W7lhk+6MdURX3E7p Xrb85ezX8an849nJr2f+u8LI+fJDqmJOuV96cSKJvt10osRmSFwaVKBxGZfjAt1AazT/5ex0 Oo5VPwsnZGMuz09icuc31a41u9betAgT4W4RUHVWrfnMvb2BbTbvGx/XCEyqedrgejas3Mx8 TtdxCNxrSzO2nWiKuvl295nLhXZ+IGH8nsw+/JJunA47qXW7O86Cqyw/Jk7aXwM8bqAePU3t LO18rqqz1/mqd27s78Pt2+vNp/uD/csfC9tgen1ZvF+wh7f7mz6Z76aveJULg1cDPWdT5uFF 945JU8Xr+EYvQY3x7/Q4XhxOyqOjC65TPTV8blic6Yoh5/EX7t1NHy6Dihb4pV4O1eH1r6fn PwHspkoYNaEblsrRmooHV0jwN5gHSWusKVM+b5f7Hz3hL/tHMfxl7SC2nWemt7qBMCBLHnQR keBq3GyymPUBGtzA3I7wXrAUobDaDduP3qAbSD1Ci9RxcSfv0Z3V7osHSnT69IFhqP8oUJHk +wNTXfnfm9vfbVbQOnoYDtu669zDkEERlS6p401pXoevzyHlxm9QRLMLBQWLmaaqwj7QMCMd VvcVqK/c8Jmw62ZvTQrHIa3JvGd647lsJgPj/gLXjAfUkuTtWqQwXU+4YQxbhhh+56bFimQH rYrF27WU5KDTZexOuVYJVske5jiOL7BikRYiOTbZIa7WiBbXgxr6EwfiKtnwH8i0WdnoPJ14 BSjzSsqU5AaeAv41vuo4rA31ZDqO71clSYxv2ZroxHi1TQxiPdjWr1ObLlPm4T2nkkkh7VlS sQY6L0teSZ7aY0bTMqDZOsG9Wnnlt+EPeXRi8btJlmDlki4rDxxV+uPbngG2cZSuogUicr/x y3d/fP90f/POfyGRfdDBx/r1dhn+6vwidoLz0N31NNt6nfF4wOO+/8VI0GazNrwErxDa2zLl DZb/B3ew7P3BQ7QRwevUzTY3x3cX0T6mftabErqM48v7zuNhfjX0HzMlp5DRSr/7vHrSnvPf HHy691I4ov3Gcz/SLoMP0HG0skgc2+pmX7OIOPGDOLhWMVsQH/qR9OT++8Su9RFvsVnhzW09 UUNhJTH39pqtl215lTjGgQrIPY3tQeL4R5+ww4ht2ZnIWBuwsJJozfN9EArt3LrY21wGEJGo o78fAjzui6c5xJBROosmNJ1BGipLgS7D6zBK4IdZgkFkwtCeypVN+GG1wUZX8tL9/zL2JNuN 47r+ilfvdC/6XUseYi96QVG0zbIoKaJsy7XRSVelT+XcVKVOkr63++8fQWogKdB5iwwCwHkC QAAEVEZyZz8HmBJ4MEEUUEkVrzeWaeIIU00bvMCG3LK4xgqWtXVG7RVnNc5zYX8kFU/3Dgdp IC3fC9WReVGUngmzT3hW7eu803BjZ+NIB0e9qxLpQJiJFGS5mcfR/VjREdbuz5XVOAshHETK qGF7ne9u2x7BWUadj9i6W6mJ7VEJ0ShIqVahC85qd/rQokSVTGWaenuvAoC5FcEnaxNjCoeM lImlcDgU0EYr13VWXMqAuM0ZY9BTK9zSGnonFIIlpZZuKM3BfUgWEA7NmTpqrhIwszkjORQl y89GQ2eNKoQ5YbVz0dnDwtLcWehrqbOgfKDGphGv1OZvl4EjuoA/joChWKKjrsDYalFm0tnE NKTdS0t/oyEww7ztTMOVUK632sBmmUurYw7SuQvVQ6P7ztORWPhs0QolzymWRNG4Fc2pdBTU XVwZvUVXHOdRLBqzhWPTQi+oBtSq19aNXpHc2x8QkEEdUUQYh9fKE/5n749v7951l67csd4z 7PTWe0dVKD6tyLnjvXogoiKgU+t1yA9f/v34Pqsevj69gL/a+8uXl2dLsULUMrNWvPpS3Jgg EMTADimhCqwK4eh8Cjm94SLN/6pV+6Nr1dfH/zx9ecR0VuLIUZ/9Neg7rN25vGdwhW2Xm6pB ppjYo6A2nfo00TtxUsWbNYweCnf9XtVSaMGjepdi6mSL4JA2Vj0NXI3tBMZK67S5EjF+UGJd oKqPtiIXF5BQl7zdX/phVV+z1HRvOu1eoD1Tgs0cjWqobewAIJlNqgOryKFRshkF59naU/oD LmO2kytAPpH8c8vVfwtbP3xoJ0XTAGh07PrutqzDUkwfofH07m4+SQRAuNQI6Ol7ir7QIBnf cfi7w29/gUK0NHAA6XozctR3jmjUGj0WnwhYdnkDZID6WsZrWo/Cqm6RMSGRW4wRg98dWFWG pB82K1D48Uxg1cBNn1d4mTU3C6+l+h2FuqrY6aPG7xEDbun05gWG5iST2RNEpfnz4cvjZOFA b2gKvBdlCtjYL3I/SeSgu/aH89X9p9DuqG+A5zJQd4rRhNwsz3jqGY9FbKNNLC1WAmFyWGod IgpS7YArQEBtXV8dcJKz0s1MAVQNJyEbehQEOSgw7IGnbk4HR6RTANRoTMNTn1SybOdHuLXx SEhOY6Tx/Nfj+8vL+7fp8TUmNi5OTqPtvRo6q3bxB8qT2htJC6zv+sP2ijYllPQPhqjsSGkG cSJV7VcDYO1hiZGqvF3dioUi9WGBybkWyeLCneuYEdO7hGEZ31N8V7HL3q8D11YWkajOGGvZ 9RAV8XzRTIakVFtng4zJDl+pBpvWWTQd3AWdwLIT07fI2JiTgAmaITgfAlticquheoy80i4Q Sgr1Xt8p1rVyZbceplUg+EX7QKHjD7VZgTJyA5nnWlw1Rycwx6492tPZZ5I78I6r2e0GMoCp lnmRAOhuD+Idelh0KCW3gVmODjOQa5PnfWpJdgMZ+FT2sSmABO6bnLIynkzKMidJX4kfj49f 32bvL7M/HmePP+Ci8ytccs4EoZpg3FB6CNyN6SgjEFTfuBnNx/ZCoP3vzme3y+to5mNAk2p3 5LYkYr4nW2QH5nl5wtSTHXpf8sKRAtqtdxO1LTt5cgKGwKQT4MQqlBK+wwaMlQfoZGtsOgho nNUZNM2ox8PY2SI6LuzvMBmilESJqq7cozg+yw0R0xf2MD/aaS+xQDzmzvWlA+3BW5dlvkCt zmtYrJbMTa6mOQOiM2TyOP8xePzTlw48K6a3yScT7c14sKI3A+dalDsvLp+BKVHzlKPh7mqS pwTi3VgmH5Upaccro6vQMYGtBX3RdjP2GmdNXZEhgRXVdKA1sa5891sU3e5IlkH0HWurybLi onVY1uW91UrNL1X8HOiYjp2qmJwmAzajS6smnSjO+D2rJiPymtOeWBvKBO5kpRXKASUZ4m2X pxuMnk0FPEYgrjqgz6cMXnBI1IFRc3uvVTugY71gvlseWydeB5Ol4BPgJZqAhLD3lT5DHUC9 71pQQsBbEymEet65mjZA7lhOjZsVbmlr2DeLb1N/8qnzVQX2ltqtGOk9UduRcOrURDKxT0wA qjrC7T4cW6FcBq8YTeOoxmoIl3U3Tdypb17fn2Adz34+vL5Zi/2kPmbCPFGhA23Wrw8/3ozd zCx7+MfhWKGMoigtFSBAoEQO10Oqi43mrN9fKiL+VRXiX7vnh7dvsy/fnn5OuWDdqB13s/zE Uka9KQZwNc18q7AuPWhLu/BSk24BdF4EXA17gkRtLteatV3MxkkGmYW/kc2eFYLVdohCwMCs TEh+VOdtWh/ayC/Aw2NhlhGy5c1CNrersL6J1vZHkz7gGEs0IPEkgWgkPRozEdPTzL54GaiB /VcbvDtZ9OgLdTqm0xTqUCFT6KnmmQtVM9WvfYV6Fepllmif5c4aWDz8/AlWV93M1ryZnuoP XyBSkjfTC+ALmt6pdDJVwVVOBC4yAC8T2u4bTKeoKybSu3VjFKwWmNODBnplMZnE4UbS42a+ bDxlra4CTWLwCA9ERAISxYO8Pz4H0dlyOd+H2uCpdgzIVxnZW4LiLI1HspfKOFCcIbIidhTr jDNSm5G3aweuLH2OeoTl4/Ofv4Hl9MPTD8V8K6KgTK9zFXS1mixxA4Xw2DseCEszUoVtRvUI ZKrS4SwOt7Dqx0MbTvDp7d+/FT9+ozBxJ2yhlT4t6N7SxCagiQWD3Fb8Hi2n0Hp0c9cTA6Kv MlfBbsMDdnc9STBZEnhxRveWQF6i8DNJGYT1dZeNhcBmpUbD7AsvA6Ao9M6qOkSzrrdptTn2 bZKUy2OhIyXdbI4apSVaYUp2mO5rxMvVatGgSeGX5KH9QpNgqna9m+cM8JNpl5Vqmc3+x/yN Z2qhz74/fn95/QdfWZrMHaR7HZfB8AQOQpZw6FeTk7beRH//7e8J7oQxKbXAtNSmGYrXw/gx IDS7jLQ9HhxwN3NwFBJxDipwSnCdTYFJhb63rgmG6z71NwJGftWA2pAzU4feB6Kf9XjSbDZ3 W1zF09NE8QZ74aFH58DxWrYDji2sNoTVwpFgUpK9Fif6QIT+HSSXxCQeq5CXIb+3vOwco80F 6lkw34dHPL19sbj/UaZiuZKlJLzxtsjO8xhTtJJ0Fa+aNi0Li1mxgK7Qo6RIcdViy2hFlQgl 41kHeXkgee0EgN+DHxZdWnaFfCe8mO0adNc0luTEqdwuYrmcWzAlAmWFhBCLEKUBREDnpgD2 hFUrdns0ntRBSVyZpbYhZSq3m3lMMktQ4DKLt/P5wofE1v1U37G1woCr1gSRHCJzJefBdYnb uaXXOgi6Xqyc25VURusNxll3ZhAJSPZOKBUdDOhkXaWAdtyYD7Q7SbbLjV0Xj4V0HLaCFwjg F9AqgQ3nCGjsG/0ZlwdWAt/2NkzXfhQ1vCV17Oz9Hdg4/SPt7/CCNOvN3QpJuV3QBrNs7NBK YGg320PJpDUANLmL5t5kNDBPk2sB1YSXJzHIcObJr8e/H95m/Mfb++tf3/VrEG/fHl4VF/YO ciq0f/asuLLZV7VYn37Cv/YzV4r/d+7yrZULK3Bqd/D8/vj6MNuVezL78+n1+3/Bx+/ry39/ PL88fJ2Zlxxnv4B38dOrkpdVFr/aOwOBqygCQkeJadbNzi+Yw0oMQPVzK01bN9YJZ5nu9D3F fwDPLThV5+nr47N+C/fN3dFGElBsGP6ux0nKdwj4XJQIdMzoAE6OISQF3zSkmCD9y88hvKx8 Vy1QwtUQoeMXWkjxq6+shPoN2Y0Tlx4C1jhNNglf4iDJ7tRr1Tz7M4cs9I7hsJ6Dd9EjBX41 ZEKsp0PMPEkl78WNyYoHJNjq2huPhoXe8tLIzi4LJdidpGfoa8aIMTaLFtvl7JedmvoX9fPr tDo7XjF9d2fN7x7WFgf0Vn/AewZ4I7yQeDAOQahaHQXEt9EDhh3zKtNOp+lqyLuNabzgKvI0 ZKCpT2cUw+5PSjj4HLoaAF8QFpLFCD2HYpuemxAG1KwBrfA+YKurCpIBT15VQZDSitDriDqG Mh5wUFuVFfqRv7yu1D+BPqhALRh4tfCEt1HB27MeI/2saKByZ1bjklJnlBgqNc9CbxIqRjpH XeTAcribYb65cnhqALYOmFZ31swE3yAAy/IwDhaGud8MknwmdRiZcwgsEwiyU+vj/O4uXuGR bIGACLWDSpIGRCggORQV/xzqZygD35108yCK7nweiB4HeYdRaioXmKmOOnJGdsFzw0+fFGvx 9MdfcFx2zrHk9cu3p/fHLxDVfCqIaktCxyJapP6t5VlxfkqCXFBX68ayBVr3BV1FKxTTeUIr gjtckToSbLb4elAcJMPZy/paHgpUL2K1gaSkrJnzqmoH0vHDYDZ+kMGeuXstq6NFFPCyHxJl hFZcFeJ4p8uMU9xOwElaM/flC0LVegpEfDIcW40GNLMzFeSzLRs4KOf4VZ+bKIra0P6UgRte YChVrgt83XXDnAsaOhpyvsanEEQkaPaB+8Ee2T16ghrE2m1VB15ec4J3REVxOCyYwts7s9D+ kuERvQERWvhZFBpcfN7bdTtVRYU+CgoHEEmZ996kOk0xps3KMakKknrrPlniizfJG7wbaGi+ 1nxf5PgmApkFjJvyBjvX3EpT4oYdTvJQt3RpKDlzO0a4jTqwTHI3mp8BtTU+vAMab9uAxvtx RJ8xFZldM15VJ9fYR262f2OBF51Ukjqt8fcTJAm8ZpY7jjq0aeHRVpzHxFkPK8PU3YONozHu LWWn6sw9xoKyGGf85SlP/a1pmh9E6mROwICExR/WnX12X1S3UQ1xQ3rFAYX6udl/ULfd6ROv pRN0q9s2d+L8Kdp8cOQcHM3hoYzQcJx2ghO52AHYLNTETpHhuTFtoP2P82lJ+ea7PVzs4Ex8 b2mk1IdCC/e8U8Az/lwyV3s9pmSAI8DK1JwIk2w1OKW45MuX8w/Gh2/iVePMnU+oysNKIkh1 Zu77puIM7BYu6oDYQNoE533lMRCSWB6vmFrQroaqA8kLp+4ia5YtC0SsBZz/6q2NXd3EystN 9O7yQW05rdzZd5SbzRI/aQC1ilS2uJx3lJ9V0ok2Ayn0WjmuUfAdzQM9vmMkyz9YjjlRTJlw 8uxA+JkuN4tN/MGK1d5HeSEYumg3i+0c2TxIE5QlQVDB40gp1MSNwc+49OXNgeCU1RUuIV3S zfxvLC6O3cozT7lz8uhHt1KPI50mLI5e3MBDG+IbIR5m6AQ0sWa60EjOnqq4aHUQoBleGdjV 7fgH0sh9Vuy5cxDeZ2TRBKy677MgI3WfBeamKqxheRtMh7p12jU8kaxzeRgTaQ+ukA94JT48 QCGgX82cg5wE9D2baLEN6B0AVReBh9g30Xr7USVyJolE106VOoNSrefLD9ZiBU6jFZqZJEJx I45RrtRnz4czWDJ2j2fJM+IcZpJu4/kCs2dyUjmsovrcBta7QkXbD1osi0zJy+rHjTS0w2eF goP1Kf1IPpdCOl0vBd1G25vKAk2i2o+v7JLTKNRKVdY2ivDFppHLj7ZgWVBQCTY1Pky1fqnE aU8t1ML5fwz9KXf3mrK8CkbwYw2mV+AVEwo+ugH1W86xZ9StStTscKqdTdRAPkjlpoBwlIoF IAHNZ52hDplWfmd391efbXUIhakD7BkCtvMauxy0sr3wz7kbechA2ssqNGEGgsVHzHTDK09o 7iYrIGI0EoA9+Ne8KKXrWZFeaNtk+9Cuu0tTfJCVpFIGhh+8xxM/Tv/I8phof2ce0O9ovBfF cWzt4Rq6Uyo9KW9ElDhc4mIh3F4bh++JLhtQSjTFewqQRyXqBBRagC4hCFGgZZ1L2SYKvIow 4vENCfBqyt9tAoc84NVPkJdS6IPEDz3A8fKA7y0X78ToPYUUD4bNRiAfdabCnNYYrj64x/jh hrWfwq5C7rBupsKOdWOjLH0Ugu01GwjKe37NR1WSOzLGoYBrb3yeVlyKFWYDZGc6ynoYEsLI BPu0Iq67i4MbWCcMKTmOsB+8tOF1gP7zNbU5IxulVaYsd3VB3eZWkSviW3x5EqSZwR3r8+Pb 2yx5fXn4+gc8UIEYIxkHLh4v53MR9OS9hC4aBcg2uMqt06a04WB+aqvzzAFHZYBMkTvkHz// eg9eZWsHMkvLAZ/G2ey7C9vt4E2PzmfPwcCFpBOzw4DNk1JHx/XEYASpK950mMEd4hm62vHr dhMVJ8mQYno4OH/Z0RQ9rFTCuZIvmt+jeby8TXP9/W69cUk+FVekaHZGgWBn893u+5Bhr0lw ZNekMMGKR/m/g6ktDT8cLIJytdrgb4Z6RJicMZLUx8Qy5B/g93U0t22/LEQcrTFE2gWfqdab FYLOjlDQFK5dFb8jldeW5jDHUBFwIKspWS+jNZqFwm2W0QedZGblbZpMbBYxvnAdmgWmK7BK au4Wqy3SCYJKDFpWkR1OeUDk7FLbkX8GBEQrAl2WREa0F/OQIeieXO4cqrC0dXEhF3JFEqs8 zcAi3S/iti5O9KAgt/qlqfGpARYJLaOu+dawcjHFar9oITyhI773sJbkJCvw03+kWeCG4yNB gJcdCGiRoNdcA8F+Fzse3yOiQplJB98Ky5l3xJzg1UFR1Gi7NQ9B0AdgBxrJU3bhuePfOSBr YT9JNOarlV1oU3j3+Dxqd+VTxXYI5gF5IVXFC6w6guy1lhhBqQOIsqJKQiiwPEX6T0LsEftt 0rHpF56qDyS/zweWH04ESZMmW4R+TwSj9sodyzhVSbGvyK5BkESu5lGEIOB8OqGzoSlJio4K INShfnv+aiLgBoKLTEd0tBgI861ZfNXFlFjr2UbxEphDDLWvaYEiDiRXDNUexR0T9eFI8yPu lpDUkUlWcZKpWaYYdlyF0zUWNjHDJQQ7BAwNfZ5gsynFZt60Re4EwjZIkt5FywaHdvbqXjUS QTypzuVAFs28ey3LuUcyzBqV5TEQlrJjzpq7u/V2AaqcmuPhuDUdjRZ3m0VbXqqurOn2LNSx GxA/u1aWJA+8rWsI9mWM7Z89EiR7xhyHcguVMnh7d4K7cAn3EW1S5xMul9QZkQYz6TpSc+0f XjPs3mpg5tTeknd0fu7Hpv60RYEdg6MDwE756ws8A1ZPEFdmBDAvQyqi+XY6GhXbw3OPcIN6 e2RJU8ZqspZskvOplxYmk2q3mq8XajIITFM3EG1Wd0s/z/Ii+jGcVBlwZ44fodY4VwW8wg3e FNhwp2Sr6jasPX9Q0yZbLHG2z1BwHV4r3C4qyGLuPkbpIHyLdz/7lBHYZWWm/ksIGqneyFMF 7VZ1q05DMtlH0uocr9W4mdGV06ZqgvWqJ7hRJ0N5h1F2dJXgS8/NQIO8/UrDpMAOfo3azRde Bgqit+PCg8dp50bg00fRBBL7kIUzOh0MU4wY1GrVy6WHh9ev2hmB/6uYgeBsSW9eLRGHMI9C f7Z8M1/GPlD9dkPTGzCtNzG9i5xoeAajZGvFK+NqSENAeSmxfcqgM54otF8NCGE4Kaqz1buV m8JBiGfn/sCkrejNhEa2k44L+0mjkCTANPn+dD2szaWScNH+GEgybMQHLBOnaH6M7PYPuJ06 vZFQQd8eXh++vMObTn6sChNkbVT4hJ4A2W7asr5aklb3RGgICE/X5fXv8Wrt9rRiXsz7PHmq BCZcc1R8LkKX+O1eYv6lOjhHH3H4uwuVjuZvkByd6HI2tHufmRrDd+fCgJ29p+1HxNG8YN65 g78+PTxPDYO79uv8qW0s2iE28Wruz8wOrIooKzAOY2kfxCIwVfsEnqOjjdqBaIVF6rKJxvZj tREklDmui3Zylu7u0cMF0/EGcWRetScd0WSJYSs117hgt0hYUzMlKKaheguSX81TTsG9qifV 0WLAG/ODhqashshlJtoMmlMVCBPqjJbEXMWcciZ74ZB/HW9QszabKCvd6GZOr/Dw1j3QFA2Z bDn5y4/fAKsgejFoy/pRp+tnBAOXcTSEfkfhHuEWMDhTP0mBNEtSmjdoJPceH625vGsapE8H XJBT6gjVZExYlRI0jGRH051Wn2qyd6MnuniN85tm4UAMMi+Q+dPeJkrIKdVPGEXRKnZeC5/S 0qnLj0sMdj94lSuKwWDxmipGHrIq40kCBRtX++L/GLuS5sZxJf1XfHwd0T3NneBhDhRJWWyT EkukJNoXhdtWdzvGS0XZ9aZqfv1kAlywJOh3cLmcXwLEmkgAiUzPKCrMBxiyultDlQdFyZ3r h0Qf4vG57Y4VpX+zB+lICUcOKA7tG3PoNY1y0L45ji64Ztrw/mhMKoXFqEs8OsgrZWeA1Bx/ +BZRA7hTKV6sdaraoQs43ZaD0ylah+aZ8wvpORdKrUc+1bO5ILWlxYwU0YWI5aJ0uFvcrdfS o+zTEESeIIngvuUO11mpV2ecX0cS35o58CEGmfS6gKZdTHosU6pMhkPCo+ItJu8q5cx07ycR pdphsIMyk6vd7ra3TTlezgz+bR7sahw6e+O3GfLiii5BMU5AoDl5HqmB/Do923uBIvPKZrzQ po0VTumRarMmY7Ef/dAdOraZRtk0qqkI/o3nMJRohllxnW0KPHTkEZ6lQEnw01gGRNfQd488 kSWO5oChfBd35p9ylUDZFqQRlsy2PRx3yg0IgtAqKkFc0yukMX+Vmu1XKuEItUVx0N9qrQPf bzvfv2u8wI6o3iZgHmWVEpMeZITqMKQvq+pWRFgW14ewHpo3tnKm2Aj8kgT9sUhiDMgipKFG w6DosmN4JGIQutGp1vfnj6evz5cfMBvw49wvEVUCTDRe2WnUqssC34lMoMnSJAxcG/DDBPbF tUmsqz5rqlwFBr+RashlBNoa21PhxSCJGAnaIEI5potbqPy0+ceH+O96oOEryBno9mjDSual G/qh/kUgRj5B7HVincdhRNHObcCYZyD4Ek4ROjijtC2sDLVyUBNBqTs9g6Yse0rM8nnIL288 PclAhlImjIoGwzuohJ17orUNECPfMWhJ1Ku0o+oNfyDBhDU0Zx7ImghlwXPOajOgPZ97P98/ Li9Xf6I7ysHN3L9eoMOff15dXv68PD5eHq9+H7h+A9Uc/c/9onZ9hgHIzYmSF+jBmDuT4Cq4 DZQ8O9EMY6APpUJyBuTGUWNapbewq5ed8yFDce052iwp6uKoDTezbjdFLeanUqYdv4+m9Roc XVm6HLyBM/XpQoXasu60W2Kg9uhAuze6t/gBK/4rbKGA53cxle8f779+2KZwXu7QuOigC9+8 2hrDfnCxZK/G4IKpwtNCS2X2u9WuWx/u7s47UAf1L3Qp3ogfqVMTDpfbWz3ugJgbICT5cmG0 x+7jHyHzh8aQxrw+XUB7uelI535jR4ooF/IsEDf4RiQ+ERL8nMrnE7wru4NOUQPaTKTBG45e U+HYxvqcZ2ZBuf8Ji21f0zbkmYxwoTtrTi3F1TTK4QD8uWCOuO0a5DD6DGkPz0/CPY++SGOW oLyiG+cbod9p3xvAKqdjJEsslB+zGdV98U1F+xsdWt9/vH0zV8+ugYK/PfwPdXaBUffckLEz 15bMict9sV8NhrtoM2YLyIfO298vlysY2TC3H7kfXpjw/MPv/2X/JO7EaYPKcpt1e2o3hG2g eDsX7jEz2T/dwIMHV+qzTDHKVD2ep8eA261GGzw+z5ODU7lFkTOrccKZ38v916+wQvEOIuay KGOdN7SkEleop7ShjRvl0izFruF8paxgcEp1u+25ky7lNJ/XZcWiNqaO1wRcbO9cL9YbAPrt 0GhtdexZGE67PRhmvw0tgrc5i62yjl3thE/Fy47FdrTNKMPmEfJdV9kRcvqp3KIvHFuyU+tG WcBk7ZSX//LjK8wAsl9Nu0BzwDhGOTjdszY+19TlOBwDFW92zUp1TZl5zHWMOVyv80/Lzz2Z UBe/4tY/T8LYrU9HrSjCZ542DoY1Wibx8FZdVxllFsqL7bNV4yeBb1aUPJjUG6ONwsSl7sJE F9csSYL5bKI0W0ibt4OWrzRLx/peq31dncvdxphmNiE3gOW5xHcTLu1jcmQqBJdH3qzxq/k8 8z23n+x829VytWYNZa7ZSbrhPbl4xDdm5/72v0/D/qy+ByVcHUfAO0QURNPOHTWoZ5a89YLE kT8qI/IeS0bcU00Bg04sl7F9vv+3fLQEzEJ/QS8dtVJBQW/FkZxOxtI4IcHPAWYF0CA/V0Mq KByuMqrVxJQTQoXDsyZmDrXvUxL7rqVIvm+pv++DQpnZUjE6VRw5FoA5dFYxs5SMFU5A58UK V1qZ+FHsOT1Ka7ggwUZIPaaTyPhvRx/DC6720DTVrZla0E01cmTKU8GoSK9h/U7zDMOfwtil 3Wrx2Bc8NZHzkNBoZJnObHSpiRW6Z/K3K/kUdpPur7HWMrFOt6lBHJOvvnhx3/dWQD1Y08FN /sUO5t35AO0LrXTeHqXJPBYyTxM3pFpgpE8NPaYQNlgLjS0Y5KSj2ZallxAGDXd9KKrzdXq4 LsziwOLvxsr5tYYQncIRz+3NnhmNwkykbBvMzQQgM5bIJkEjUDUs5jqf0VD67sPIkY8IIscu 86PQpbLEKgVhHC9mK4wkqeQwKAI3tHiWlXkS2jJS5vHCpVIgRywfK0pAyOTVbJot9coPYrMX +YDANvES+YB2ggdDDlnojNi+Cx3yucP4zX2XBKFUyNHBifwnrPuKCYEgDpt4zem6uAi//wDN nTIGGVwTr8rucH3YK25pDJAq9sSUx4GrOPRVENrWaGapXcejzltVDqlZVCCyAQldIoDIV/US R+IFlA/nvIt71wIEdsClywFQRJt7SRykL2kOhGSubRZHi415w7pCtn6f6K5DA+u0dsPNsB7+ NMqCUdLbOqMLs6J9Cs0MTVHkZNKub2g3XCNH3kbkQ/4ZdyP5IdBEL6oK5nZtVqUMb9BxJFUc 3OM6IeW4S+Zg3vqamkPrOPTjkDaXEhyjgTjoFkQHwEa4zgl6Bwr0ocOl1ASvq9BlsnN2CfAc EgCFJCXJnkndlJvI9YmxWa7qtKAad1U3RU/QYSMjpJyZVRjKnqdGMh5U8pFKtLR+1qDBf2QB URcY2XvX8xyq4zGQVUp69Zo4+EJACCcOJEQT4aWfGxJDEwHPJec1hzz69bnCE9AeFhWeaGne CA6idLjUR05E1JQjbmIBIkYDSUzSIzFrjZJzyKcdiCo8wZJM5Rwh2dUcSuijKonHd2PSi8o8 lRvfoQRPl0VhQFS52K49d1VntmlQ1fLF50yNaSo9fGpSRZNgRidji0OlZmQZGDUbakb0d1Un 9LSrk6VeBJj8cBJ6PqmGcChYWhYFB9l4wp5kqSGQI/CI+m27TBxalC0G4yMy32YdzBD6mazM E8fU4YDEAdtGz/IBGLD0S625/GsWJlTzNKpJwJSAJqNu5cVE72OokGy9bog05d4PPXrKV7UH uyL6VE2RsvGyhon7F+Yutd8g26jpmfaeE1PSWsgCaqwjEgSUBombtogRArFr2gD2jMTqBEjo RzGpyx6yPHEWNSzk8ByiJHdV5FL0dtO5RJWATMk0IPs/SHJGcU/mC6Y2Vxdu7C/JqAJ0pMDx qcQAeaDTL44B4IlOnrOsU6J/qCCul+TEyJKQk02gKz9Zqgmoc2HU90PIL1PB4ThIE0K/4ZC/ PCParmthwH5S0TqKliYEKKKux3LmEmM1BdXaodUUgGLmfbLfg55gi1uUcpt6DjngESFDC0oM vkWadFlMHb1P8KbOqIA+Xd24DjUvkU6sQpxOzfC6UeIZyXRqaqHTq6w5DJquCUYsIrT1Y+d6 8iuvmc4836WG1In5cexTp6AyB3OJDQgCiRXwyI0dh5bOEjgDObgEAvtR42aZYq1ANFtfUshc kSWmhsQFs3GztPkTLMVmPV5kaBZU+gzImtK6n+5uHNeVtj1cfUgrg4D2RfvrYouPnQYzZtzb prfnuv1vybx+ZOfaJWUiOuCnfclfeJ+7fakaXIwcebFOD1V3vt4dQcgUDT4Otvh/I1Ks03Iv 3q0sFEJOwGNcc+cDnxVmuDuoql2WdpaQD2O6/7goSi2pEiDDKt1e838+yWi5Lp/UYeAW9hbG cMiL43pffFkaJ/iUuZRXGhGxiX8yq9K60RF8Ppt3IE137Vp79qIyzB+dhz1w+IHToynJtxfl EdpsLyRYxuS0TZEoY7ahuAYe+UrGqP9o/G9SjNA6E7DdndLb3YE28pi4xBOJMw+EXWxx0tBP lKYE3DjFOJc93X88/PP49rfV51G7W3dzNeQ4cfhM21t63jDvKqX0Y7HyFLLNlUs1Yfm3lONd We7x5s7Mb4hBIDf4XNLTYilhy+33PZFnmn05YGQlrZhpfkRPZTAoAKAubqqyRuvhIZ1EjUFl UanFKjvDviBQqfykjxUqsW3QfeRZ8baBYY7XZddkHlnx4rDfLRS0XMWQofIRPDlrpZcFp3QN EgFZZuO+yHecol1pCQvUJlVGKCpBmfyQNqotPR6bud5ayxaIKmXTkKNRmIHoFZ3vJxpAztvx AVFJCssW1M2hQeYrYdxVu75K3B7VbhiMJtSCRk6vUaC3YI3WPgDE2Au0bgCdK9TYQKkfjZFM xI9Xsd5QqLspjKMOobIBlcXxemCdxQaD/YMgkw2KHqrvLOMKR2XRwN7CJ+TfHKhPbdIycfxe n2rbMosdl9lLUWzPqefquLC5atPf/rx/vzzOMg7j7EmircmokVSXPWyKThZpSnyoyUrbh+Yb /6ycv2bLWbOUHg1wPs0ceOjMVQnffLt8PL1c3r5/XF2/gZB/fdPMb8aVotkXaJa5O3DNhupg 9NKza9typb4Mb0mPUausTmV2iSzdXCIT+sbkpkw094Qr15oT0JKe1jk+RCoUSQkAvd+es3pr ZDzi9KW1YBnidM7vcf76/vqAtqv26OfrXNNoOEUzhUMafCFMHNkIglNNYzokTyYGBk01leAf G1y0/SSIulMQGRoeJFHrKHAJnUBPKxy62JMophachvZ/SsnwbqrXm2EgqpXbdGiv35aZrzIL ufPlkO5v5mcQ0iPWjNu8KgTxykZTBlHrbOoSW6JDjY8yFp+/NzwqJ+maubEGKvGwEeMWkFm9 y+VyIzA831BowoGV1qyCGGqNOBhPGNTRXkKlssTRWbvIT3TaqPmpZMVYUBkiIHEohz0ISWYp kjgd/BfZ3G1ODJaZy785mTrKRG4doRa7LYM46rV3PxyoQ0c5z5iIS99tb24ZNLl0nJOu+tDR owBz1ts2k/dMSOvKc1r7fgg7lzZLc20KTwavaoqqPsjth7atrmOxeeGGr45LG7sIMKZT8o9x BkYfD46laVjsUydoUwaJ62l1GKimJDtVrhf7RO9UtR/qXTkb/uojsKutHTaapctiVVg7q20/ EEnx2QZx5dEXILwSNSj31G3TCMqnMYLGkiQmaIygSVcKk1OxmW32M6aFnJ6BddkX0A67qktl O7SZAV+AH7gnim170N6uzFx4AsEPICY+skHmBIMYI9pl5kmzjjH5RliC8tBPGIls4VdDl9I0 5SOYxoX5M7ZxpV6swrRsUogn2/RoiHLGLHVXugVNIqTO1mcm3X/vjJRtlfikHbDCA5sJN6Vz gKkXkRNcYgFBFbtUzThCtga3KuxtSEiOAbx3C1lig6I4oiBzVVSxkNmSsSggP8ahiOxKY1nV oJBsDHOJlrBBM1KFoorHzKc7D0FGXn1LPLDou2TvIeLRhdIUhRkxLU8lbH24K5RbQgk7MuZE Dl0NDpKmAxpPQud9qilJyEMUDU8GDVBXHmZEWvOJouL1qhv5y02OK6Dn22orll2P0rJ1ppic QRxzfXsJbY9hZiZ9rclwv6COQIKAXuXlb2ajG1DSjWF2nuOUy2lmX5/0Qe7+XGxJny4gyhSL lxInQCHe4ko8XYExMRWa8B+mkAz3FiU+EkCXQ75CE3Gp79Sal/vxVRl+ylaN8nq3b6rDtS2G AWc5pORLLMC6DhLKFYG2q3a7hr80UYrI/QQRJPQnt23rslO8ACEsZ8sDUUyHfLK3ipfL49P9 1cPbNyK4gUiVpTV6YZpPCKXzHsSFK/BzdxxZLGdDyJuX12WHhf5PmPcpPo4i+NRK5cTp5VBy jPZsh+Q3MAN1N4aFlw/u8oIHyJlbU5COQeVB9iv03ZTKW8cZ1pOk+VHX6gQgNLq63PKwINtr 2fO84OgOW9nHDP/4ukrbDfqXPmfwv1ZHT1v0zaQWYXVY4xUJQT3W/KbJRDxNSMz0Gma4bL8z I3Nm81YFD9SG5+bGqVjNR6F5MsN7Bb1Qz90oTtEufz7cv5geh5BVtNfYIvKxnAzJMSiIscVd abfCo4mSRR1Gjj3iT9sdnYi0RuAZVkxWOaZvnFfF9gtFzzDmGAk0ZepSQN5lraPuzmew6HY1 JcZnDvTq05TkJ/8o8D7oDzrnPyrPccJVRr38nLluIPeso3O42W3LjJKSM0ud7luqZPU+iX1X NlSese2Jqc98Zmh3DF0qpofCodoOatCZNj2duWBz5TmU3Y/CEvuyMYkGuWQ3t4ViOCIB2wQ+ 6TE7RnZuC63fr6zIHyQC/4TqG2gdpCx6dJ7Qnndkh9jCZ6PPP+uGni2HLwm519I4Mmtqn3x3 JrGgNUdA1qy7cTX3gDIIkoXUnyWewxZ0EUPqCbCLXNocTmLZaa5/CI7DEHmASn5kIak1zyzH zPE9y3wEPTKlPCDMHH25F+7kSosQucv8hXBrzYm6kRjWBBCo2iS82/tR0GvTBfroVKygoBrZ 82ZXCWJx+vWqO1796/71/vnt798fn/5++rh//oW/4DZWLVGEovaY/DmZSmoTA8TdWwoXv29/ fXCPW4+Xv55eL49X3+4fn97ob4owEvu2uVVrsgHNcz8ZLWHSTV6XV6AvjQ5+tEyaQ9UWDBUq vU/2abltN2m+OyG6oOihYrCkDkLlJxcZYxxAKyMoJR78fMrH3+QSTNJuSf+mdHcMSieBil4Q ajQ0f11nv7cY9ttsuUGpO5rud7LbZo/x+tblvj5p9kiSrnT/+vD0/Hz/7efsWuvj+yv8/hU4 X9/f8D9P3gP89fXp16u/vr29flxeH99/ka8Yx13BKt8fue+3tqgKMraNKC5uZrxptKEXjeL1 4e2Rf/TxMv5v+Dz3LfPG3SL9c3n+Cr/Qvdf76MMm/Y5Dc0719dsbjM8p4cvTD7K90kMu+8sa yHkaB74xP4CcMNnkeiAXGOkq1DVdQfcM9rpt/EBd5gaR0fq+Q3kIGWHQEEI9N6RWvpcaH6+O vuekZeb5Kx075KnrB55ZAtjha28ACAaf0nGGLUrjxW3d9GbO6OnzvOrWZ0CNAbjP26nj9B5q 0zQK2eRp5fj0eHmzMsN2CE1riF0SkH2zVAhEDmWxO+MsoHZdSOYiSttVrTomP1KaiLK7wIkY GcSb1lF86QwjBtR8KGgUUzUI6XDvwy7zlMSybjC1aey6xAgUAKVuDIMKz1rjgGjJEdEFszbb mlAJrSORQ3NaHZvYcYhR2p08ttBp3SlJZKNpiWq097HpffEqTxpdKC7uFWkiyzippUinSMO0 7L1QiAop48urdYzHrkf0LgfY0oTkQzum7/Jkjs/y8ANal5M4ks84QpfSk0c88VliSKL0hjGX EBfdpoVhbToqyu5fLt/uhxXBpvdgkJQtei+s9M+Vde/Fgfm53dGLyEDtMxwmVLIwCqjd2AgP zwCNRDFBjaOAmJFIX+ze3TGJyNhTI+z6LGTGuG+jyDPkQt0ltWMue0hWXBtN5MbxKXLnOK5Z FQCOzsIQ4bhPzPd27/hOk/n2Wm53u63jch6jOGG9q/QjpXMb3kSpsWZyqiE5gBoU2TW1qIU3 4SqlfYMPHHWZWqJTDyp3x4obZozz9fP9+z/W8Z03bhQa5Uxb2F6ERqXwmjwymgVv8IJIFU9P L6Az/fvycnn9mFQrVW9ochikvmt8QwB8hZ11sd9Frg9vkC0oYmgwReaKK3wcept22nXk+yuu ek78swVazi/GPE2gCTX26f3hAhrs6+UN/QCrKqIuXWLfXCLq0IuTSWS3g9b5HY3zoOzvbw/n ByF+hII8Kp7odpL+mlCHx4NWUY/v7x9vL0//d8HNnNCvSX50ntrIfvNlDPRQ5snXWgYo3wFp oAuoa0UTxpR1SIGLNIwj+tGXyUc/cpb56s5zyKNNnSmyVJVjvhXzZP1Kw1zftVUTI+xarGNk tp4fi31S+j4LHVXVV9GAflmpFLavII+wtVSFo3FnQbMgaJljayKcSLJlhTlS5Kd5MrrOHCXw pYF5C5hvHWDim6SdjMRWBAttus5A8fq0TRnbtxHkYmm37pAm2hqmzs3/Z+zKmhvHdfVfcZ2n mao7t2x5zTnVDzIl25xoa1Fy5HlRpdPubtckcSpxn5ncX38BauMCOvPQiwGQ4k6QBD54k/nH 45sXN5Opw5JKEctB07n2atV39HQ8ySkPMW3wxpNgAo0sDy3qivN2HAX79WjTndu71as4nx/f EJkVNpvj4/ll9Hz8azjdd1Lb1/uXH6cHAtbW32qPnPATXSEotwnkFNwSjmlL7Ja3oG2qkGtF wtC4CazpnA47hGzBqTsayUHsWmEWc38lr3Cz4YyOjbDf+rWvRrxtCTj36m1Wik+ThcoSd7xg uzBPU83BJbcfuHyWjX5p7jzYOevuOn6FH8/fTt9/vt6jhXJ/NwKNHJ2+vOLtzuv55+X0fNS2 VbbzBY0+CZ/G2HRtsAlbT3mFHXH05ee3b7D7Bb260iff0I/Y+BotwbbriAXXb+q2vkD0GaJt 8RpRuUBLy0R3BkVCnQrhRp0WiY27veOBPch3BhoWDwYQvCIPk21Btx4I5v4ddQXd5Kjk1+EI d3d+L8cHDCiFxbFeMVHen6Hnj1phSWWslEFxXcUBibyk9lzJyzLdcLIncspZUHKFitEgKWUe qi5ysrHC6JYnZs7rsEgzI+SxwsZ5kB/MRGzH4ReNiij5aS58Z3GZXCv1wrX3o3otoN+2aZKj W2ZPH2hQaD2PMBa1FuIHaVGIwW6McRNGNLy55P1BB2Rvxke85ioKqyRuVKhSpOzSSDNaaX5b 5d0Wi9U01zODb8uhY5b49kDOPuCULEq3nJlddOdH0LGuehzyxlHUSMTRw8+RhhehWajffSMK rcYt7niy8xMn/zZMBIdZS67ZKBAxw3VaEkOj+aMwSfepQYMWkTPTKHBHxx8Z1Ti9gOyrPi2S 8zJeR2HmBx49W1BmezMbE0nvdmEYCVdccSxY7EMXxmkpXK0f+wdpF6I3RszRZSTdFGZF4xRD bIXuGYqRSbm1SCkCScH1byVFzrd6M8N+Ed7qUpmfoH9ulKqzRCFakyALk1iG73zSqYWPYOgG FVYd2KvMymaRjwY+CR2UV0rkHPZ6c7TnIaRyjvc8Zcw3igWLmvFO2lBjUZLOjpILC6W+JSYH 93orcfKiJoyo/pECxxDsTo5wIVKmeSl2VUi1p5SrAIZs94W6FPckq59E7OfF7+nBfIpW6ddG eMH31CO0ZKWZCEOrW4sdrA7U03HDzEtRNMjSqif8QLVqgFEJ7+pMTHWyjG+vN8wd53qgciRW HAaqnvQP0BFle/TUjmIsAlL4EMC271zsGliIeqeG+FDoDOqFRrHyl7HXR1n/SilfdinlST4C 88CcT4r+00o0MQW1zNZnKC5ot5fzw5kINYsJb9dGTnIt+6RE7CJLJYNUqaXCpOmOcVB3iyIK 6zABTSHRs7Zs/5BoQuzIh3AMPg1Kdb1jeunUrpGP3YwOASwzSRJYnlhYJ+FdZxb7wa0Xttv5 BVV/04O0B7PIwhwOP2QAZJQ6JD56v0nLQaFXKi22ZvGBVN/tYGWKjCwtqXUkdX5R4DhzfBzl Nno4UyTDvisQMWSL6LXoDOs6LDS9T2/7yLuT3WXc2A7jDSOHsSFyWGBjSsj0i2U1HmPHOmpR 4SDa6XtFTw/WW0YG/+sl+ghTWtuHXaaGSYSk5wgSAc1aF65ulWJFgSNJgF4d0JkT0a1kt1Sl NxnvMur7CB09WVRXmgMlpguPSryBDoecryROh2oTVEd5RbSaTKyZN5ChSKnZOQ2T3MWl5cnK XyzmN0uqFpgjego7kiJbmobETWDTfry1iBzs8f7tjV7afBabH2vDs7qHeOCyeCri/nCZwA7z 71FjfZTmCD369fiC1z14zy2Y4HCiv4zW0a0MIyuC0dP9e3eVcP/4dh59OY6ej8evx6//GWFA HzWn3fHxZfTt/Dp6Qgvw0/O3c5cS68yf7r+fnr/T1kNxwFYqGCtasmeGrXBD21PDYqC3YXhX BDOBfY5hhF611YCJHuZ0w2HKMjBtkYDqAvaXVZE9H+SWCVPDcH6s4W/9YKvHI+hZAXrh5Ubc 4gam4PH+Au3+NNo+/jyOovv34YUilsMNRujT+etRs9eRQ4qndZpEtMIuv3nH3IZ+wHRbLyNU OA9C19SQuPMLvcc7oj1/G8akLqVPrLUKyTSIE2C2DinZNLElS0j2La7OXRnnm5yzpRBLz7DJ 7n0t9CWncbdoL34cpehCchuvQQrL5zlDeCCamd9OYX0mefaljMJkuykJZaqIyH1/F6oHFYWL jhl4HRXCwbVxESE/k8H67zJv7WRa+7V4RX4ojLNw68h+UwQY0dllgtpK7bmm2CocnvmfaQYt H8KgamvrZtYFJ/mb1cSbei6WFuVJHT4+HK5cvcgz8vJREShLMtfb8CDg6IxBSq7xaV4k6Are pmuO0eVdgyFmRV16ToPfPug5HJ3J/ONULJeeZT+ucidzKhgkLbyaObOqyo+zSPx97GihLPK0 52eFlRZ8odlrKLzPzC8tU+eOB6sUHkQ+WEYylq0qyyC84/ob12LYL0NhDifZNmA2WUhxiNdp RLIc454d1mH+u+afpnArWN5SU8FrF6A7R/umWXvDSLDihCehawRiQnblANGVCc/Cdew+hHQF 5GK3Tkm/RLXFRDmxvR66fi0+mA5lFixXm/Fy6srBUlP6TUw/OhIQevJsEPOFe4MHrkdFo5La a1AWZWXo4OFeqDGkpW7N0/nY2DGjcJsW+g2sJNunqm53YIclW7jVFHaQ2H2uvT5oLg3M8wlu H2HkuEiWdcTHkQBUhch3609w3IZ/9luXGhQZxxt0wGRw3F/nLZCDrsGkd34ObUY9ccjUcNYw j3cYxkqeQTa8KkpDnwZNB5/iNnfmlw4g6dqbwz9kA1XGfoWHUPjXm09M55+d4Az/M52bK1/H mS3GhheL9M2AlpU2JcLYVdnOTwXsQzrVL4yDs7zVtN41ZAYVvoU56leG/jYKMTct+wr+aj7R z6Lsx/vb6eH+sVG5aaUw22nxwZI0a3JjId87h00Tf29NXqp2CurUctrqjg4WrfcT1T/S8PaI 2+MAWjWzgEEUhU6vP01QkAXBOuFj2t0nj+C2B8k6KeN6XW426AgxyPWbRpoIQyfPjq+nlx/H V+iK4RbHXM66K4fSASwkC5JfZXd3AY4WyCofza/0K8l9bR8hJXXquvlA7Owbz+yudcCulg22 Ns9butfroIzjw5X7loivYbfNUsELY5HYwD5VR8ak7rrDpIa42FrpCdFNna5Nh9RNHbLYIoUW KU9g4TWJ1pXuprsyMVYP+d+NoKldWc0Vo2P7zLWT9CKyXq70ycfpsQ1cyYGHTjawqn+US9NG 7/QXQvcXsh2oLR/mvoEBUQvhzGVTb1zrhCJjGFcY3HLvOhorQl0XD68xhyzUbgkkoS5YRjV8 wyyZdm6BXw2C25Mu1kBlrCxFHL3m8ZLataFEGcfI5VpV72jzmDim6hyHsQD1VHue62gOLa+J Oy0up4c/KV/4Nm2ZoOaPcS7LuF9R1aT/4Ga8z6zgm7gmncJ7kd/l23FST1ealWrLzec3ilKB Tx94/68g9+FrgAFPMNAaCAO1byRvnaOKk6CiuLtD1SHZhrbtD2IsW80k0/tZaXxtsLbWvyRR ySj7w4E7pRLRIYUkt4fc0RM1sZ+dqVr8J+0zCB43I4gqAlFLnM+H6BFWcYFLBlcYuEQdgew4 SbT8Fe3f3XZuuMdo2DwySipbYV7RrTOvLKA+W2rhsNFsBO6oBUOyBqg1vUTrwFuNzQZtwSXF TAuU0lS8mM5v7PZqMZzcRSuYj2g/ruIVEZvfTCq7ZXAMzv92JUsLu4Qq3KMxUeRV/5fH0/Of v0waZ+R8ux61YOU/MaI0Zco2+mV4Zf/VmGpr1Ppjq9SILecqM8IIr9aVWrri9fT9uz2P21dE cznpHhcRFlc7cGlc2BLFLqV2RU0sLgJH9rvQz4t1c2NKf6I3jPzoIywrHR/xWcH3vDg42AYu qsrqXojljJcteXq53H95PL6NLk1zDp2aHC/fTo8X9HmQBqejX7DVL/ev348XzSVYb1+EFuJh Qt+c6BWUIEEfNUPmJ5w5OwxUGAOMpZfDm2nEIOYRNBXxFQ5/J3ztJ0pfDjQ5GmE1usJsPqB2 tCIRVpkqdfX77bfUeIcKU0ZljfF/mb+F6UQK+UHQtv0H7EEtpuTiYsd8N8c+YMZRNVPErlcz CemvAt3OWW0BlgcxbQqoSPEs5bSyhanrvHLgig05rJMKY4ETlQgDHwHKUrSbECwvFXNvybKs RpCq1kZKReHWZwc7jIMqY7WDpG535HG8KVYcLBeVlSTEMNlkjVv23KNufiSTr7zVcq4Ece2o N8t5ZVKnY/miq2fPpx7p9tIww+lE24IktZqu7GzmszHtp9OXk4yoJ7n5yluoj81tjoZnSUud XP3OckpDmBYMz9PDJ5CAAcYWq8nK5jQqrYp6B8QdK1IYEfTABT7winRH3wcg3zoWaNxkD8uK pQUDZ3R6hqX92732RI8pQI3ZNENUL7ykZ3nKzApIhmsRliXM9/JyzyoGWm5hUYh76S5dAx/r wGhtZfz1ev5HKEjgxF6kWqkoRh09EJOpBtup0c242QaXwS5X5gear/sg6xxH0AVFaKGhp7Z0 DHNyo8FoDgwDfbRl5GLOpkuPKgkXEcxByrlNl/CIglRAn9tkGf5RPxZoLBpBXhOZLtzJP06t hhHt22Y2KVZUm0m6Hkij460/T71bO4mAg92NChnWMTbxVAti3Dc/DLoJTZ+vJrS8RzRsGE/H HtW9iH3ae+Sik6o+m9RJ6sFGkaAFMFflEQfhH8zCQEyNR1uqi7yJRx1VhtJCLW4YORobnh1c TDd7cdYOs2BxKsip6EmgX2oq0mgGqsCcHI44QVcYQS7mEaVZKnLLGTF/AuHNxjOisDLKAjHw itvJsvBXVFni2apwQLWrIlMSC1oRmN8Qc0TEC2/mURNkZoSJ7TsymzPyiN8JYEeP7RwV/GDZ 5+fn3+D8c73HNwX8j5xgVqyJntEBGPeOYI0P+PUPKZbSeHwcsgW9ksCyHaiOOztUZgPTPA51 1DABBV8JIIC0Hpd95ydJqOIcILcNQDEceqICgVdjsQ1Ic8XmkoIDc6FtUBggzaVjI+K+kynR lHeYYR1vHe/lgwxRouAO82ZG6ISWqhaxE6Ri7GDW7PF0fL5o65cvDgmri8pZeqCTmgnQ1+WG srOWOeLzGFEVv6zah+KhIhhtJdItSnfBbLYkHZh5jGVmnLfP4F3n+NDxQ7/Ln52Ry6exQc5T LN2nuU5u7kPhjCkE4v/rWTch6Drev/7VX2qr9wjwo2ZccYBDQobTYxsmPP+s3XoDK0BAtYZF 3ZeDhG/AvyFwb5izlNTk5NcY750otWIkYVHpJc3yUg3bgqR40+Ch9B/EmXUFzQ3ZsgFa/IzX C8IFmWtEI2WGNBqo7aGPHH2t1Bpxb2nf4kZAws4S2cdGwIvWW+Dh9fx2/nYZ7d5fjq+/7Uff fx7fLop7xDAQD1mIurlgGdr12t8XRXfjMByX84BcV3REMPgpl5qcqlXCslp9loPf+B7ls1t8 G+bbRLvkaLg8ZUVUY+hKozwNW6CHFn0KagQS/EP1csNOhVcngsgXMYmD1J0wiYRZ1LAqcl+h wuIXBtz8bWI699Tmgg7RlQX/I6xv15+88Wx1RQy0f1VSidnaCsdcsGuohY0UF12sLKvsMI6j 5UQLk6MwPAqnS+UvyPxUhXkgr1RYCZW8oL8O52yy13uJeHq1gH6cRdA4PMWwgdAE1scbgYx5 08V1/mJK8mGiahbvKlnToLqe9ZkDK7oXAO2TjC0+CIxXsizW4MKkVgmBqsWZUoRX+s3OwFnM Pihk4a1INVDh66FPVMaV/pL8uV0zJC8d+ZH3XB0/jqeeat/c0jfRnBiJPu5aPJ149Yr4FnI5 z9N6QtnLddMMByX3xreMyIEtKjSqpoyZu7mcMQ3Vq/t08HnirYm+SoBXYIBFEkBMF0pd6WPH +5ohM1lQ97+DUOSvMUYbMTBhmqoX7QM18Mn1ADc+SrwkyNIX+fPUoos5uTBxZRE0K7ry5nNT /TT7Af6yI2aqXB+/MdEw2Gz2nJiQKnuyoMafIrC4tuYNcgv1kGSxPSyluxKeRy4PgwDe8v6T YkybGGxONh7lqO9gXGe+MG6xHGLLioxmpAvBNkPNLcm7mZAL1sCl7tJ6ITzh8slyQnVry/Po xuy49DOxJXa131uhhbMUtYaUS+2RhqJL7JIuf1diw7w+l1pB7lELXs8k9Aj4VYRMqQ+xg8EW efXrQTEdU7viIZHY05MxMXO2oGftMkLXg6NHNbOoHPRguToRe+9nGWPRM94qWvbv+QdNd4vh 2crWJM7aZKRLstzE3Tn0QlapW05gr+INJ24S0V+NA/L00DVTB/tlkrFBiJrAnrKYk3eOqkBV WSVF+mJMLSrIWTreG8yd7IOBnsjtJPhw78Rmubbl50Uw9+xWEQvP1uXiBkfF+gacFmEzpbZM xge135pH60ZlrJnNa6YQE3S3QH/VGJmc9LbVxXBdmVFf6NuZ5sV4H0F9/nPpS5AVyDwzCmCK SnvZjw5GsOvbcxdVAZeGIK4M8dvmX+1pkFhmHUy5wNJdYa8uwg9ie5J2repkXEnYXIcod75w /LrxSrKFgRm5nuMxSryWqnkNhEnwdmmdh/trlgbc7OHh+Hh8PT8dLypVxkmQwHZNqAQ0VIFk F+MVww9gx1tY32uTd2m/nH77eno9NmGfXRkVy+nEzondv9w/QCbPD0dnaYayaDjY8ren/V4O oK2BLBD802Qo3p8vP45vp74FOsb399fz28P55ThqgfQ7geR4+ev8+qes6/v/HV//Z8SfXo5f ZUkZWbz5zXAJH52+/7goWbZChYi8v5d/d1I+NNl/j6Pj8/H1+/tIdhF2IWd604XL1XxmNV1+ fDs/opGZq90aBMPW1Gv0G46Q56/Qcc/HHpz15Xj/588XTAZ5QRO8HI8PP4bitpdYDYaian+C N+HSpkNkA7kF2m3JNhh7w5AQz9fRsntBb+lRFpy62JZ53tRC/h8yWREIzx03FnmDuhFGmRbv S5eSEM8WIPRQgPFU1U6tWiwI0P2WK80NZ/14eP76ej59VczyirDeBjHoporKtOF5iF6Gls/A 5q4oDhI8sUgx7Fvj6L+Y2XwGGlLLnvbuI9s0CjZc7Goj6kNcBAMv0Yy+osZbUPkls8/8Q5TC sXQynq3my4XGF2G00f2VJLnK8qLma832r0T4QNpKPtgmyjq8FfUm2/p4F69cXCdcHITIfMXy PU6FZl6Iv2vmCOmOPK1+kiL7z6AFPPYMkh6pGSmlGlVxm4cHw969JdWhoO+HOr7sHaK8HR9b wQhy0rHw1c6dUJpWUsmilL4fHvhNCMUreTeAcWb1a3RzsoiUb19fuZwH2zBAnzFrQZRuTue/ JNbmI26C7/KRvnh/Of5GvtFXq4USVsaGEGrFsrgxYNPK080H2gOtZ2c8U7XKHXRM2H9TV/Yl L4XW9DMDINCWydAPjHp2QNi5Gg5wUaYZGylkWMwp/4lOIsvTQr0JQvLtWsL7Dfa3ih4V3SIK CoyA21LZCnb+PkQeZBfCBNQV6zhNkNc9D7Hz0xPoDezx/PBnA5mK++6wBg4pasHn0/lE0+I6 FgtYuBwvaJ7A02DNtE1J4ScVhTmkCDThcKmkWUW/jqoinJF+CLs7kfEE32X6lpBNIM4/X0HH sJ7LIC+RS8O9uXolF92G+8Kkyp91m/cguY6CXnLQL4oYHz85/QANY1jafdfM8ULdC8RFSS9c vUQR0wpvGLcCoqCPhejZsE7poyWHli4plNxWSXo6X44Y7YiwUZARc6VdXrv/5i9Pb98JwSwW GoiGJMj3acpcQzLbJ1ATchf3bauQImWjX8T72+X4NEphJvw4vfyKutjD6dvpQfEnanSEJ1C9 gSzOzNT116/n+68P5yeKd/rfuKLon3/eP0ISM81Q6jKp4MSck7HioOC1hKOUKarT4+n5b1dG FcazrOo9o5yKM7n+bvLwc5dZ+3O0PUNGz5oS3bJgkd230C91mjR23potiSIGyh0uuOg5TikT qiRuVAKWL1dWaHAOSsXHGflC8H1o1icwB9dQ9Trch4lqCF0VTNpQygzCvy+gpne4WFY2jTAc Flgt0SJUc+CWVWXe6v8Ze7LlxnFdf8U1TzNVd2a8x37oB1qLrba2iJLt5EWVTjzdruks13Hq dN+vvwBJSVwg96maqbQBiDtBAAQBytKq8Ortg/2ZcntJy8l0STtLKcIma/wvaCYg8PY3ws3r rhBFuVjeTJgD58lspr8nUuDmibg9mojwmsNOkwuBFejuqJH+ZYSOBuKttXGb30JrrycZdUeB z+qyFF8QUhwDCbdhFApys171WAMP36YFGlb+U3cI0L5xSEX1HPdCSzI2W8ubSIq9/QEK9a1r FLAtDc354h9iIzWbApgi8iphRm6yVeKBti9jJNFQ9X23SdmY9AzymZHV1U9A9xkuLYCuv2k+ a7KiiW8OcCMrSaz0UrGXBgj86mN2IKPpbw/cN7ImCQB2ihz87cH7vB0NR5SDTwIChhnhJEnY zXQ26y0N8XPS/R8wi6luVgHAcjYb1WakOQW16gQQrdgnIpkHte8BM5fJPLsjp9wuJmSeC8Ss 2KzNQvMLM1a73m7Gy5G+/m6WS02fRsY4PCDr1Fsh2SVCKdnQG4FEOVLftAttiYtznZvQOB2b dJvDjb4go5SNDweTJC698VRPRCMAC2OYBIgMtICceGKkfmGH5dzISOLlk+nYcKJIgrS+H7k9 7tx6WHWzGFLTIpwUeZ5EdWQNYofZ0QNZ4v2ZN1yMtM4LGIe1PjNhCRwdcpw0k1OOsTnQmiFr ViLS23cQnTQpx/t2fBZhSLhtkWNlzPBFvxPB1/P4wpgmdmslZr9fLE3PLY01yNLc7ArSefb0 1DjPouVWKkBdkzT+Izm3emZMoxtWbnCohLct0FKIcp439dp1KpZlfkTj1Cgo3e3jRbc2NlbV C+YJFHuT3pCzoX5bDL8nC8OyO5tO58bv2XKM7z/1hAMCOjGv6dB5klHrzOfTqenCmMzHkx7H fNgusxG5sbx8ejNuMw/j5D19PD//tHJehefj/34cXx5/tmbn/0MLrO/zv/M4btek0PbWaPx9 uLye//ZP75fz6cuHnpok//bwfvwzBsLj0yB+fX0b/A4l/DH4p63hXavhv7Ftt51cJesReQJo 62t9V2TG6Zfk1WSoG+EVgFww8ms8/mgUPqyw0eV6Ip+3yY1yfPh++aZt2gZ6vgyKh8txkLy+ nC7mfg6D6VQPlYQi59AKIaZgY3dnfjyfnk6Xn67lniXjic6Q/E050jwvNj6eCAdyl26qJPLx zXGHLPl4PLJ/m4O4AXXaOF95dEMfoYjosnRGsJ4u+KL8+fjw/nGWCes+YJis2Y9g9vuljeRA pnWP0h1O+VxMuW4jNhDEWoh5Mvf5oQ+uc6meqxN016+Z7jPK/M8wxoZwx+IJ5vU1zvHc58tJ zxNFgVyS22C1Gd3oKx1/60zKSybj0cL0a0nstz4dQsao6H7P57oha52PWQ6TyIbD0Jjzhh/z eLwckn4yJslYu+oQkNHYEBp02TbuS0igCPIi0ybsM2ejse5SVuTFcKav4qYlbRiPVlApZnok Lth9U9NbIcvRZUQjyaGu8XBiZRnj0Qg0TFounEzMlL1ocN9FfEyRlx6fTPX7HAEwH/s1ncEb O/r9nMCYeZMBNJ1N6Miws9FibLxl2HlpbGe465BBEs+HN2RSz3huaEr3MHowWKNm/yQPX1+O F6mGEdtoC3q0roxth8ulvoWUipWwdUoCbbULYLAFf3GQ4IdBmSUB5n8wDhTQXWZjM5aoYg2i sj7tqZmeTeLNFtOJuwgVQmcsycf3y+nt+/GHdlRGL4/fTy99g6WLWqkXRynRA41G6s51kZVN Ep+rV7Bad4XDf1Hlpaa8m+OBr4p7Ve/mwH97vQC3PzkquI/+yLo+AHLMzMzxWOYxeSLaRUMP zJMkTvLlaEhkI84xrykcQMQaXOXD+TAxTKqrJLfUd4pniWiW1FLLh2bexDweja6ov3kMa5bO +pzw2Zx83IiIifaUVC1TKz2WDjVPwnI2NRu5AbVzTgmr9zmDc0RzsVUA55R8QW8By28hP7/+ OD2jDIOXX0+nd+lcQUiAceSzAhN6BPWOOrWKED0qdOMaL8KhIUTzw3LWw8GQ1k3dWx6f31De JdeF/lgwSLQYCkl8WA7nI6PqMsmHQ8pbXCC0eSph7+hni/htsuK0pJJu7JJAxSSTz5iSYLA6 n56+EtZXJPVA/fcO+ptPhJZwaE0Nl3eEhmzrqoWigteH8xNVfoSfgQDSKh9I3WcMRlq0U2sH 6l6LkAI/7DAFCHKsoggUUbEmRkEAM2MxNLAez8oO7STvQJSIMrXolKriVmQKJpJpFkm9xuwr 7FCnhZ6loMHsgN+XZMAYfCKlJrNhOMJqUIoXBYb7cBsdPPNKFlP7IsCIsfCjLLI4Nnm1xLFy c7OkHbgk/sBHfZEZBMEqKOC0uUIQJQfa0C7RmHgrur1GkHujRU+QE0mRBLwn1rPE5xEvmbfp 8dGUNPJ25hoB3i5dwZcRLlTvakPu79JrPS2DdcHqVZ5Qd7xhoi13+CE2psy01BaDYDh4dxG5 GBC7L5CHBniVmNhf4iWh5V8i2fTmbsA/vryLW79ujas3mnZM3JWX1NssZSJ8sO380OylzR1e R9fjRZqIsMHaptVRWITOjxDpwSYUUXfJgUQKYcmTAYl76tYo7LpLAIPyYEh54qKNzvaTeCtd VhHuzyYA3RsUv8iPZ4xwIA65Z2kOcFlHYTpWl5sq9dFwGLs3xp0PVsdeUr/ISNcZn2ke0iJg jHZYluYPGV7WBPGsKrxAXM5kepIKDaeHRWu4mbiSKzcuxBypFromaTkJTXhFlWvmJm7h/SF0 0CGLRnDykEhAC8wNPhz13PjzOEostxtpdjudn//zcKYuR31NYIcfdWamgQujItmzAh95Jwm5 JP0gjutiVRm3wp6/YqRzWhLpCdzgp33cCpDH8L4TWGga1GmW1kEYAf+J45V1fxth0qE6WoUY oTylE0KH+9oL1258LM1hKVvHQdtTZ/Cg8sHvwQ8Q8t9PX74fu8GMmmBHfwC/srYVtnjH9Fev CAm4Ec5L0SifJW0eTET7MNePuMjYol9FA2lRpegkUtPzI8du28ygWT0KDA2yy3ukF7ovWJ4H dkfQkw79GPGKV572ZuuBe/EKBlXSmN82uNsqKrboWF+gH9LGJDL9IEW4fLS6QEvKyAyM0cgV JcoxSVRGa6FiUpYGUXtutwe9tHKGOxmGXCCVPP71/DD4p5lsy459Qp9gcULpyqQHaxaGDJOG qjh+3RGKnn48OgBCS3IcHNA3JzQ61MDqFXopwd6nNhKGY9BerjcHAPBj9A+868HjQ/LUK+6s PBchT7MyCrVbft8GRBIgZWedPzCJoO6+KtD2uxLET/QaFdH5hVofMs9YzCIcsyKErYhP9vvK tV+634ZJWe8MvV2CyFs5LMErtXlgVZmFfCojCHSdq3iPk222AzGU3RkRBzoYrEk/KgIPd6y2 2CgCFu/ZHa9DEJczI5GCRgyczcynoN4HPH6zkqZzsf5cger9+PH0Ckv5+9FZsujjVZvrT4C2 9vWcjtwlZlwVAURpVB9SAcQQEJhaMbKcVgUS+HvsFwG1VbdBkeqngnVIgCLr/KS2l0QcgDkY tW+qNSzDVc95oLB1T/gK+QfDh5s8ERi2sRxEgASR8uCOg85uDHFWYOAUUQbFscUONQprQSqg irGrP4chHxvNaSBqlwwduJDLXc+dDo8xIGAFWjvbIuQgtrHiGkUz+ldIQDYWJiHgSCoBDzUm kvZePnGySojvKadviStEbCXnk6JaRdS68wqWmLtBQtDTn9J3s0QuhGcTgnIKOibdmUF9JRJ9 uXSoOv313SGPfextOzzUXpRk0P2Wiiglvp+Shdh0StK+RoLum/3tgIHqxgH4PByDW2sDNEhr 0PD3bmz9NgyCEoKbm6hfIKc2Od8z2lVcktejXiRyfRVV1afDuygi5FIg7PtWkJeQ028J4LRD F7Mo00RuPKLtn9gZY6w8K1Mwr9Ii1xRJ+bte69ZWAPBAwOptsTK9iCR5Xx5KhRbPTjDIrXY5 F+QbY+IUgGK9XmSepfgbX02RRiiB3AcM/ckx/fHGLKeuQAmPjbQaAuywFh1ph8JpYWOnHJl1 BpTQXCSo6y1Rb4nRrWQ1sSLZKHAtj3lyqXmZz+gDgDX7o9OzQyLsm8ItzcBH4ic1IxIBi6Iq jDDfZrShmDfqxqffTu+vi8Vs+efoN211x7ge/UCc7NMJ5QtikNxMbszSO8yNsSoN3IKMLGKR jK98Tl1uWiSaIdzEzIf9Bc972IZJRDvPWETUzalFMu1t4pWhm1Omf4tk2VPwUn8JbGJm/aOy JK/2TZLpsr/FN9Pe8Yp4hkuwpqNxGMWMxjP6vsWmoq6wkEYEybNb2TSg76MGb3AVHdE3zQ3e muMGPDN3TQOe0+CbvtqXv6h9NKELHE174Fa7tlm0qAsCVpkwjLEI4g9LXbAXxKVuFu3goCNW es7OFlNkoOPrSRxbzF0RxTFV2poFNLwIgq0LjjzM3+e7rY3SKip7+iabZMwD4sqq2EZ80zMT VRkal2B+7IbW3h7PL8fvg28Pj/+eXr5qj6aFTBEVt2HM1lwLGC++ejufXi7/ysvO5+P7Vy3y ZCO5ocK9rZWM3Ck4KAji28Y42KF8o86Dm1a1kUEdXYqpZpfH6I+qfD/oS3OIkU8w/D0d0tR7 fX4DpfXPy+n5OABt9/Hfd9GbRwk/ux2SJ3mUhtojhQ6GanflBdZbmBbL87jnqZdG5O9ZEdL8 au2vMI5/lJMyTpCi7U7YNaA8EMc9VgbaAlP4pMJ3t5tAf58Wgmgtv/w0Go61QeYl1AZ8Cy8t E1q6LwLmi4KBirKJpSDI+ir7qn7rifOb7VPdWOYm59sEaN7jbXutAQNZA/U5VIUTDF9F26wt IjlCdmJxYyTyrEnbZVUYZngvIAVJmeyEukNheCEKSokIL+oCW3OrnJFPwx8jiqpN9Wa0QKoE n4xkWAP/+OXj61dj54rxDQ5lkKLia5eCWIzf6fUimuXS7Dxz4mCAeJZaQS1NTJ3CggeWVdIb 0yK+Dwr6NrNrFqy0kLweQIICZN2SNTlGra+z1WdYA+R1gVxGMVvZA4EwUNKYtkvEy1o1C0mQ KKRVV4O50hkuLMkVp80/kmaX2A3aJfAfEwY4AlWs3KYAOF8Lxk2pAAXsBNCEGloZr9kpmQbL N1vAr/STSqI20Xpj5ITRRk10HO2OobRFuqOiIe1B21gheaWLFC78ATppf7xJ1r15ePmqJ1cC fbfKoYwSVkCm8RqehWUvEi+OLaR4x3iVQvdvyMqcASfRyXKVEeiXNPWOxVXwaeRSam3uLc2m sUuTra03FWy6kvGtPg2SK7UocWxnVflpNB4SzW7J+ntmkthN2d8SQQclJZrqspz3gO2CJLJp bdtWDlvFd1PTSDCetfRxgeg+O4L8Vm7gIPX7ziVsyjYIcut+QXqP4dODlmEPfn9/O73gc4T3 /xk8f1yOP47wj+Pl8a+//vrDFjuKEk7vMjjoCYnU7uies5sblSbf7yUGuFy2x6spm0BcDDUH hG5U37WXPsToCONSYNwki4JwNK/wQ/VZLy9sMhjFQZBTDcXzg+VRG96EOw2A3YnZpZ18Ls1C bIfDCZBiCsAa+8AlIJB6ZUKygGHDzJVB4MNSKUDGz5Irnd/Kw6m38/C/yoHsdD3iDveFUVBg m33SngISKW7YIjqcmKTwQLAFbSmSjwDkg32vMuQOa5UU5GNzfSKMO1avEgy2b4YQb32rY+x5 QGBw22/RUrvgVslzRZO2rtOs1IjUQVEID+TPUoikJEbBNFsKTahmUWxKFgiRoowlewlEiEvQ vPo0Sm7FY3ImYxD2U+/OCl/SCOFcRHholqyb+AsTfwuUcQjCNIZVKiu/jl0XLN/QNI0GFjaz 1I+s91G5wfSV3K5HohMRHhIIvKzwLRK8HcSdJyiF/G4X4qkPZSnaHZ5otYzdZDZR1uqZjLVA dmO/CBfhAwS9cXEGf2BOy5pDxzx3fLSixIrYizsFs36jvMZFzS5IEbrzGjpbw5pQ8gY2CJK8 BJ4nu6VnvytuQb4InfrlsdhCu5vOPSzL/prUtKqp486U8JTlmNiyF9EoYcS4BfUKeC8Mukwt YakqBk64APXcSykClqb4sgCv3MSXdLCihhiWYUNGVOoOh6Zuo2BxhaCCOlaBmpe+Fl8naAa9 ZMBO8z6Gi7GqnbWzwXhtTabSax/VxCEq9mS9Aia1SVhhCE36PmgJaGODRvmLHsiGBCAqot+S uCfU62y2jByp/my8eJpFflBnGy8aTZZTkb8GFR/6PMXkNnnUY24qPl6Epak8vl9MM1uA7/Fw dLncvl0zAwUkq1t1HB0kl97Dc1XClrbOTWHgwMHpcJ3faFDgplLA7o5IyGHzaSsmUaMeiJB+ B7zrMp4MiH6UYv5kxD9qAQmqLZCV2cH5Wtj6QnIcBH4VlUnPjazAVxXpRypwBd4JlsIa82x2 RSbtNubJTAIsy+bCUS2nbR2yeTllvRAodC3E5mscTIKlw6C7HoQnzJWe9ttD1TywEk4R+yrS JDIMACQZqPk9q0AYXUBgQZMMHLn4ukqKRh2nw9CwJBcVZ7WwTmzXvmHVwN/XLBnVirNU2pww s4h1oSvI9gw3uyRMszqtYrprguK61QQ9juuIy4Nbt7NiaDslsgtduDIUooAV8Z2yWxMViLh4 pbgpNl2gOoQmdYRRna/LWkEtqX5Pu/D6WQXLXMiWvZIx+i7FlX5LLmal4++OoIGv/3HR1eVd HtTDw2LY6eE2DgZrROPkwv00prF4Sn+adD1psVgd2VeNIiCz/DZ4VfFP4lNbNmgHSonnehP1 oD5KfRO3FGgN6QnpnLNeLQWdlRJcyaDbR7axVRYPZ1dBmbFxtSh1Qc/HnVewNwQfV2aRlrNV 6R69AAvHAC6jVxwfP874rs25D0EeopUPbB1OMZSFAYHM3hSA1Ac00ykqjgJWj4OEcitVBAZb CO5qf1Oj6y7r8+5qnBIwvxcXLr1wFHnGSduQXPk6tFUK8cAkDWQqbGT/UrGzI2g6ZLRgBhsK PWDl4wOqGZJtYyFJ5gcqcO7Pq2jhePzpt7/fv5xe/v54P56fX5+Of347fn87nn+z13I3Ssy4 GDCxWqo1MSVtsjHv/PPt8jp4fD0fB6/ngaxEC6IoiGGE1izXkw3o4LELD4wcKx3QJV3FWy/K N/qY2Bj3I8sZqAO6pIWh2rUwktC9N2ma3tsS1tf6bZ671Ns8d0tANzyiOUbuGgnz3U4HHgFM WMrWRJsU3K1M+W+T1M37grqx0plU63A0XiSV5umvEHhMO9QIdKtHn8DbKqgCByP++E7ZiYI7 Y1mVm0APdKzgpqTcEMMCcwJZN72Kq0DhkC07eJU9s4mf9HH5ho+9Hx8ux6dB8PKIewpju//n dPk2YO/vr48ngfIfLg/O3vI8QzRtWuDRBsjmow2D/8bDPIvvRhMyzImi5MFttCPWzYbB8bRr 2MBKBNdBPvPuNnDljqhXugvGI5ZH4K0cWFzsnQHNqUoOJXcI4eDAxyfN0G8e3r/1NVsm9bSY RMKIeqjKd/Lz5lE/aH9uDYU3GRNjI8DyzReNdJoloJhkTu4kZ7YLrxwN/YhSRpr1opQe+9Nf L5DEn7obzDdTTihoBKsmiPFvf3FF4o/0qCoa2EgG1ILHszlRFyAmdEontaw3bOQMLgBlaQ4Y U6y5lQCCcsRqsMnE5STrYrQkOFguK5BH6untmxmJuDkA3f0BsNrIytOBZ2YyaQ2TRnJx9Ted pdUqImorPHeuV6AKYeztXkQXUc1ZlyB2xnHUE9K5oeElHTlCIyCz2KlDjxi1UPwlGrTdsHtG poZTU8pizsZD4kuFwVH/b/juNRq8RbrGj4vcCFtrwmvOg3HP3JfB1ZEu91loeZT1kNi9bP2q MATJSY9z105CiHcVLiu/z4httZj2ZGxsPqI9pTr0xnNaVzy8PL0+D9KP5y/HcxMFjmoqSzm+ 56PkPr9YibiNFY0hzwaJoeRNgaHOQUQ4wM9RCboZqn6gSpACWM3M/NoWSjSif1m1ZLyRSO3t 3FJQQ9MiSdEdq7b85xrM3u2+eDnpW8HUHRzJDnU8MGcSvw5AUSJ2B+JCHgM/YUm7GIRZl185 rvArz3PFcgWvfVf6RBTPr36ldCzqy1vm7n0FBwF/sZz98FyxpSHwzFzzNnY+Pvyy7F14vfRd 2FsElt+DbsO3KxTjd0kSoL4uVH1hZ/lJIPNqFSsaXq1MssNsuKw9fNsbRugW2T3FVQT51uM3 rd8pjZXW6eDOeOoSrVGxzwP5IFa8aMMarLtiyRUxOuA/QrR/H/yDsRJOX19kPB7he2pcCcg3 TbpVpDCuAl08R8W8a5jEi7TOes/7XCSz1GfFnV0fTS2LXsUiJwUvKWJFKqwk250RmkOZlKP7 vmfUqyjFpkh7fyMJxacv54fzz8H59eNyetFl9FVUFgEmQzPvqlozcof//76ubclBEIZ+1HZ2 +qpgu+xQsaizrS/+/18sB6WeAO1jkxQUIUBOLjVsJD4Ee7gljHWcfK+G53rxMbcGTwcWsV3/ hovSOvNkGNdMrGjwvxi/oRYlHzUgjRPB9ImVkV8G6UuDvG2oyzhYI6/gKuiRsGXwWlVZZeog 8+FWEHqd5lU28JUdgnHpqOFCuUhYol37rFYdZYFTpfXG/72bwJtEa2ombYWTKg8HxeVY05Y3 L3UWuMGsYTPFOMO8EnTX/imqswnePjQSR7Mx1jLse/LsE6nFiSgLuCSq7kr6YwGZH3mjwNpQ HaydHbPADLXX2AVM833Ku0G+p0pXgTr9zLcaPLNLoBiUKlpr1W9BkxaW443X62KE/9eLYReu /EeMx1IuILbQps/WwanPWSeSPTMV5udz/Q/oj1itottPGydNPyYIgPAShl95OxudMkEnReXl GzreYZGHxS9da0ECELMKpRABKh6S8WpLbz5g1XuSgCwFhBCBun6TIyJ6P8YtsIFnFn2COytU 6wSMh9+fIOTe7uH0qRe7rFMjKk96zQ6nWnPBBX+HoYL6vw2ycKUzGj5GYePishOzQrz55DOY ZbyWURsHa3COczwkXbwVqDEcUAvHDt0N7Muyo+Hkc/gPuy1urjbVAQA= --8t9RHnE3ZwKMSgU+-- -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: email@kvack.org