From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-10.2 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2A7CFC433E6 for ; Wed, 10 Mar 2021 12:57:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id CA90164F25 for ; Wed, 10 Mar 2021 12:57:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232557AbhCJM4h (ORCPT ); Wed, 10 Mar 2021 07:56:37 -0500 Received: from mga12.intel.com ([192.55.52.136]:15282 "EHLO mga12.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233003AbhCJM4X (ORCPT ); Wed, 10 Mar 2021 07:56:23 -0500 IronPort-SDR: xn/2I6D17gLIv3cP1mWk9pmfkelT1fTqYXPjk9HU0JdHrucboTfU5tlaVP+cCBGB06Z5jJEUs5 2ocOXgJMuZZw== X-IronPort-AV: E=McAfee;i="6000,8403,9917"; a="167731379" X-IronPort-AV: E=Sophos;i="5.81,237,1610438400"; d="gz'50?scan'50,208,50";a="167731379" Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Mar 2021 04:56:21 -0800 IronPort-SDR: GizVQaUzEMYvjGRRitXtuPM3ke04fXVPbKtJVzqRr8NL3rr97QVynkTJwLeE7TO16cVVaLARrD y8cHNYmkAfTw== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.81,237,1610438400"; d="gz'50?scan'50,208,50";a="431205054" Received: from lkp-server02.sh.intel.com (HELO ce64c092ff93) ([10.239.97.151]) by fmsmga004.fm.intel.com with ESMTP; 10 Mar 2021 04:56:18 -0800 Received: from kbuild by ce64c092ff93 with local (Exim 4.92) (envelope-from ) id 1lJyNu-0000Bq-21; Wed, 10 Mar 2021 12:56:18 +0000 Date: Wed, 10 Mar 2021 20:55:39 +0800 From: kernel test robot To: Masahiro Yamada , linux-kbuild@vger.kernel.org Cc: kbuild-all@lists.01.org, clang-built-linux@googlegroups.com, Christoph Hellwig , Jessica Yu , Nicolas Pitre , linux-kernel@vger.kernel.org, linux-arch@vger.kernel.org, Masahiro Yamada Subject: Re: [PATCH v2 4/4] kbuild: remove guarding from TRIM_UNUSED_KSYMS Message-ID: <202103102058.1xwGQNz1-lkp@intel.com> References: <20210309151737.345722-5-masahiroy@kernel.org> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="liOOAslEiF7prFVr" Content-Disposition: inline In-Reply-To: <20210309151737.345722-5-masahiroy@kernel.org> User-Agent: Mutt/1.10.1 (2018-07-13) Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --liOOAslEiF7prFVr Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Masahiro, I love your patch! Perhaps something to improve: [auto build test WARNING on powerpc/next] [also build test WARNING on linus/master v5.12-rc2 next-20210309] [cannot apply to kbuild/for-next asm-generic/master] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/Masahiro-Yamada/kbuild-build-speed-improvement-of-CONFIG_TRIM_UNUSED_KSYMS/20210309-232117 base: https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git next config: s390-randconfig-r012-20210308 (attached as .config) compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 820f508b08d7c94b2dd7847e9710d2bc36d3dd45) reproduce (this is a W=1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # install s390 cross compiling tool for clang build # apt-get install binutils-s390x-linux-gnu # https://github.com/0day-ci/linux/commit/16dfb9e33ee3b9d411560c44c016edc6a3e27e47 git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Masahiro-Yamada/kbuild-build-speed-improvement-of-CONFIG_TRIM_UNUSED_KSYMS/20210309-232117 git checkout 16dfb9e33ee3b9d411560c44c016edc6a3e27e47 # save the attached .config to linux build tree COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=s390 If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All warnings (new ones prefixed by >>): In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:464:31: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __raw_readb(PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from macro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:105:32: note: expanded from macro '__swab16' (__builtin_constant_p((__u16)(x)) ? \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from macro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:106:21: note: expanded from macro '__swab16' ___constant_swab16(x) : \ ^ include/uapi/linux/swab.h:15:12: note: expanded from macro '___constant_swab16' (((__u16)(x) & (__u16)0x00ffU) << 8) | \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from macro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:106:21: note: expanded from macro '__swab16' ___constant_swab16(x) : \ ^ include/uapi/linux/swab.h:16:12: note: expanded from macro '___constant_swab16' (((__u16)(x) & (__u16)0xff00U) >> 8))) ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from macro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:107:12: note: expanded from macro '__swab16' __fswab16(x)) ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:118:32: note: expanded from macro '__swab32' (__builtin_constant_p((__u32)(x)) ? \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:19:12: note: expanded from macro '___constant_swab32' (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:20:12: note: expanded from macro '___constant_swab32' (((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:21:12: note: expanded from macro '___constant_swab32' (((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:22:12: note: expanded from macro '___constant_swab32' (((__u32)(x) & (__u32)0xff000000UL) >> 24))) ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:120:12: note: expanded from macro '__swab32' __fswab32(x)) ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:501:33: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writeb(value, PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:511:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:521:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:609:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsb(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:617:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsw(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:625:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsl(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:634:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesb(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:643:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesw(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:652:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesl(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ 20 warnings generated. -- In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:464:31: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __raw_readb(PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from macro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:105:32: note: expanded from macro '__swab16' (__builtin_constant_p((__u16)(x)) ? \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from macro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:106:21: note: expanded from macro '__swab16' ___constant_swab16(x) : \ ^ include/uapi/linux/swab.h:15:12: note: expanded from macro '___constant_swab16' (((__u16)(x) & (__u16)0x00ffU) << 8) | \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from macro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:106:21: note: expanded from macro '__swab16' ___constant_swab16(x) : \ ^ include/uapi/linux/swab.h:16:12: note: expanded from macro '___constant_swab16' (((__u16)(x) & (__u16)0xff00U) >> 8))) ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from macro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:107:12: note: expanded from macro '__swab16' __fswab16(x)) ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:118:32: note: expanded from macro '__swab32' (__builtin_constant_p((__u32)(x)) ? \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:19:12: note: expanded from macro '___constant_swab32' (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:20:12: note: expanded from macro '___constant_swab32' (((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:21:12: note: expanded from macro '___constant_swab32' (((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:22:12: note: expanded from macro '___constant_swab32' (((__u32)(x) & (__u32)0xff000000UL) >> 24))) ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from macro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:120:12: note: expanded from macro '__swab32' __fswab32(x)) ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:501:33: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writeb(value, PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:511:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:521:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:609:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsb(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:617:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsw(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:625:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsl(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:634:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesb(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:643:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesw(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:652:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesl(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ drivers/spi/spi-sc18is602.c:265:12: warning: cast to smaller integer type 'enum chips' from 'const void *' [-Wvoid-pointer-to-enum-cast] hw->id = (enum chips)of_device_get_match_data(&client->dev); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 21 warnings generated. .. --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org --liOOAslEiF7prFVr Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICKXkR2AAAy5jb25maWcAjDzZcuM4ku/9FYruiI3Zh+qyZbuO3fADSIISWiTBIkDJ9gtC ZauqteMrJLm7a75+MwEeAAhK1THjkjITVyKRJ6DffvltQt4OL0/rw/Z+/fj4Y/J987zZrQ+b h8m37ePmfycJnxRcTmjC5O9AnG2f3/55v7/4fDa5+v18+vvZu939dLLY7J43j5P45fnb9vsb NN++PP/y2y8xL1I2U3GslrQSjBdK0ht5/ev94/r5++SvzW4PdJPzi9/Pfj+b/Ov79vA/79/D 36ftbveye//4+NeTet29/N/m/jD5ND37dnX26evZp4eP958vv04fHj5+uvy4+fzx/Oxh+vX+ 4sPDxcPD5dV//9qOOuuHvT6zpsKEijNSzK5/dED82tGeX5zBfy0uS7BBlCY9OYBa2unF1dm0 g1sIe8A5EYqIXM245NagLkLxWpa1DOJZkbGCWiheCFnVseSV6KGs+qJWvFr0kKhmWSJZTpUk UUaV4JU1gJxXlMDqipTDHyAR2BR27bfJTMvA42S/Oby99vvICiYVLZaKVLBaljN5fdGvnsck a5f/668hsCK1zQE9PSVIJi36OVlStaBVQTM1u2NlT25jIsBMw6jsLidhzM3dWAs+hrgMI+oi 5nlZUSEoysVvk4bGmvdku588vxyQhQO8nv0xAlyDjXexeh3DJvx4j5fH0PaCAgMnNCV1JrUA WHvVgudcyILk9PrXfz2/PG/gCHb9ixUJs0LciiUr48BgKyLjufpS09oW+YoLoXKa8+pWESlJ PLeZUAuasSjQmd41UkGHpAYNBqOCOGatnMORmezfvu5/7A+bp17OZ7SgFYv1iWLFHzSWKNM/ Quh4bosoQhKeE1aEYGrOaIVzuR32lQuGlKOIQbeiJJWg4Taankb1LBWaSZvnh8nLN2+1fiOt J5Y9gzx0DAd5QZe0kKLlntw+gQYPMVCyeKF4QcWcWwqn4Gp+B8orzzU3u80DYAlj8ISFxMG0 YklGvZ6cLthsrkB89Soq4Upcs/zBdPvmIPk0LyX0W9CgtLYES57VhSTVbWCiDU0/y7ZRzKHN AGxESjMyLuv3cr3/9+QAU5ysYbr7w/qwn6zv71/eng/b5+89a5esgh7LWpFY98tsQxZAqoJI trR4F4kEpsBjOOtIJscxanlh87gULMjXn5h9d4phakzwjNirr+J6IgIyBGxSgBvy0wC7ecFX RW9AgmRgU4TTg+7TA4HZE7qPRtIDqAGoTrypYXsh4eD04m1hCkrBztFZHGVMSPtIumvvVMbC fLh+6lfZwvQOBWWULeZgzz3p76wwmttUiTlL5fX5RxuOm5KTGxs/7VnOCrkAG51Sv48Ls3vi /s/Nw9vjZjf5tlkf3nabvQY36wtg2661UhZ1WYJTIlRR50RFBByx2JHoxguCWZxPP1ngWcXr UthiALYhngUZE2WLpkGAMwahRDx3TXlKWKUsXLBnOG2nSJr+S5aE9qXBVon2WfxGKYjrHa3C /ZZg8+SRPhO6ZDEN9Aot8XSHVC3YcLAroAAc24rbExpIW4zCpRW0ChMDAzxaYFm8KDlsLWpu 8GXDqlezVnuOY1sINisVsF7QDzGR7jb6OLWcBnqoaEYso4wCA+zT7k5lOf76O8mhQ8HrCpjb u0JV0nqrvXAkQ0evRzVuqk19cxcWsmTUudOosGMHqDshQ85cxDnaJK1g7O2IFQerlLM7qlJe oUmGf3I4kDQkZB61gA+WcwJehLScCO2F1Sw5/+DTgOaOqTaGoJyJK6+jSt3rKQcflKHkOZ3j LvnOTDonheNIlFywm8ZpsA0Naj3/uypyZgcvlpaiWQocrWwrS8A5S2tn8BqCX+8rHAuPSwYc 5+VNPLdHKLndl2CzgmR2UKrXYAO0r2YDxBxUZP+VMCvqYVzVlaN4SbJksISGhRZzoJOIVBWz 2b1AkttcDCGGEXi+Gi+k18pl2vYe2GJtHVYEdEMbZCD9H0z62kYj05CcL4CJlh0W9IsjXHlE kyQY7eh9QPFXrr/bJDnKze7by+5p/Xy/mdC/Ns/g6hCwdjE6O+BgGo+uEZy+k6Dr9JM9du5d bjozHqUjsiKrI+Pz22mCvCTAOJ0S6DViRkKBEnZgd0ci2OlqRlv+ezg0TejMqApOFM/9AXr8 nFQJOFZh4yjmdZpmwGwCA4EgcNDRvBqZnXZUIOqRjNgn4VZImquESILJF5ayuPUuLe+dpywD 8Q4ZMdQ62go5sZKbAelkP7d8vjsIFlRiJxtwghHKVpEwYvmAGDqBCWq9HWvyEMcu9AyGuDbw mq8oBDcBhLPXFrA7bUovyxGTlgxnFFWU2EpuBoy0zj+Gy/oYOmEX4zhL8Beto+V6cjVwO6KO KhCkgK0mCV8pnqbgtlyf/XP+6cz6r2PIxecziz3a9PMcJpKC3e0WZE/aZLYyOBegpK6cI5wB D0pMJrQHuNy93G/2+5fd5PDj1YQqltNqN831mu4+n52plBJZV/aCHIrPJynU+dnnEzTnpzo5 //zBpuid3rZ9QLL7poEWND4PZ6DaVhdHsWGfo8VeHZnNmZJ14RgC/N5qmWC3mgD34hj281Es 7kHo8Gvs+dlgOsi1I/2Ncq9pHGZegwzzrkGGWPfhMmLSV+vWKbHNXFHpyOD6w2UnRlyWWa2V k6Ol9dmScJwhrrsNTml+B2wLsxVQ06tR1MVZSB5Nd9bxnt9dn1tnf0FvaOxplaF1aRKWBY9C oQC4jLzJldtupIah7jnSpE1OD9uhGxf2sam2WKiBgub9mL7RCinfPL3sfvhpdqNPdX4PnC2w JjiAr2479MA+a7xp1CZMGxk4RVPBp6U/UkMlygzUcJknqpRoPSyHkIAbO78VOBkQVHF9+cEy vWDgjJkLBREYARqsZxPVrAa/4Xp69aEFr0hVqOQWQlQwX22TjtMOI01q9z0PZSa/JOD2PnXm I2Z4YtK60CleMCB96kOnHbjjMsdzEePB6TsQMay5dlQyJUmORIH1LlPws+N4pfM6bVLWmaee evL29Aqw19eX3cEqolVEzFVS56W9cIe2D85WrclbbneHt/Xj9j9eSQ6MtKSxDohZJWuSsTvt NgHjqbCTla1w9XFinof89bLMtA+G/r4lQS3YDT1aKHc4h8ZfzW9LiNzSUArBVGCWuWciAYIZ bzcTb2PsIMiGq4rXbv60ww6CJwQScVvEwJEwVOG/ga7QKUSP7EZp3wWjXbcDlIrQBIsl7EoC gr+gJtXlUyx1plcPz/gw3kYS8NjcwNHdbWcidrYR2+rtqAEgKx7Wf5pCC0xQ/XmyZ9KFm8dv h83+YDlcZpxixQpMkmapRAG0TkjfxKlNrnf3f24Pm3tUp+8eNq9ADZHT5OUVB9v758aNzrWp 8WCtawwbX906Fsc4tEEO/AHHUUG8Q0MxrN4FmkJEwjBoqyFih7Adk1kx5tg9PQvBrK6IgkSq CMtm/nb6frWBVlSGEQaq4EinbWbFxrc6T9Gq4lWozKXJnJxHX0zTPc45X3hICIcwtSTZrOZ1 IO4AX0WXcpris8cCVLkpBBEsvW0zbEMCCB8ak+UhMVsgOhOBmXplquQe3cUUrBSwW0JsnCpg N0985mDRPedJU7b2WVvRmVAEpVWbKrOboNR8TjUpBxukEwLYPgTXyVPTZ6PmB3zv5e041s64 tGY6r9WMyDmMYWImDNGDaCxZnCABvWI+DTbIyIypGAyyWGaqzSkwm6Njf4+iaWfuDozgEl4P vSKdMGJlrExxtL2NECBqciM/RcuzxKIPMV7QGAmOoFQKJ9vJUPpNMsl1/dHr5Gi9b4zCK5f2 Zwf4CZwHYkwX/kQ/cG5Hjn+BHiiqtXk9o4E9NIvnqVQJ9HvrYeFwtX4sjTFnY0kZT+oMFBfq Q8yroiR7rdF20xs4xKC+8LPnQWoaHBpxQMJXhU/ScUSPoIMMJ4HdnPOMGd+3S9NYvmCG6Z8I EOCZJsK6jILiIthM1LC2IrkYIIinZxvROo41Siuwa3oly5yUllPc2voOOpZg1TIhQTHLNq6q VlaK+gjKb252LdjcQXWTwxjCzmaGHL5uEBMGxdVt6StzxC4TwXUCcCwlpfOiWtHoHGPrG89i vnz3db3fPEz+bRKxr7uXb9tHp96ORA0HAkNrrEkv6gSmZfGGmD65eGRgZ3PxChsGbqwIJidP uEBtV5ivw6qC7SPotLzIcWJn3snzjyKa5BjLv8SprDXIukBEKOETsp9Dw+r3J6q4uy02Ena3 lCyUz22Q7XWmwAgtanBNa4TMvW7VYFGQVipnQpg7Fk3hVLFci1ww0cxy4BaotUQt3GKJDVWr OZM6dW5VF1udqO8vZOB21ZbhiNxwHIuXIhYM1NcXN5Zry5qRmAWBGYuGcAxaZhWTwfJog1LS TaG1BJghD1YgsSCfJzq5oq1v5bdeRaG6n+kXz3IqvAVjnrgkmd+PuTnZ6g4QKrtXkxNe7w5b PC8T+eN141ZvsNagfWSSLLEOGhRzkXDRk/bToilzwH1WyBvR2cdBdg9XkX/BTMUAhgZbh44m 4cH72xbOMoCScZPuS8DnRoaE1tFTLW4j2JEux9GCo/SLk7hwxuvzCu1NKvDimVtVJZ6OFsW5 p1Kb7RIl3ketbl3BHqNQ0fwI0Yk+fq4D95rdKIkgg+yZTYaq8uhkDMHx6TQ0xyfUEzU3K8K0 +v7vUT5rip9Aj865pxidsUMyzkJNdoyFFsHx6ZxioUd0lIUr0H/0OA8Nyc/gR6dtkYzO2qUZ 56OhO8ZIm+LElE6x0qca8PLoiT912E+cnVPH5idPzNHDckw4T8jlKZH8SWk8LohHN/3Ufp/c 6p/dZdcdJ5JjhqbKV5arqa+96K0wEZsdK1crAQHACFIPOoLroxRz0QRmSspSU2gLSf/Z3L8d 1l8fN/qxy0Tfwjg41jNiRZpLjBPHApSeAoMtu4beYERcsdLJoTcIcB9DN54xL+nn+cdmapeR 8vXz+vvmKZgF7epFVnjWV5husPRDQ6gl/MEw0i9CDSj8AJ/mxp/BypAa4lMipJrZbmxThrKv B7uYQRHLhTdTGkW394i495hmvPzVlLyk8cuwqnrZbxF4aV6kri+xVBRl3EnS5GxWET+oxxSp aqPRtgNkFUmSSsmu5tuLDATJwZt4mJVrvS27wUKE6jQtF/Sm5qzQ411fnn3uCm0juZ2+UB3A w0pW5DYc9QSoc3O5zO41zih42AQczdCBcC7Z5MR63GABYRAirrurzXcl51nvxd5FdWJXOO4u Up6FHPo7HRXrfemJG5g+4MGYFPhKq8rNaur7ooERdAJcE2BOaWGExb4zhkk4HCnEUDgzSjph nTYQINUQhs1LfRkz9WsLqAJLSU22jTi5iHHd0U+poHIQNyWbv7b3m0my2/5l4g37dDvRiv+l ecrihOYA1gcnqoN3hwFLRJn7LRB29OZIR1TyFcQiMLWfIENDNSQekPbXY53VweJl7q43F2wA CL7paXF6z1KQOEwvChdfmRxWW5Z3X9QhgZB15Fa4sTY5ABLpdUxj4s2b8aXHcbwJO8ZBkGjB gtcpGwVs5KC/J9KDQbnG7HhLJeZlPNYcK4jDwB66vH95PuxeHvH9wYMvqNgwlfD33L6TglB8 zta+43gaINpnIk/Opt/g/cIbX0BBw8YVx8q0bhs4RPvt9+fVerfR041f4IPwC/+6o2TlSVmy 0l0OobQcwsqMBCgROtKJRnk9gaUUmiP95YMj0zeOyctX4Pr2EdEbf3m9ChqnMp7Y+mGDV2M1 ut/S/fCOhJ5+TBI6PJUNNLTeFjXgXIsIsM9GHeszyMg/Pk7PaQA07KiBU8cXPM2PLtUUPgPd +aDPD68v22eXg3h9VV+09PRDA22eDqS+/oZJptoyjSoIJChk5OKtmXaz6ea3/3t7uP/z5DEW K/gfk/Fc0tiWz+NdWM7HTabGLE9MqsRdaQ4mNOSkAKG5CtRM/939evcw+brbPny375fegitk uTP6q+JTHwIqhs99oGQ+BJRRe6HSpeRiziL3hQkpWcL4QAnpasL2vjHlE96FDv09e1OnmdOs pKHb2Qldyry0vY4WonL37SN4NUVCMqfMWVam+5RBRAhOnHkX3vIx3e6e/kYN8/gCYr/r+Ziu dEnCDvc6kPauEnyt1iMxyCHdIFZyvW+lC/BmlTbjggSdfQ6Ke9+kLSMEpd5fXDul5uHD0g4F W39OFx7CuDAUz2RzTSip2BK5g1dDegPWPfHF2i/4Ewb9I4Re1hl8IRFYO8nsUlFFZ06QZ74r No0HMJGxHA/Kkw+3L1B0sJwNCPPcvjDVjmTnJVrYRRwaRZFlbrk6eGdFzEllBCZ19x6Rqdbk uv4b3MWRA6TFN3rbTx60q+zm5PmNpKHYIJ8z5TCnAfhvO1owqr/eI+mmZA/b7WNh3znCbwrE GcMBKyzS4ByffGpUULhNU1alASKbpI5u+hHaeUvr0g980dKJy/WKMa/r3d6vY0i8M/BRF1VC uhrxVlXJ9m8RxdMO6nQJ+65fxA26DRRs2lnpadXwEXwXLICY9zpyt37eP+rLbpNs/cMxUzhS lC3ghHrTMtW7J3dOJnVS8cAqU2lxsxh8U9XKXiBDWOgBYpronuzblyJNwg+LRa7CvWi28tJb UVf0ggOVEyH7dFtF8vcVz9+nj+s9mOQ/t69De653MWU+R/6gCY21YhqZBxwCX681XWH1Tj9W 9AvODbrgoz9S0ZJEYJRuMX72CD2yzCILjTSjPKcy+OMBSILqKSLFQq1YIufq3GWrh50exV66 WBycnQdgU3+aEFUdWSBWfDP8BZ8hj/NEyMTfNcSAyQ+5Sy26lsxVD+Cn5O5MK/cFgNYDkQCX IXhajwiZiUnWr6/b5+8tEDOphmp9j5f1PUkE6w0LRvaWrJj5ko633mGrvVU34KaUOypYLRlP T5LMSsZ1pm6cMhhAI0bvmVrinb3Kmz7EJobZfSh2gjndHd536FCvt8+bhwl01dia8Gku8/jq 6tzdYwPD12opu/FmZVC+vQMMlo/TjIi5z/AO0VQi9DvAsVPWE4Os+3KVx/NyerGYXn0YaS2E nF5lfjORAR9HWpTzgUDD/30YfAefXZLMvKS2E7INFtwuvLKD2PPpp4EJmRrLatIK2/2/3/Hn dzHu3CBR57KOx7OL4Dk6vcu6rwIcene/EdLerXZ1S0ERN8Kniqx0085YrP9+D/Z2DTHbox5l 8s2c6D7gDYwLUTfJmMtuC+EmI31kIgO4mKQ0AM5vWOwvUCPwrI4eU02B5w5zh8epmgzCCLc0 CanwaaV7sjTCnPlslreOVb7d37vcAqPup7i65vhHsDywahOVPgWmmzCx4AWmukaXha63LwCm DBfHIHXfQc6GKZ1uACAK8hvgmACYEwgLgi98fcqo+emotrIWGLzFaeHWU8xK1L7/Zf6dQnSf T55M5jyo8zSZy9kv+ofWWhelG+J0x7/4LPT1eAPUN2Yv0XNvfxhuyH38pYZViZs1fLR2nBar q0tdmsvGZNJutaB20guxdcRchgBArTL9EkDMOUT8ntLTBBGNml+am565c0QsVhHzI74b0syy mkZjxlEP4T1nA/D8FiJ8JwxLpBXI8tT+rOqCSbckA0AwMVI61+cBSEmV3YZRCx794QCahwwO DF0A5+UIwJzAl+N9aYi5luh728Veg+DZ0h2Vg6l0fvoEnHf9DP3JAyhy8+nTx88fhggwRpeD 9liRVG7CvrkUODj8xTKnw6Q3Qv2f1GhuFSKqh2pC/Qsg4GvNPXhKItBY1jYaaOwBJKlmVNpq zQJjXUOAkNahH8yxyDKIhMa6SOOgiXWW3ulpK1/QBmD/z9mVNbmN6+q/0o8zVSd3tFiW/Ugt tpXW1qJsq/Oi6kn63KSms1TSc07m31+CpCSChDxT9yGL8UEkuIMgCOY1FyNaDAQelhcvyBb5 WRYF0TBmrRlozSBKCwzFLc0thrjZuaoeoTNRVtATq/vG6E19cahU6xgpSGI8DD515JnyfRjw jeebX4j1rWz4ucvBTADRishbf+1YlIa9h7UZ3++8gJlBSQpeBnvPC21K4Bl3NXUt9gKJIjPM gAaSkx/HyJF1QmSee2+gLzxX6TaM6PvgGfe3OxqCSaCAU4e0DbVNnd5906olMsnr2Wf+Rp1G jTw75JSDCfidjF3PDc27vbSsNk+1TgUvxF/3+aNYVxIz8TSAEe4u4rlY2yp3AVf0kfXBxkxl IUdksTVe5keWUqq8xis2bHdxhHqVQvZhOlBa/AwPw8YIIqTJYvc87vanNheV89nC8tz3vA3S HXCZJ/40iX1vGh+IZkdoWYijmGXO1WylUAEWn38+/bgrvvx4/f7nZxkW5sfHp+9CGX8FSxNk efcCessHMWt8+gb/NY/V/h9fUxOOnigoBM8tcL+JwXa/NTb0x7y+PmBjsvg9q8D69mGXp7AS PS53EfL0hC7jJ2k1Xqh7LLIvszKFiFVIt5/6+BrZ6tUnlrCajYw+34aIabTxF83Yanuc8mLa KjmjQXrmV41hBO1YkUFEUxTNJzVdBuQ3VoQ4SYNQgNZV6UUCnbUKPfCLaOQ//nX3+vTt+V93 afZG9NpfF6GmlZUbYqWnTtEMXWCmHQm+FO0LpHwpxClmTvAjk6VsjkdLbccMPGW1Or2gi9lP nfmHVcnS0C+r9TOmQ1Blt7olvSwS8Q/5gVv7QJceAbwio9JJnq6dhVh21pbcTpVcZTibtTSz k901TmOXsdSpfkEXiye/ric05lXqlEuQWXlmZG+n+vY8AYg6WmoOrvdbx9lMnmBW2I6m4zYl DVz3g8kAQ/LukVFeoLXydEtZMozT7/9+ev0oJP7yhh8Od1+eXsXu6e4TBND699P7Z6NzQBLs lBaWsFWTwFWtUroBlUVqTEbzJ/O8ZUx7QE7zCzOrXxIfmq6gtCmZWiEWW38bDJYQDE6RJ+mW ZgGIF2WwIZKT2OEw1QgU/r1dK+///PH69fNdBlGljRpZDrUzMYdmZMxpmfcD+PNaovJhY9QC RH6o1BylxBAUWhbJZmYum7QohrXMq4tTF/VljRnWY3AttGQtSqI+KW1TQZerlcC5tLvLpbB7 +6XoIX72fJb1tzVgjgtmZqAoVWZTul5uMRCtFzWH9h2a3O62MVWlEk6rbLsZrKTSR3VjDlPz A+uc5E9tH24p5WpGYzt1IA5BTVFDMv0hHOkeKTmKfhf4oZWaJA5Oam+lF1ZNrjGSoWJiw0yG IZRwnfepgJ1066J+y0Jau1cMfBdvyJBOEm7KDPq9ky6cVVlFxwxiuAZesN68MJzBoIJrp2NZ wR/t9u2y1KKgADeKAgaFDt4WsL8WA2u78xyizTZ5o9gl7bviUOar5VBjDH9yLeqkIWyIbdG8 +frl5S97yFnjTPZ8T+qEWMRKN4XbfnbxoHkcsbp3EMpq1bfm308vL78/vf/j7re7l+f/fXpv mg3RRKjP8tdqRG2HDDuaobFNWlyFj+GyEU7EGeW3U2VS+/TM9CTFdyku0ybaWhnNZhg6L+mn awifSH9vMw1FURsisvtrBm024C4n5lNeL11+LHhv++BP1ZVVU9gVCjPdROzdm/xSBe8x/EX0 dk4d4VdiT3HMO3lJhbZOQyIF2IULbkqXSQ9jMZJ6cI3CFyczuEcMl+vbPENUdUH+s0HhNWtx EH5B7E+FPCu/FHDNGt1VgERko+AiqdrkFaXOCFieuk2NuZDzhFvpiA0inUKKXcIEpSqkMmim B50Omayq8V1OOknA97NJEH8x08cH2rsF8ax4MyKeE6cceRBL0TBUkkzGm8aCZef1zOyLBCam nPNoCQ4lu8/tjOB0tKdMKtBfpBul1WoQ+F02MaUwSemcK+La7umYCMUuvpAjgywNwBAvYeUA DeBW7kBIe1rTtOCPp/Omd5RJS8AaPJy5FTdWUWAnucoOu8Cl2JoGEfH4EZ3TagRF6dI0vQWe NOciz/M7P9xv7n45fPr+fBV/fnXtCIeiy6+FaR6fKGOD9jYzWZQdeXvMQN1wK/7jdMP7liRT +vUFOWeIn2Mrpk9nJSy+fPvzddUsUtTq7SPDcUkQxHJHRs1X4OEARxylFeRBYeou2H1Fuuso loqJGXS4V16Ls0PXCwRpnPdIaHnWnzUQqyGnNiCK4W3zKGDj+ryk5hdFtFLLL9b6ZdTV2g0b 9aUY10lj+SZPNLGXoz25DIY2ina7f8JExU1dWPr7xNAzZ/pD73umiR0BMQ0E/tYjSwMuffcQ Rmi7o23FM2d5L8S5JS8czpN5SA8bCJVHBnmY2fqUbTf+liixQHYbf0cgqqORuZbVLgzCWxkC RxiSqQ5xGO3JZKuUGjUL3HZ+gA5iZqjOrz3eKdkcTZvXMK1zog05q/i5PhLSHsV25FDw0xRR 3eXgfXNlV/ZIFkikajWsy1M88G1An9AswovRTtlQjFYMRY8fiLL1VSC2Mef0pBZUGx7kQHA/ S1nr+8NAVnaSUgc7xjRjmK3hp1j8AkMLn0gjK5EL5kxPHjOKLNabQvzbthQoFGYm9jcpmeAM ClUwOZMskxGBgORlR+tiyYIKjUioEWa0cRdbzxa8AfPS8shZcpbtRt7FXJgOEGxuTQIyY8e3 WVIhuGkuc7QR0d7RPt6gTZME0kfW0tt9hUP54bBlVf4LH4aBMbf0tjMSln9uTnWQY327wGdO vRgwL3ccnvtaKmeijGLvI/raUgsLEKJla6FnVBENuCBySZukY0Qmx0NwT+YiVFVKK0C4mCOp JMU+scyrpicwGdyVpRTEiyyH6KbmVZUZ7KssJciFZfi2AHl69ZkonIaDkHp2Zua6wgMeTUem UIkNayk6HNkflzJBtKumS/4BV0K/8LEwwXV5um6uRSZ+kGK+O+X16UxtJ2eWLNlTjciqPNX3 GJ0Mz13SHDt2oExSSz/kkef7hLyg+k1xG2xsaMkoaTPecuDQl2Dczxd4PND+wgvr0NHa38xx 4AXbrg9pGfsTaeOKAp1uFA2aMnopNrmKts9XNnkL14nVV0a/yrEw3Sfix4owbX5knLy4p5nU FC36e9pUG1f9ltM0T7s8p3QevRIXHC0risqy2N9QvUTDfZWXsPirhcD5PKmYvxI/X28MwsEb k3NPa2PTDmaI423kjU2NlBIT3YeilmEWdwtfVUJjvSmEVIqTPKdv/Rk8mRhRaHozsEsB87OF pK2om7G9dqqIrnCsh6vuYqrNqYls3gKJCabWfHYW90P/du/WvLziL1RyyolRcTzmDDYcjsiV 7+1dQbv8eC7h1Rpdzzeqs8v781LmG4x9y7dR4O9oZsR6VjtnR6yWlRUEffjbBNr0EHnbMBzb 6mx3IYHtonjjkK+V7hVE9QpMtvhqht39zotAMKLPyg7TNfDAJjiH6T5lZZGxONh5urpp14KJ ce9FgRodq+JIpkgPob9cbBvSw+sqNmb+MJo222lmGMpwM6yQbVULg5alyeIqKrjvR/khavyB B9s9syVNKxaidzcQGTvx6HJ3l2DrDVMVO9UC8Da6DcdrcCej894c/LxvqyL1V1uuq4qNY1uU RFpJlhByY1KUKrEoB9ODcKLIRaSxOINMu0LZ/KZioCmBTQmRnUPTqH2phpjLHiFLiLQanZ6+ f5CXieFJCdsjRhbhL/QT/sa+vorcsg4ZdTQ1hU2jnURZJAS1Y1ebpL3DCGZBAkM5Op9Xn3Qp gLQhV3G0yW0GZdXh1BJytqoE1ELrAS5NGWseRYZhZ6aXG4KYV2ffu/fNFpuxQ7XzfCyuNrVS bTebYSnLqTJMfnz6/vT+FWIa2C7DvWmNv6DXg0SvLXMVmElF2uIm58Sw0E5Xlyb4FjKEM8vQ MdK5Loa9WL76RyNtdXa5StTPJBtPvpSZ9O07942OPaxvn33/9PTiXrvQqp50sU+X14Xrr1/e 7OCtoh/qO+kT57rlqY+FzhSicDCIPjj0M+v6suhzPFgMAF6XOctbx77FgX3bDaJR2ag3C/gt GdJLg7w4WC8sImBK9kYCaVoPLZWABP5JAv624PEwWK6vNryO4HgBDmptjjSepNU2HEj3IcWg 5563PYNXhXonAwt3e/ttvjF5hCsChGT6A2Bel077ardc8jl1I2ZBV5AuXRdSYKLTyUiLTqfr 2sD5QNCWXhoGTiEOvBzL9nYZJE9Rgy8HWcMWfqOLi1/5IKNfFMciFQOffA1Sj8q8hrfWIrfH tF2GHC7xlGFx18pLNWPmU78dvHbf4+UxfUxLlpmW7/TxHRh+zPtYzcDU9bvS1BkkmVdMB2xe Sv1Yp/J040gfWBacOnqsx1NWok3pbF/vyZPdunnXVGjs1OeyXGFW71HC20jmjk6/Uok2RqfL FFLEaQIZUvzMkZ9MJ21ktFtTSx+pqRDXbmcvhII4qsd8zUjVQJURlzLLYVchcMNhXDsulyzq 0WxlzDvAew84bV7YBDG5Iv0ViFd4czJraA8WJQlsQpsVQ47gSBxBCIHFAuw+jzcT1YPA8gGz W9+OCduEhsq6AHN0cQfBj3Qu9DTtuxo9Wr9gQ9GeaO8PsJeLkW562uQXdHdN/L5HBLgqbPc7 OHOXdIiwYSgR4jdW60SvOaqH52QNYfcE8aetHM2a/wYB5t5b2hblwtXXYRBTjx8C4EfIjCUp 1Kq6zA5p2dqDFIOXPgi8lXF8qmB0YudZ+KY5kO//witcPWtn/1VVaLgxcPdx0k5dvWn6ahTb V3NhX+jR3jNFuFTpyn3NppZOJuSED8ldqjNqLbFwlo9W2K4lRpqjGi+dRw2P7sx7/SgmhUBM mDm+lDqVF3tL13HBVFjEj1Ee7cFVX0yew/ovwxyo8nVk0pdAoNV5mPKu/nx5/fTt5fmnKBDI IW/2U8KI9T9R2x6Rdlnmtfkwj050OgV3qCpDi1z26Sb0trboALUp20cbn57FEM/P2zxFLaYO 6pBg4uhyNK8AOctXPnWSr8ohbcuM7Cc3K9aUQkf9wvE2AeA4mJVsg/LYoCdbJ6KoDLM3zbs+ CNe0tKaOH3cnUhb0j19/vNIR8FBBWVn4UUj5Gs/oNrTFFMQhtFuWVVlMxr/Q4M73fZxQscP3 OiXNegITgeBrSz+DC2gtz7BIuy+glyIrmOitZywEL8Q2fR85xG3oWQ1W8P12wHzgafyXRWi7 ZpoL5dCXL3Te/Q6RtXR0lF8+i7Z5+evu+fPvzx8+PH+4+01zvRGbTgib8isemylE7JKDD2Uu VMriWMvQd3jjZIFiu36xRrOBGldTrHGysKQr5kXBllf5hTalALpyjgxQo7xBkNCiny/yIIG7 +3CwOxwvqj5fMZwLWG2QnEU5/ylm9y9CrRc8v6mh8vTh6dsrFSRS1kPRwDH6GZk7gV7WgS2R vsW+KlLXJE1/OL97NzZCAVypmJ41XGibToP0Rf24dqQuex7EHpCuXbr3Na8f1eyki2l0QfO+ 5+qMgjo/CgQsKW6vkiR969VpLInBhePzmlOq6nXgBA1dY6WY+tKrmBTtHi29p8/owStz6Z2Z Q2PlTbOaA2UKOLY4215NsrnzEnuXBaE1kqItJM+JDK6E4hXCweyciUmTeqtSqNrirnr6AR10 ubbmuvfJe4vScIBTYoO60yiWdIhf/9nExGKTMBxGXJLPPWwfSko7BNyJlAvEZb6w6Fd9BxXT 0E0KTdMBGpEsMMxWxADjEpgGnArFUyVQyir2xrJsMVWZFxL8MRCdFBs1/Gzh2oEFA+07BjAY A+zINgbMU38n1hkvwHnNBjmzOwxmRA+gDBCFx5bHnfIM8N1j/VC14/EBX8xuZRA21NkM3cbV 3EGa8zBr+4K//f719ev7ry+6l1p9UvwBF1Yk/OJznZv3hAHqy3wbDB4mWnPNTFIPG37GlaAQ /igGVSVfTLCeITY7lx0rRccNXTaiK07jbevenm779u79y9f3f9gqWf5Fvr/Rnh5FZ5Ovudd5 D7eiIE6bLALvWQVx4u5ev4r0nu/ExC0WpQ8yeKRYqWSqP/7HnLTdzKYiaM3WOI/QcVg1MB67 Br0LLehIgTf4QQteHjk3v4D/0VkgYMpTbN6CkHs7fGrooKhn2qiLwBt6ZU7QBz8yre4zva8O +NqcBtSpN9FJJgZ5+Ex92aR52ayErp7kn2O5c1sdUgHLnr88/3j6cfft05f3r99fqCV6jcXN rBQ51exIXtuaBYLdKXOrJ+WbuPSjFSBcA/bG/AUFRDOqJsiIS/JKiwrKFPnBxNEcrH3l9Inz NrvanqLJZCaNF9+iTtFtMVW6P3vL/liFzPr89O2bUMNl8zhKoPwu3gyDWp/MoLftfEJJ9gAl 3Wo8NuUCc2WtVV/joYd/PN+ji0SoyArubDd1ST6VV9rvSqLg1ZteqNNvVV/JbsvNS7mKmtfv /CB2suKsYlEWiP7RJOf1PNUKdwtv6EVVoY88XXGDkfg1zfYh6WMl4fnFBdSIcM1QR6LAD5xQ XWPe20nq889vYk53u4y+K2HnpKg4/JZGaruzH+FFhcyufNmFPYoa2A0lrSihXVpN1TLg2pMY aYrUMLj22An2bZEGO98z64+oHzXkDtntekuy2IuCnVUSQfV3gV2bSSaE9avrxRmWyolnvZco /50bOK13Suwtq9+NvRlCWQ2lNtxvQoe4i6Nt5MinJuHVYadd9JzP3JUK4/oiwg0G7SO2lrPE 9/hdVgU8VMOOMu+oQSfdmpyPBHm/tyw20/hy+8H8fsPt/tHvBrefix2X2KmP/tatMnhXQ4Jk HAzlO5alYaDlNx6BoOQDjfemfGKp8LcbpyqkL8DeX52X1LC2V7EqDcPdzl4I2oI3vHNKOnTM 33grYVldsdXlNZ7cLg6yK8zJEZ/J5C6fvr/+KVTWG0spOx67/Mj6xi1AJTZM55aUn0x4Svfq Twu6/+a/n7QZY9mNzJlcfb3ZlperGqotFpaMBxt8BoGxlfhsJpN/pYO1LjwrBrKFgR8Ls96J 8pnl5i9P/zHdeUQ6eqN0ys3oMzOdg6HBJUP5sMKLIWr6QBxmjA386XYFCJBB2YSE6v132Zm2 Wgz4q4UIqQt0mGO39nHkrfSdmSM2w1tgYFWkXe5RMxRm8WOiP+h2n/Vz+R4ZRPRER0cGeT3c sM0E/+3ZilHTZC77NNhH1KJpcs1+z8ZuAsEyszWpb+h+Ltvt43LN0+XyFYeqyWiFFGJtVmtc KGt4p7R8dCVX9NWQE5NSz7J0TBgY3gyfYe0tDLYS881LTZbpo4NoeLJFUomM4NAQYkqABupt jYVG5zqytN/tNxGKnTJh0vGeSHTGr4GHz6knBLr8ltInTQZzsCC6v0IPKCF5Qu3hp3ILFF1W 0yE26I+mJJOHIB6Gwa0sDdh+2TZ8yqjYFzZX1o/nNmOi+ex78XOh19XZiUUoEH7sbW5VtWYJ qBwkFpD6yVSDk8+/4dqkkYK3kLBhWNeASHW3N72jJwD0YryDnJCVJXFJUbYbkWIfbiM0ty5I uvG3AX3aa0jqb6I4vsmU5b2Mkq24t/i4k0pSavE3S6Nu27hVKvrGxo8GqjwS2t9KFjiCKHYr CYA4jMjsIsiOaBCAdn+XXbTfeWsfb0kvy3lcVkm4id1xfmTnY65WlQ0xW02ua+6HXR95IdHl ul7MbhEl5DnlvufRw2suiNqW/g3Pfr+PqDX8dEUh8+VPoVpnNkmffym7l3JEVhEJCb9lHWM4 i0Pf8Cg36Bsf3V1DCKXBLQyV7wU+lSYA0RqwXQP2K0C4kocfxySwF/ojBfTx4K8Aoe/RddBD iK6blQAcpIAC2AYrQLwixwYHG56hU39bCh6SKfI03uJYDDM0QHz7+tbJx5xIm+cZkXg/tGTS qfiLFd0IDyrROpXF2HLaCjjxSWe8PqfjoE48fEtF44YI2VQX1Ze3mBmeDmFkMxTR/cgq+lby xHOIfbEToU7tTY5dcDhSORziKIyjlYi2mudIPus+o2Xk73jlFksAgUcCQvFilDACIA9VJ1ga oVlNfXoqTls/vNVli6RieUXWclK1ZNS+mQHM1XqmdL/ud/GNb9+mG2JMCmW48wOqA8nodsec AKYjFEoItRxR+1HMQcxfGrA1Rhteu8uH+P6PsmtplhNX0n/Fq9lNBG+oRS8oEFX48DpIVFHe EB63+7bjuu0Ouzvi9r+fTAGFJFKcmYUflV+i9yNTSmWe6Oe3Oo/thdOTB+QLyum+yoHGp1RN As8jWlsCge2LiOoFCRDzGAWs2WBsV3KEvKOhgAyRE5EzXWIu5ZxI44gSukgnomPlyV5MtceM +OQOhB7oYQU7LkgU+cTeKQFqtEsgJJpZAvayn6hPss4nhQCRRSEpV4iOe34S0Xadz2RZU3ju uc7miX7M28ewsvmHPLDQ2yww1iFWR9RJzwZTGyxQfZJKDe6aEleASoyhqk7I3BIyt4TMLSFz o/oQqNQsrU9kbqfQ88mOlZDFXlfnOVoYuyyJ/YicCwgFh1O6Edl8hlkaLqVXPBMwZ4lqIRBT vQZAnDhE8zRdVhuvzdZSFkl4UmZEp5vwPvlq4wWLKtp6pP9jjYMq7ZlVU1cQuxXsqVNWFB1R jrLh3QC6ecc7sjhl74eed9ytwJM4EW1zu/F0PAzMF6omE6+ixPWP+riqvdCJCCVCbmfkbJoB 7VCR2uj8hPSmbOwXhBI17wUOvT95jn1pB+xwb53XXWp+IxIElJ6DZylRQm1MHbQCudt1dRRH gaAfwy0sI4MNkcjuNQz4e9dJUmKOwFIfOAG15QES+lF8okozZPnJ8HZMcHgOUZgx75hL5feh ilzqA3QoUahB7laAnwUnApNwUMSI3gAytQcC2f8PSc5IkWUxMj9Sc2oGkkJMfczqzLzW23N4 oE1bPo7wbPbga17zLIhrqpoLcvLISkn07J+OJjUXgsch3Sh1DdLKW7u76yV58sZxBY8Tj5gX EogpFR4aJaHV57JJPedIPEQGancAuu/R8lJMrCziWmeUpCbqznXI5pbIsTAkWY6aChiMWFoq ciiNAkPoEhvsrUyjJCLVzJtwPfcozZtIPOoM6J74ceyTejRCiUu5xFI5Ti5xriEBL7elejqa YZKBXGJnBNcay1skhbGCFV8QO/UMRaoLTAWKvPha2BBGQrM1BjFGMb5n7TrTUwDfmKR4lSqG owsBQzOJkus+WVaM1ay/sAZdMSyXbbOT6qnmWxyUlVnGP9wuqxYqvt6TkSLRMzl9QLKy5kz6 gp8uLQYYYt10Lzl9bUd9UeCRFL+m5NsC6gP09TH7ottXXE+Qqpe1kAQfWuFPiyk+AWsF2U6d u2HlIpLP2a3o2avSrbsSsnqYPXkclM60yRflxNvsIF/1PnPNW73vJh45r6MUPbO1nJdn44k/ +eblnNWpyq6Q9V9zsCW0EKIS1zjo+7UnB1TczjE/LD5OZeG51Gk2ZTXV7BqbYc05Y+Y18vbO 87e/v31Ci3F7VO0iN/yHIEW59lWp3I9dzR3NSvUskUtq2eldCCo7ySC/T4WXxI7tgY9kkS7w 8F2H9rh7g65VlmdmwaSPVIe8Z5Lw007QrNDYec5oc5Ja5Dtj6Y2mv+FV6NrrEdnmpmH1k+iH ZoEk2eKv+omTl3Ebqt3vyn7Bk2+fjJeyoqGnF285RzdcpyiIvcmWY3biM/LU+Qlq8utCdcnb UwnO7+8UyiUVTAabwYN0M3uQof1xtLtKU3kORkPnRd7JTPtaRiA7ybakrv4EPgzkZabVD6mQ z+598QJXHcAZFRAFEa55Gy7WwN1dLQyy9G2tT2xpvJrVba4vLgi9sNpWHoSTpKsTUn3b0NDs Q0mOSHOpecrMt+677pL34p4tM8U+dkdNIop62o0uSU8CSupb4OTkxMRXyckSe/SJkxrRhibG siEi41xspdrTWU9R1XZjH+SzeeoyTa4NiOk5a7adCh09Tuqce9OPpwPI+aptW29Wus2HNKb/ NLdVieu1vdYMfRaKMLF1Er7LSXafNKGIXPqmHnHOsqMNiJdBHI3ERsnrUNednkS7NZ1keXkk MMiptS89j6HjrHk9v0rP6E5sV0g9VVDIrFWQtm1muwh86ef74TgJntE+s5HNNGOfaUmc7Bpa 4MNKyq+kHDHSUl2RZzseuU446pTQUY+eZko87jKS9IS2ttkYLLdiTwbPpa171rpAJclNUsHR lF8bFKs9vTkuJD2JrMkRZvYKfbe90kxHmxkwwWLt06ey4l4Fjn8wwoAhcoI3huC9cr3YP+ap aj8kLW1lGc2wCZIoHxoYC9WYhKExJJ/XtKZI15cf2iY9bMGVhw7RI+tWJ4Hq0W+hGY8cNuqB 0LAwEKIUIqFz/OnpFBiLc3ut5+cw40gj8vnMP/Q3JrL4TNUTWh9KqiWZX1VtxNUfq+56YhNG llMG9UnFoZbyTJc6y9+8JdvMaDeOohwZjJi2EumF0Ymgj6ph9hrHh9ryjH9jR/Vbat/kBzt2 EHkuMPPprFHbSiLqJFjn0TUyBctD/5SQyKyx/UHlShivUTz68DAgdbSpEPECa4NtdsNKhxrK h4GEVKZ7dUHDXMullsbkkXZXBotLd2KRNqEfWp6PGWxJcpyP7qxgo5e8Ovm6PK2BkRe79LPT je3oNbDCBRu+ekpuIGTfSPPd0YaElmIvO+gbpZGiBlWaebuwJA1gFFN3qxsPpWzoaEi+cNN4 DL1Dw5IoOFFtIiFdxNdBUDTeyjc50bNEQrFvrRPqG/+HOqlak4mp5gIGpt2gm5gXkQXOOhea kP6uC7UwWSqSJOHJhkTk2lR3r/HJcyxNA/qV+9Y6IZmOx+tee9swq18BhSVLYam3fb/oUscp FMmoSioqMnxgs19iKvEbLE0RLTIbXG8sYZLnRBfhXlPk1wz9Qc7ONmgQw3TcNPOKjaFPeXdm ff9AfyFbKI4pFYuTlv0Xi564B0AwopunF0FCXpuqLKbGqmL1zXIQujHx6hKa8X/3TKaEpkCg WDoRKScAlHgBOS0kFDdUc+DtvRv55Nx8KnAWzPMjy0ibtTMyYJ3JFFvEJom6ZHQig8nQxUyU dAxgMJ1ccoG/Sb8qBPDUCygkcMjETMneGP5Vei7PapiBzBC0e3RBpQVwr8qeDGKQrWFW9HiX /dSwJ0R8Bwx9Fj5DtPyh0SOS/v6WKXQ1K942DyovjSdtHu1xgfCurSOzrkE4fznnluzHunsr 93J+fXHYGnVNpS8bGL3uko/PmNlxNUM3hEjv9UPqJx0fDNq8yM1cBMccNvzHxz9///Lp595t U66+/oUfs5Oy/FxSVK7cXyA176Z0GFevozr2UvPFx6WeEtKL8wppnxRndNjyvHykwPbG+rQC 8fUXWB632iMDOledoBVyjERb3+nb3KXU0Jp66kIYzXDr05osP3CS9As6lcILQaJiWGcbht/x K74lpVCeXdnTbx8eB3z+9un7r59/vPv+493vn7/+Cf9Dv5DaY3b8bnYGGzsOfTS2svCyciPq WdLKgK7UBGg8p0R7cLaDzbBPiq8PW4llkdO+3seakE3WwoiejUeWtFRWlbNPc6aaK2w0qZ93 QjswQDSt80tHHU8i2LTDjaWDWtuFtMaWyMRITTSDeY7tHpLk1ZjgF5+G61o5ZdehbuBXfYis OL4FrsrLVZjVvV1Il90SgpGpt9yQV2ZHp7Y44rguXNKL59DijOyILO3Rg981r6kDtSdLdcuN gryOlU44g85q8HRpw6r1PVz+5eefXz/+8677+O3z192EkKxTehbTw/GdcXSimFaSFeZexjbn sBiRUSoUTj7w6YPjiEnUYRdOjfDD8BSZDTkzn1s2XUtUwLz4RF+q6czi5jrufYCeruyzeWaH FXoig8BuLPuWnum8rLuK0UVmVZmn00vuh8L1aUuzjblg5Vg20wsUGjZP75w6lHCm8T/QyqV4 OLHjBXnpRanv5FQZSwyB8gL/nHzV5JNgKE9J4mYkS9O0FTp6duLThyylK/w+L6dKQHlq5oS0 HL4xv1zTPOWT4I6q/yt42Vzykndo/fSSO6c4dwI624qlOZa/Ei+Q1tV3g+j+Rmsrn0BBr7mb eJSRotLPc0zlqcpPTkCWtwLw7Pjhq0O2McKXIIx9ug4oPDZV4gTJtbKo0Qpze0ux9HLCkOdu JG8UxZ6l5xSuk+O+NV/qtBElOvROCyeM7yx8q8BtVdZsnKosx/82A4x0+n5P+aQvOZPRhluB 1+QnyrmTws5z/AOzR3hhEk+hLzhdVfg7Bfm5zKbbbXSdwvGD5o2halGQqW7u00dewqLT11Hs qo8bSJZEM85WWNrm3E79GaZSrtvE70ckj3I3yo8rsPEy/5qS41Nhifz3zuj4b3LVZNkNFt0J pZ0t52+xJUnqgBDCg9BjhUM2rcqdpsfFawtIxda2rHxpp8C/3wqXuh1ROKUKVb3CwOtdPlqK NTNxx49vcX7Xb70JtsAXbsUsL0DUvUfAQIGJyEUc/z+5qcMDC29yupGVQh00zcbAC9KX7ogj jML0paY4RN5OooJRfudXn+wu0QFH7niJgLXA0m4LT+DXgqVvNYNk7i7uG8um6IfqsUgk8XR/ HS+WlfNWclC62hGn88k7He8isO51DAbf2HVOGGZe7KmiuiGKaVJcX+ZqCAlF1FkRTZorv/31 +cdvHz99fnf+8eXXf5lqgvTTvZtx2RU6He8aUQXyjfm/bsVAaqTPDh2u4Etc1Cpxilz3CBvG zGxJFK4mPAigDlykvIwqxLXs8P1D3o1oVHZh0zkJnZs/FXc9u+ZebYq3kRNqXp1o/IB0oTO3 KmpBU8eTyPP2Xf4EA7v0Duoh/CkT2t5q5ihPjmpJthLnF4MaEeXLtZd1lfpaNuiJLIt8aEAX hEADb/m1PKezVUAceYfoTrQycOo+hWBLjjLR31RJHPbToqMdRyw4b6IQOlK9T1m/7HLX4476 zEjqXTLcPaxdaTNGfnCAxtodrIbmnVlU7cPIoy4xVvU+zW9x6O4WKwXCkxRLAnJq1te8S8Ig olaH/dRWP2eiSW/lzcx7IR/Zt2Md+6y7DHqT1CPXlx0gFGdj4Sj7HlS5V1YPZsaX2vUGn5wI eLmALNcx8cNY0VxWAPURT3WPogJ+4NJAoA6VFahL2EL8V7FHetal2qnUCsDWFyaaMqogsR9S x5pyMZPHHcY5WV4YI613vcRsq/pik3ExLorBzNNbejnWr0GEZo2Qh4LT61D2L3w9Eit+fPzj 87v/+fu33zD0gXmQVJxBG87RocNWC6A1rSiLh0raqrSeHcqTRO2rXPUcginDn6Ksqh42kR2Q td0DUkl3ACj+F3YGNVVD+IPTaSFApoUAnVbR9qy8NBNr8jJttCqcW3Hd6M9eQAT+mQFyMwAO yEbA+r1nMmrRqi+OsdlYAQoHyyfVlTcy3y4pegRXebcjLJWKzvWWw1GuJYHnMlh9MceK3Q+I Z5yx3YsH7A0517WculrbKGcKdEzRotSwCAx03bMH6FWeo2pBKlWOHr3J2w4jkvfk7QC2j5tL o3MtvTlWkVHGJYARbSy24fOB5D/Up892t3V+X96oGY3jOQ70Ks8OVI0izkRYvDCCGEhQtnxW vgcX5etAGw9ubHRAxA23tsjzyFir43xmbLMO3Djebq2Zz2aRBhypeLjqw9QniT7FnWFbdpw+ kUNkt7RqaGkZeg1rYWUp9eXu5dG3Rov5sBnQKdzaNm9b1+C/CZAkrYUVIBnSkTSx+v3LbmZS mh/OubSvtYA2Gw22lBREiJv+6k0Ds4GLljpBxQYz7bwljWdDQTsaAXjIKREF580ZRIpRBKGx Yuy912HDzWaJ+jxjqNm2epgTpJ+hkcn3TlhaDouKE+s7SR27mvZG7qlycT1//PTvr1/+9ftf 7/7rXZXlZgxx5cgdD8iyKuV8uQIlivMc6Rqj9q7tyfEici+k+ntjQYOSP6hv9x4ydyzyZv1e qT7PNnBv3LthaY42RrRnTY0ndugEDgx5Nqaq9iPfSenqSfBEjj+FCYTwkBoTGkusBiVQKrDa j+6QxUSRyvAWek5c0ZE5N7ZzHrmkhZuSe5+NWdPQzbfYGr9Ve0bHanxjOK9lAUEFXzorKwrs mrBEkmIJXnStskj2/dvP719B+lgUnlkKIe7gh7p+7GMSa2T4txrqhv+SODTet3eMU/uc2LCY wf5TgPC1T5kAFw+mGFS5TnvNWzHF3bdi90B4i5V6XO+1FKCFKiIh/prkkTpGbtWeoCkQ9IVL WWIqLFk1CM8LVPvynfnD+hlvh0Z1CIA/p5bz3cMbHYFWYrBoldQ+wbUEm/wZFVghdVmtE673 nHU6ibPXdUnU6H16r0Fo04lQMDSb2FoTiXU5Qo8BpE7RJXsk04WX6Fzmf/TPlqBYkG7T9haH hVjw+Wp8go1sSslnFDKXvs2mgpt53PDZGWcSLux5bGxlI14sWawCr0lav9ahTFQTCAZlbtie LH0xYKye3mxJ2Uk4DS1FeH64dIPxKXbkHD+cxvZUkAT2wPwsnBtVxWLpfCmGV9NJW3pavWrR pVQU4RnjmkckWTIZo31wo1C3WJX83RDQbmZwGMBIqdPGG4P9INWGjlxQr/l/p3//+uW7GgLr SdPmU57iHJWWQiDnfmC/RIFWYP3JDZLoAJqIFGXP7mVvjJeVOmlKrGz53ZxtR/VoFyklX9Rc rQwyTXyobCnJmZ1bI7NnMfLyUjrOSCaJuEh5lloWrI2rbsWwz2CJXK8Pfd3nwdw/Zb7f3a7q OQr82Lyyi541F3FVewJwWOCIUg5XzScyJLPF8ZrDr/z5+dOXj19lGXbqPvKnAV7C6kVJs2yQ 96BGGQDoB1qol2jXWSKsP9GSOlWTKB/4LrcBx6o1wTOrXkrqzGUGRdtNRaE3zrm8nFmDZK2+ 2RUvf01aCb8e+veLo16TOBjeT5FapxnMM1o7RRyW8rx8YQ96NZfpSuNFOwyNI0oU9M5OaLmt kHwPmPLktoYojKtL2+BdvG4ftVInSzgI/JahzSLl4FeClepNbKYwzUXFTGsNpg/QJjrPhdXn sjdmy6VQLTQlpWr7sh24zndtK8FeFE75ezcCbiVscnlpjsCLiBLfNmShoPMkMXr+5UHpdYgM mQwfp2d9TysYqmZx2F3aMOwK9OgJAVNhKDF+nh0VtqK9T899atZE3MvmSh5rzvVvMKKkUMUC pFfZGmhDJTKjAyvWtDej87F19qvRSsUfXWdIwDNiGaSI90N9rliX5h49VpHncgqceUhon96v jFXmEDcmOXRnDYPO1qw1dG7fGhOhTh8F6Pa71bVn87yzZ4ehMXlbUKdBEsfr3Z4ZixZIwKIk l/NG0O+hZ6wvqWM6xEA6YS/mYOnSBm+fYBZS3sYkB2ugrRphFqNjIq0ejX1j6WApRk3UisNa Iw0aMvtqipfbfK+daSsymh/qY6/H46Sc6Q0KQniWCp0G2wLRJosxiiVDtJ9QpCe0pjDXJely HhS4fcqCkWLLgsG4BSlAjRcvgaHpKnOF7NVXRXKNQdunlJep2k9P4tF04KAji/ftAzOxlA12 LGPSw+LHmVwd9LXnCmuLrYbi2g9cPIOQbzd4Ct2+NQ0oTE0d9/WGGLziA+uN0t1T3LN0UlmC PGiMibGEsW12EiZntoXO8MhBpDqY8bMnuuk60L72pZRUdbbGxlDA6GNR0fkpefAZ2I4UVPFl 2SysGnOSmuYL8/zsQYt+p6b9NNvXM3ymjzfpcp2hh9oGT5cWpChj4VCM7LX0n6qRWhKl3O01 K/X7vG18IL5o8DoRw4rrrkOQCrvdZFk/ER4qGTVemZ1zUk1jPG9Gctrj1pfy6ZrlWt5mpoZq qCbRNLDuZmxq2H19fLMqCPWXn58+f/368dvn73//lD31/U/0N/BTHwGrnz881iu50QgFJFs2 pZDLZcm4WTL7EYna/OIiheIhE9UuB2hQLltUhp/hZ9kRejOBxgI6BOwx+exS8RdPhedO2kb6 959/4YHcXz++f/2K5/mmaiQ7JIpHx5HtrmU14kAxe2Om5ueL5jXoCaA/PdDrGFd9vGzoFqFY azi25GRrsnHwXOfa/S9lz7LdOK7jr3jZvegpPSw/ZlayJMfqSLZKlB2nNj7uRJXyuYmdaztn uubrByApi6CgVN9VYgB8iA8QAEGg20VMMOWOtt1ezmGYoYwuQRqTkZQ9126P0Kw+75DIJq7b 7c0NDP1a0f6Uk3A0Qhe8Tk+RnEYnbKAybRvamc0ZVTcyg+h1f7mQnODmGmEfAci9gxYzU2ZF 4EOcU0CV3/TqJZwA/z2QH1etSrxOfK7fgcFcBqfjQEQiHfz1cR3MsnvcbzsRD972P5sE9/vX y2nwVz041vVz/fw/A0xhb9a0qF/fB99P58Hb6VwPDsfvJ/tDGkrb0oADkb7tXw7HF+P9EJ3l OJr0vEyRaBQxQZLpJZD+S589uZO1yKmKS/7OWLKEh4i73dEoz16bCJNBJTuffLd/fqmvX+KP /esfZzSvv52e68G5/vfH4VwrhqZIGp4/uMrBr4/7v17rZ3t4ZEPA5NJigU/qPuniLsaQKCW5 QWhxtlfBDaOtrJ8NjAecLozuYS6ESFBMnPfxzLYt2Wc4CyO7UXSrTOOEtyM0rMLKOHhbS3K8 ejbTWogx6/clF6g0fVrnpzKHRva1i4FrjVd0uSus8pX8tMVdmJYRRse1GJBGlve+a8ZLMHDK msT3eOGbGdUMzMMCpP5FElZslWh7RFtaAvpn57xq6i6AG2/t5d4glelml3MRKQy6JC+SO7b6 eRWnmB++Z0Q3wI8584ZBkhbh157uscY8s1vxXdKVmCwkaAR8zyeu53f4QIsM2NBj5lqS/gts 3WnxwMPXa7avaKYD9XZXxGHPQGqKz3t0n4m0r/xqhk7FUT9L1YR5VIGiwj7sN6lQbWU/JV+J 8ZjG+LCwEzYlpkm0XffO6jLc5CE/6EXm+TTmvoFcVeloEvximX+NwvWWbfYrsGKUxNmGRREV k23AFhThnGcViNgVIWgyMV8wTUrQItMSNrfoCLwN0WM+Y1PKGTQ9y1+6yP0JpwDPdx46yoke x0Jf07GDnC/TZcIZj6waot4qtqiQ7vJfLtOHVCxmq+UvmLUQa9cMxWLOaOWx8HURjydzO5OI 2cNfMCV1Mr+1ZxxVgHoOuyRP2WC8GmdG7pGCZryuukt1I5I7u9dZcreq7AzElKJX2m6Oh+hx HI182lr02KQwp4d93LFWErw8L9B036dJ4iWOfirSNiihu3yOmRRFpbJ70lWddbQNEHFAI92k sxKjePQ0l64ewhLkmpJ+HCoAFJIsMI+1VAzm6bZal4mtD+HF4txi+49At6Wg5Jschq21+hZr FHhmXuBuO3r3QoBqC//4AfvqyiQZjpyhNTDp8n4Hgwlqrf4qS3oLVwIOF1Y6K378vBye9q+D bP8TdNjO9Z5UbBbGPC1XhdI5oyTd0A+UOQxlAKE23mi42KwQaXbqBlQh3mePjWWgbwZBuvQd YoL6pOukRyFICJ0BUVAt887TLOGNa13SPhFaU+Gn47XXAzUbaKzWt3bLdb5TLj/CoOtKtu0U 1efD+4/6DF/aWhvoDDUa+dp0pJdtl11Yoy53bD/b0BvzBnSpj22wqp4RQKRvn3LLworo20Ch HmmuoBjMTDPtSGszoO1vF44izxt79qdo8C7OOd9qY1K2KWwea/sqGwYzmMorrLF6mCuRnSG6 RWcgWxQrAbK+ZUxBi4INAoaczSiwWSE2NFzHtrVvzpLO4cOEaJahjZsLG7IOzQBYugbiIKNg xAlBgRpLiAWuIku4Uv/aTTdQ9ituSDVqlNE1uNWMTXlKaPoH40Yyh0nYib7edcfMQMnB6+ue QutHQP1GEkLOJ4Cw6HB6fvXdzIQZuHbm+tqoqP3rxqW0geT9XD+d3t5Pl/p58HQ6fj+8fJz3 jC2Y3pJIsYAuZL1B7YE0wMwAdjb4vCNWz9fLCOXbHhc4xQDapfE5+6hQSqlslnWnV24fr0TX NH0ydUrqCehrFpc95vmh5253Su/Qilx0q0dov2ufQcPtPbzxMvptMMBfT/5NIHgsEmKbkQBY VQVnVlXIRewL4XueIeXrUjJy3GTbrU9U0C3XyoFwW6vVz/f6j0jFRn5/rf+uz1/i2vg1EP97 uD796N5jqcpzjHGS+iiuOYHv2XLJf1q73a3w9Vqfj/trPcjRDNkRyVQnMEBYVmkLNsHol0ct lutdTyNkutEbWTykFcl8kRuHYvFQoudkwgG7QW+AajfLVhFvFxaw+2Fb98Vgg7Io23amExBf RPwFS39yIUPq6Xs8hDgRLyLjhLuBQIuQVjiBOb3M5dZS8FdnBj6r5rk9Hgq1AiGgDAWrMVGq Jn18TyXVlPMGJTTxQ5SLRcTXgY4/y6gnsvyNao5/2XzkLU2eZrMkXFd0LNHCUlJQlc5zKGON eWFNQjQbmwEiEbTBoHwxWXoSvIZdaZGumQ9eQz/TEazxvu9Av0F08yqi1C7boNasY6vs79fO OlqIr9aX64fvTAM5y57b0d0mS9MhyJhgFaCyAw9zK4F0nuSYXo5rBi948a603fTy5lQ+JSLu TTfoTroi8e5TLZH0IYpW2Yq3U0jKWYk69hItEosH1FyXd/SFidzM+OqEMbLIGsKl73gBGwlI 4TEzJzEhqoajfOR7fAKTliD4hKAv7LpClo7jDl13aA1qkrmYbps8bpUImcPBsagl0OvMAb5T GnKWpRt2asaRkFCMgczVpeH92VUkVU+eGdUe5jIZdjsJYPatmMYGznZrf24RBNst4x5xw7LZ M1uszxZijXAaOwkclymE77f6RyPre6nWjmjAjn+wbRLO2aiRbxdoMlpUYbXubsPel3gaG7ne UDiToLPuiwf+xbBE3gLk9lU8iz2MRm5NW+UH0+7QV1GIwYb7qqqyKJi6nTXQjf5+2wnB3xaw zdBE4anw3Xnmu9Ntp1MaZb3qtJiMvEf/6/Vw/Ndv7u9SiCrvZgP99O3jiBE4GZeowW+tC9rv HTY1Q6MdJ/JKbDeZkPrAbAtT0lcIQ3JaoyfQR+jR9DNTYy2TCDUbqzOyo+nYLtDGoVahAF73 lx+DPUiV1ekMoixlyLfhq86Hlxciu5o+ON1V3DjnyDdSvQtFE63glFisKrunGhun4t4ajAaV V3Fvy4sEJFAQXDhTJCFkH5MTiojGQeWJQtBFN2nFKbGEjrp00S/VXlVyJuXQH96v6JdwGVzV +LfLdFlfvx9Q8tfq2eA3nKbr/gza2+/8LEkju8AgIf1fGsJ09R64DVURLk23dQuH71bspXgb pLWVOI/2r+patvGrZrhh+X3HdFUJ9+kMw1yatxKu+whCSYjRFWzbLOz5/b8+3nEo5ZvMy3td P/0wWwRpPbxfW29oWydKrnRbOMbUlp0Y1yqCVx7O1vOuk514XEbSoG0OlniQcN7aoWvqjodC 7PLVJmmDuph9Q2yfJqXRIsnmqLTRIIsKBxvNTjzcxDCiH3ebifW2c2eEt0SZ6fO1iIfD8cTp cDYNbwFpDjWKKE3xasygq9zRvRnVDLCeIQgXYSn9DQoZHbdVeXXQSIlsczBrcLmSUxK0Y6AQ SrqFU0uIvlAS+gNh1YLqxjuymiSc/mjgmwcDZi8MGxx9cA4/d1HKt4m4Ii436GuTll85SxJQ xBh5W1GQVnZhElEAHFzRSvh28+jvqL15eruxTCrW1IvFyzV9oIvAfD7yuKjcmzkgU1g2a2lF MVx1EEN/wYaQlOaOkHDeBCBReePObAP7ozhgaIruA1SEmh26ufaWsNNgpKok1jSo463KR83a SOMNfsmF6t7IWzlEkjIqHTN6JfYVwYclQrs9tyGutIfw0/l0OX2/DhY/3+vzH5vBy0d9uRLH 7SZj2S9IbwbiMnmcUVFYg3aJ4M3lIDzfpexTiltsELM2DdsVKZv1cYEREqLMEDPgB85otloB 1ze4kibEd7PAJAyDneJTViU3WCfJhYEyMgi1rICgp8MJF4DOIFIZWt4YjEgDEjvNQgUu2ydA uUTxo7jhkGdghGjM6VEGSRRHydgZsV1D3NQLenoQCRktKuJDWhiE4TbFv8B5Pu+KmQ2xi73l 4uSasLSuLsEmCthPbLLC8dWqNHyYPp6pXV11Qs0k/t7iAXSEpW2VVULM6+npXwNx+jiTxOat CQndfNE1FDZINRrO2NOcrcSoAySr2Yrj4IoXh2ZebwVqn1Ao3936WJ8PTwOJHBR7kGRR+B2I Lmf5FSltRwo35hVfA9aPGEIhqkW5Wt8ZR+pqvmtOhobl+FOHhUXRww0uO1nWb6dr/X4+PXGD XSb4XghjN7DDzBRWlb6/XV66VwhlkQvD2VP+3C2FDdFnjXHZQ+u7fRCG8NDv+JVofAJ94+Fw ro3AgQoB/f9N/Lxc67fB6jiIfhzef0fR9+nwHSYmpipk+PZ6egGwOEVkSJqsFQxaxVI6n/bP T6e3voIsXnnkb4sv83NdX572sC6+ns7p175KfkWqNLH/yrd9FXRwEplIl/JBdrjWCjv7OLyi 6nYbJM7wmVbJFsMGoIpSlStQVkp2mfzz2mX1Xz/2rzBOvQPJ4ttFgcb9ZkVsD6CO/d1XEYe9 KUr/aMnchFrMF7SZl8nXpmX9c3B3AsLjiY6cRsJZv2nC6K6WcZKHS85hzqQukhJf26ADWrtt CAF65Ak4+tuNb6JvCU6JXmWWBwYDsl9X+dPfw9xutR+vQp8wn5Bsq6h9xpT8fQX9s3n3wtSo yDHf+A4dSXsr3M1FCAIH8QnWmB5bscYa+SE7CN83U5G2cCs9okboA7cDrpaBa9oPNbysMIVj 2GlX5EFgmjQ1uPFv4xCwzvEu2KP55KXwzR1spiUHfmhnMOOcucF20YwjRR26D54s70iEPgOL Fyo6ly7F38swnEBFwdrAAhKF7iHBqn/ngi1DP6ZpVeCmuZF4Jol46ERk0uCGvKdrTYgfdWA8 PdWv9fn0Vl/JcRfGqXBHnhl4vwFNTdA288deB6BvI28z24D7wlnO8tCd8K+jAOWx710AQZLW qd/YRAdG7kZneQSLWz0Q4aF2HQaGZl0IPdNAEoe+FZ06D8vY4QKEKYwxkBJgXtfKqax0qz7I 16IHh69yP8OjPbvB33p2vxUxH6Xvfhv9icly2Fzoke/55J44HA9JwnMF0ONnXM8qcE8ac8Ba WWcBNBmydzOAmQaB2ySrM0sgvLeEwfvybQRrglzrAGjkBZzqJ6JQ3zQaGvE9qJhc5xAzC3XM qUbiovtL7bnjHsQwfBD3fHg5XPevaNGEY8TegXC83uUYKjerQnOLjZ2pWwZ0f41d1kaDiCnZ n2NvNKK/p67126I383jD7+GYlh85I6srANmlGKVJBvYHyYpz6yJ0HXYB5xWfLUeiJjtuphFl 7kf8bX3b2DwE4fdkMrbanbL5PxExJHxvPJ1uadHpkI3mD1xTqseh6RobRZhP1bWAeBtOQXG2 9CgkWW6SbFU0ERJXJN7LZOiTZbHYjl1upNJl6G23uuJWJJZ3tgjl7iWqyBua6bclYBJYgOnI BpABRtHF8bhhQozr0p2mYPwtMuK8IbvhAeOPzA0fbmnyjDwqQPLYUsCQpqVA0JQdPBkeCl1Z VEplOj15stx9c9UokuoKb+RNe8Z2Ga51hmrD3I2SGYhPfAkZInaDIubNbH8rektavEs/KSwJ NlYvWwwg+LTxIpaSbb6Ku9fcrUOhrMCZuFzzDZK+MmygQ+GwHgoK73qub3AjDXQmwjWzgzW0 E+EEXfDIFSNvZIGhAjewYeOpKQQr2MQfDjv9FpPRhHtEp6uWfgSkoiqLhsGQCAub+ch17AVi mJ8LfMAMQkIviTZWbTv45iT67NQxz6X5+XS8gt77bBxGKFKUCZyG2j+R1mmU0FaI91dQNa3j bOKbJ88ij4ZeQCprSyl96kf9Jh+riPp4OZG6qgw2R7HQcVoMviwRybdVizEEyWTEZgiPIjGh glsafkUBg6EtcjF2zBxeIop9pyOOKCgf8V3htLOwWQbjepWYVELcFayroCiEKX5tvk30GdQY Du0BU2EQD88aMIBZHESnt7fTkcSsZAnMmc+FHk+hRTtlmBJFU86o1JRBRaHLdQLpNIaKThWW DEub5XFEJrdwemJ0Eie17GEH7NW65cWuwDEjisJvf+TQ31TKCIYeWT0IGfZJL4DiclkBIph6 6CMhElI3Qi2AbwEc2tuRNyzpmCBwYglpCOkRyBE5HdEhB9g4sEROgHBMDxEjlxaleZAkpHeA xmOHP1UQxzrrgjRmPXEGZjNho7zGxQpjsJsilhgOPdI9kFvcEe+cBhINSTufjzyf/A63gWtL PMGEPdFAwhiOzTQ8CJh69qkInXUmHjqi8QcM4INgTJL2IGzsu13YyDX6qg4cNRZGNqRP9oiK HwUs4vnj7a0JpN3Z9Mok2IlD3AaIsivQmVLqf3/Ux6efA/HzeP1RXw7/hw5hcSy+FFnWmLfV 1Yi8lNhfT+cv8eFyPR/++kC/B3MLT9GR0eSMn5WTNRc/9pf6jwzI6udBdjq9D36Ddn8ffL/1 62L0y2xrDkI34QcAGLtm6/9p3W3qg0/HhDC1l5/n0+Xp9F7DYDenpbEd0HLjsKefwrn0YXcD 5GwX2gxEeeK2FN7UqgJgw4C33Ny5I2K5wd+21UXCCB+bb0PhgY5g0rUwWt6AW8plXqx9J+ic znQRVxjyc6UMJ5wCVd35nuNwO6c7EeoUrvev1x+GKNNAz9dBqd6UHA9XKuXMk+HQ4msSxCn6 aPt1XOLFryAkmQbbnoE0u6g6+PF2eD5cf7KrKvd8l03YtqhM5rNAEd1UtwDgOS5ZLYtKeCyX XFRrz6hLpGNluzF+e2QeOj1WXAt2/hW9Td/q/eXjXL/VILB+wAh0TJ7EpqhBI2ZzDMe8gqSx 7F6b5alL61KQHklRI609sBKTMUnToiG21e0G50/5+3xrntLpcrNLo3wI+9rhoXb9BMe3gSSw 3UZyuxEbvokgop2B4OS6TOSjWGz74Kyc2OA+qW+X+uQY/GS5mBXgXNOI6ya0vaVQDpYytwfL nf+Md8JnjQ1hvEaLibkkM99x6W9gRaZ9sIjF1KeWFAmbsjJNKMa+RxKqLNyxeaDhb1PgjXKg n7gUQJV5gPisHQ0QI3P74u9RYNR1V3hh4ZjKvILAFzqOednyFZR4Fz6eppNotAWRwWnkctIp JTGzXkmIawpkf4rQ9UyRqSxKJ6DCflaVAStpZhuYpmFkmOWBIQPz7pi4EMapBMtVCKey0Z1V UcG0GoNVQPfkSxjCIF3X9MbE32ayTlHd+765fmATrDep8AIGRLdTCyY7qYqEP3SHFsC8FGrG vIIRDkzLnARMLMDYLAqAYeCTR/WBO/EM/9NNtMyG5DGQgvjGB22SPBs5RHeWkLEJyUauucy/ wXB7nkMEObqFlZfe/uVYX5V5n93c95PpmLXMI8LoY3jvTKdkH6p7pzy8W7JA9pZKIuhTwPAO WAt93ecHnpknT/NCWZa/Smra+wxtXjRZE7/Io2Ay9HsR1jqzkORzGmSZ+5a1mGL6jC+UyBIN H8M8XITwRwS+wyov7HSrhdC+VrbsZvmaWGkIoRZOnl4PR2YN3U4jBi8Jmtcigz8Gl+v++Awa 27GmrS9K+TSEvxSWD+fLdVH13Bnjaw1M08KjxaOYCwN16zDfLX0KHkEGle9g9seXj1f4//10 OaAixm0fyeeHu2LFO77/k9qImvR+usJRfmivu03rgjfmbvViAXyBSOGo0w/ZWHASM3E7xJMx Kyuixs8fU4hxfXpnQRmhpCCSQFVktrzf89nskMBMmdJwlhdT1+F1HFpE6c/n+oKSkjGJzcDO Cmfk5HcmryrIxbn6bfMzCbM2aJwtgG3zcXLjAmQoTsJZFHT60qjAgWMfMReZa94DqN+0ZxrW 0SozYLOcNpSLYETNywrSw6E0kvJwgPnjDtuVYch4KCsIK4zV8SoYOnwWzEXhOSOui9+KEAQ+ w5avAbTRBti01xhD7IXSCsdHjJ/bXT/Cn/rkoqBLrJfg6e/DG6p+yA+eD8h6npgFKQW9wBSa MM9WKV0CdxvTmjfTsTAbeQsz+7bC4Dwej4emqCrKuUMzR22n1pI0UUFPPGCshuMJKNf4DnWZ 2mSBnzmd5LLGaH86JtqL9nJ6xTebv3RI8MSUKMeecC0ryC/qUodW/faOdjiWW0iG74QYVC43 nuWj5XU6oZe6aa7yrq+i1dqOm5Ftp87IZQ0lEmVdPuagc3C2Lokg9twKDj0q71OUxzMnNMa4 k2DEThI3IDctoCJx4OAncANO10ZMGpPwOAhK/r+yJ1tuI9f1/X6FK0/3ViWTSFYc51Tlgeqm pB71ll4k2y9diq04qomX8lInOV9/AbLZDZKgZs7DxCMAzZ0gCGIpOVc1xOgwJY2M3E9wmZcF 6/OB6KYoSJAb9YGsyNVM0aADpB18d5PJTvueqEUAP0/mT4eb270fBB5JG7i4zEgCUIQtxHp4 zFHfP+yebjgTzE2WID1cWy2GPHzoGW+aDb4lYcXgh5Zw6PgjUDSZTLtVGmFItoAv+EjXRFzA C8TH28gtelFj7OBwkf3uCBSowgiQPYIw5RmvzDS0qFl9Pbn+cXj04/QABh0TiJcUNIV6n6Jv ZSWQjsbH8QocyisxlraVbUG/XzdllEzpfW2IDlxEDU0rDKeVbIh59tgUjZlXUVbDYtPv0i4W Rdu0W25deJOMruL62FhdntSv356VufQ4Hr0XnR3JkQC7LIELT2yh51HWrYtcqJiV6stxLuCL PlQM7KCq0iaY4+QSNJbJzTAh0WFwyVqlOJFuChuFyyrJLs6zr31cSYLDvJwp1xlElheim57n mYqk6bZ3QGJv+SWLzVJWTXzYF1W/KMtVkcsui7MzS/mI2CKSaYHPuVUsa7cBylxFx/kMVk9o Ek6WQZo+XZDqh129Cok1nVhHnL1eBmo0Xdc5KEaJtGEjdGWRxdLhp+sFaeHSkn+nqEQgtiYJ mIK/jFdOt63cSIoztDs1AVB7E5Cbp4fDDTn087gq7DQ0PaibJzlwBNi3IXsTXRQZD8F5LeXA kQnbVT8HxmsD0TKpjoUVEqpPutxJ9PThOaf+uoJ/vNNgtT15edpdK1nST4hTN9z8ac7SkKTo BuLGJRrgy4YP9TMQwAI8UlNX0nDVA3TMdmDePvzemI8W5ZLqiNMGeXmJs2dsJEIoHXb0jhbU ZctqIHQMMFx8tCkZZG+sxH+ZRHLmXf0GbCai1UUxdZ8cbMJ5lcQBB3GFjxd8gssFK1upMEwg Yl6M2nwanM7zFcNodyJefvo8tQLX9+B6MmPle0S7OcwR5joncpokz5WozLqiJKd5nRTk1QR/ 4dnsBMmo0yTTJ/a4BQCkmWjUVJwdr1Ihwf/nMrLCXUSYci4QXztzMoqMCgZbMNOWAQcM9aC4 rS3k6fTIIBbWaGdcs+FPAJeoAF/UB2VqhSHtAd2FaBoriqdBYAhamLiIXzGGqpZRWzlhSSjR KR8LGTCzbmH74MysWq2WzmhVDsbJMP3nPLYuOfg7GH4Co7vOI9hZkspLCQwqRjC1VsQABmLW vWkgUFm1k3xRsGX6A06R7KAzdGQsxp4qFPPhhdcZhJgU4Rve2RpJvrZFw6dyufibtiK+sjYG Qooc2B8cW1HVcnIRknipbBAoauh4Axehhg2VCqf81EljPm8qbzTGgzFJ9RfcipjqwSJlKRBG 0zr6hT+vBnF8IxkqbiNRErXsuJZpJ+Mk/1NGgXSTpgqMK426MCdng0GnV5z33YglAhYBriIf fFXbgZNwXlkhKLThcWHaXTUwHRcUmDw7FUkq0dl+jRoregKB7IZW25cWReAk7OA6UV2WobGs MaeSxYUGkMuKRsS8TeAozdGzJReYL6CmVEPUHCMwuoBEA0zcrrGxQiM4a3fcuuRWg4F8NbDb iip3BkgjPC454hcZMApe/6Nx3LOAKjVqyMxi2rxFbXN+DbNAixZTQRNA1NaWoqsPSxLY3wWM eiouHbQ+RHfXP+wsZYta8X/2XO6pNXn8DgTt9/EmVkfzeDKbOaqLz3CRs87YP4s0kSR2/VWC 2bXIXSRemB1tauRr0S8XRf0eWOB7eYH/5g3fjoXiU0R/UcN31mBuXBL8bYIVREUsSwx0Pjv9 xOGTAsME1dCrN4fnh/Pzj5/fTd5whG2zOKdbuq/0zoYwxb6+fD8fSswbjx0rUHipKnS1Zefz 6Ahqrcjz/vXm4eQ7N7LqXHf0Yghau0bzNnqThYzqEYtKGbpDFBAnAHNIJg3NRaJQ0SpJ40qS fDxrWeV0Np07ZJOVdpsV4OjhrSm882zVLmWTztlDEC6Ziz5JPBGlhohDy2Qp8ibRPaNBUPDP OMNG1eBPAuHlSa0jl0E/G5lxjclTeodOa7PKrCU7Lpi0HlZ9B6ueL3Ak+XRq5cOwcZ+4pzCL 5PzjB7txBGMJrg6ON7tziP628ednH4KNPz/jGbxDxOu8HCLOCsohmYWG4Yy8RDqYsyONZ42J KMnn07Pg+H5mLXadz6eBFqOPZKAvn2Z2X+AAwAXYnQc+mEw/hicIkOEZUjHqglhTL2eyRfFT vrmndnMNeOY21SBCu8DgvYkwiNACNvjPfPsmgQZOZgG4s8TWRXLeVQystb/PRNTB+Sxyt/2I iCRGrQ50QBPkjWxpNosBUxWisVJAD5jLKklTO0mlwS2FTBNeSzqQVDKQXdVQJBEm4OJimAwU eZs0XP1qJBLB5xM3RCDtrhM75Deh6KWE4as2T3C5cwqXottaTzCWgkR7Zu2vX5/w0dcLd4kJ E+mJeYlB8L62mMDLuf33GadhppAMpOalfQ3RdwMZq0I4+2IJ14AV3E9kJfAKYX2NSCWxJ5FG 8g/h/U0QwyLWyyFaH2vW5WpEDMQSCEx5uWy2RbVmMKVoSGwqFYUOxLFY5tDRVsVcLC87kcLF SVgiiUdkyQteCQsoYi4CaR0WcL/DS05dtBUb5RCv4CqxGT5+x3Il05K+jrFo3bM375+/He7f vz7vnzBf77sf+5+P+6c3zJCnhYjLhLv4DSRoLccMIaZwBPnVfjMg5UbruNjmaHkdVIkvg4q0 JBO6LInPEF2Bdm1tjctwXhTcyjBy9biWBI2oW2df3qBv0M3Dv+/f/t7d7d7+fNjdPB7u3z7v vu+hnMPN28P9y/4Wt9Pbb4/f3+gdtt4/3e9/nvzYPd3slSXKuNO0enh/9/D0++Rwf0Az8sN/ draHUhQpaRBvfN1GVDqLu4no+/solcoC9JuOV4KJ0vCxNeczPxIKWHakGq4MpMAqQuVgZCNc /jSGslsSxjYCdktIePU1P0YGHR7iwXvUZXOD/gzWhVKPkM0vVKRfO7mahoHIHpXkqVZDL+j2 1qDyq0tUiSQ+A8YUFRtyR0fGWJiHgujp9+PLw8k15hR/eDrRO46sBEUMY7q04vZZ4KkPlyJm gT5pvY5UUu0gwv9kZcW8JUCftMqXHIwlHG4fXsODLRGhxq/L0qde0wcPUwLq+nxSOK/Fkim3 hwc/wCDpmOe600GaXarlYjI9z9rUQ+RtygP9mkr11wOrP8ykt80KzmIPrh51nSXZ9ZGujOHD 67efh+t3f+1/n1yrRXr7tHv88dtbm1UtvOJjf4HIyLIQGKAxJ/IM2CquBfNZnXF6NDMUbbWR 048fJ59NV8Tryw+0SL3evexvTuS96g8aAf/78PLjRDw/P1wfFCrevey8DkY0m6CZSZp4z9Ct QEQS0w9lkV4q1wx/By6TekKdSkx35NfEimU89H8lgGVuPPXcXDms4hn97Dd3zg10tOBeEgzS VmAMUE5wG5o2Zz5JXYWSjS4W82PoEpoervGC2VAgKG4r4W/rfDVMgjvWAmMpN60/fajw3xhD qBVmYwiMbyb8/bTigBd6KmzgRlMaG+v984tfQxWdTv3iFNiv5ILlx/NUrOWUmyONOTK1UE8z +RAnC3/Vs1WR9e7WlcWcjeWAZD9JYNErkyP+xma4ThZPWIc1s6VWYuK1FIDTj2cc+OOEORpX 4tQHZqf+9m1AnJkXSw+xLT8q/zB90quEpv56ErJmhgGgXcMZGwyzWGxVeG23ToNgQv+Y+RWZ hKsyZyY4UOCFz4n4T3D+rkLoGVNXLI8stEXgKOv5qD/2sip11gx3Tmb+Abct+ujjLHxMgaTn 5uHuEQ3PbSncdGGRWtpaw+uuCm8YzmdTjiteHdkF+mnQLUi9DPYLp9rd3zzcneSvd9/2TyZK AddSzCrSRWWV+ysxruZLE4CewbDsS2OEHcKd4uDYCPcLKbwi/0zwciHRZLO89Jko1GUMAqhw /PPw7WkHV4Gnh9eXwz3DktGbVkj/eFBetprdGdvMYzQsTq/Go59rEh41yCLHS6Aii4+OA30z nBdksORKfpkcIzlWfVBiGXtHxBp3bSFRgLOutnTtXCnocZ6tQnlzEp+qQGGPFgAMVxfBcfPO FMFjh29ZPubVzbHsQPtUfPKSuw2pI9W0yePUeOL/TZ8xPYI2JU+mEbdTBzxI4P+kGBzpDzNG pgcKuL5X1FDMQ3VRnmOKOZbETbRBUKgVusCIqxwyiuB8ZScF2pylxTKJuuUFG0WyvswyiWpB pVPEPCTWrd0gy3ae9jR1O7fJLj5++NxFsurVkbK3JqNDXa6j+hxtBzaIx1KCFmdI+slkqBmL srB4OcNSLA1ZskQVYSm1aQbaSxjtqP94j9EJvqvbzrPKtPZ8uL3X/iPXP/bXfx3ub0cWqp8H Bz1Zr8wlijsPX395Q1WCGi8vGrTmHIcppLIt8lhUl259PLUuGrgzZgarG57YWAT8g06bPs2T HNugjD0WX4YADKFTRqtxqHrHQLo5XK7h8KTKYjTdEhWQ5EvKttHfwRrYOWwYiZloyFozDgSL JI/hnwr6PE8cu8kqZh9PoDOZ7PI2m1vJbbR2nfo/qMdmNByJsvIiWi2VzrWSlrQfwZ6Do9oC Tc5sCv+OEHVJ03b2V6eOQKQYWp/FKsBMFQlsRzm/5OxgLYIZU7qotqH1pylgSPlyz9zieLkt osn8krl/XYvIFX+4nxGT9DwussA49DQgSA5maGPJCI2lD7/CIxgEJ1tOvdKig4GOx7CCL9KG PQ9ArB1rvqNQUjOBz5h2KpmWh/PtB2mXIVdgi360drxCBKvQN+Td8or6KxFEekVfJsyeY55t 4NiJu7pIC31VYKD40EU3hoWDKiluTrN+K7vojUg7vDuSw0ZUlbjUFuX0pKqLKIGdvJGdIhhR +AIQ0+6gy0ZRUsMO1SSNSGW+pC9YCoeITJTqYcg1SkGciOOqa7qzmWZFpB7oYCoqTOO3UlK9 8zG2bVFU6LMExG0+PAqS02WbFE06t4uNMssuHkGlrIC1KZR33MX777vXny/oSPpyuH19eH0+ udNvB7un/e4Ew6L9i1wZ8IkIpOUuwzSe9ZfJmYepUf2gsZQdUDS0B1+pg1nmrKIS/uXXJmLt PpFEpHD0Zzi65/aYCPTJCtp3mVkdTihOLF2metmTdalS8rhvhsu0sFRJ+PsY+4rSq64RZFqT 6iveMsgxlJUJhkYix+Z8EZMVhC5EFSpMm8pa7rAFzI7dxHXh7+OlbDCkRbGIBeOah9+obKhd Ti37irwZ0iDdUahLdP7r3IPQTa5AZ78mEwf06Re1sVCgEsSEtC+QvO7mGJq/qHLEBB6AgQQW VdLNfnFeyaYJH7xyJx9+BeJl9wOQY2dCRQJ6Mv01nXrFAiebnP065Q2e+tawwZbQL65wRRP1 0LgVNIGbAsWyLBoHplUGIBJh9oshS2QNjMpy6kDDgHw5LFg7WIAj9dnvt0ZYVtDHp8P9y1/a Vf5u/0xfdYkpI3D2tVphAVNHhY+Em1FokO9URlQQypYpSIfp8Cr2KUjxtUXj2dmwsfq7hVfC QBFf5iJLItcM2wKbp1AijGfzAi9JsqqAjntJ1h/CfxsMRl3rz/txDo7doH87/Ny/eznc9eL6 syK91vAn31JlUUEblIn2l/PJ5ymd6RLOS3QRzMjeXUl0T67h2IV1Q9mQbnOtfQLQaDITDT2n XYyqEh00Lmnv/nH7/4cmWOtXWbz/9np7i0/Yyf3zy9MrRpOz08IJvOHCbYhNDKp7QA1ZDETx 9m2n+zseDAaLb5WKIENfLP4QsUsKWBAMh307r0UOAnieNHiuWQOtcLQdmhhujSW3DSJS4ByT oVENGEVqgWkgcYrXcKaCvqmrZNH4X8XJJmTloAnavJKoFZun0ulhV8zRwUQd7C5qrpmdU5kE wSZY0Xj4O2Xxg6w0B3qkh1NsHSH9Oio23bwq1jKnC/cfLUV3PaAltZ20gxq1DGUQi3DkR/Ki wRDmVJJW8LJI6sJ1tNAVVUUsGu2BfGzZaeLthbsDKGRwzW/iNiNHg/7tc7u0nfelsO4tCo8C M+UxKJv0I5TJLJVi7RxtY2M3WVcum379OL0eccHd3uehRXMap35Vz1rU1EbSQeATpC309RtK Y31FscaiSRyeonkxrj24GVg3NqfiQIEaXLRNqs0NRrs/hUiU9xtnM6jQ+uCXub35CG7Ug7vd dSpSWSqkt7xcC6RxQffXDfh5Ujw8Pr89waDNr4+a169297e2KIDp2dHaqeC9sCw8+qu20sp0 nURKjIBxAvDoloBbHFU2gSzox5un7T/hhLp5xWOJ7tXRbopBu2sUG7aWsnS0cVqRhrYJIyf5 3+fHwz3aK0CD7l5f9r/28D/7l+s//vjj/0g8MfRWU2Uvlag2pCTt8Vs4plqVk9EIcYSL/Tc1 uj2Bm8kiFUtugtRqggMqIutMHf9oBdfmNVye4fqs1TlGi6iH/y/NTm92L3D/BD56jXpIIr3o qlGnSdQDitd0iuMBO8Kwe8YB0ZraQNn6qTBqOf4L4C4q207JPsOimk7Gou0PB/WACu0H/a8c ZrJocy0WHccu4XBf8TRG2Fw448sgu23SrPAu6PLaHp0pX3JlZlfFDgm6Dak+IyWcNLnHsBf4 GuneMLHjulhytqpu4EW9c9qsmxHhEiaaIFzGbiJClVtP0VuqYPgDS7vpYy55A+bRm8MsQOjv HneU0RpWXYK9ooMz+zeTGprPI1M5XhFN0WVV4OsGdy/SXH+odbQorb7WxWLRYwJXLimzsmFI TNnRCvaxt0y3qWiYGvue9CuL4xv9SqlzUdarwpIvHZRK36h25pYVg+fAXGBB9OOi5G9amoGL PC9QeRf3H8hAwBtDDhuCIzSVpmv1tKayQrKTqZZx7S6v0Ea0serlgQgD9WUOS2IocbSKxwef PnhocJD7DaWdup0NqXa79UAzauDHvXlUP2bqEKlSpeHgMStB9xf/tFWduNbMZsui/G0mQH/I 6Vn6tTWecQ6iEVXTlt1wAHp8xaZhqqB9d4pjKIYoGopbqFSD9E1L7yxU7gEKrmG2WSmZWmRZ XqtrgblAuMkl0rIKzpP0N1Bpew0of4+exhNDnvHZnDkM9SiZY9/nlaiV698G1/T0dcqjeqJm //yCggfKWREmRd7d7qkkuG5z9slp6CbezjyBG0RUXDS6vSWVny1qdbPT4rB6QxEV3qdqhwAV H1WLN0n7xqiRMIECbrT61vrhFwbMHiTRCnatOipg9nBl2FZE6TpuiHmslk5x69ZalWrLrVmS oyqmZLeIosDPuFVL31XsVSaaAnjS2Yyq9wyKWOEPij9a20pe4PWP2/qqMVpvqLXhtdNLQNaR 7cmjH+4B0RScNl+h+0fnOwvoKiz1Pb5NYq/F+oEoVDh69C9gn3iNqlBRGrpT6qFwXikVEPZ+ iD5dZ34n8OHJbXF//QqVg35InXKJGvXu+PoNpXGv6+qbRVJlIIhLpwG9j7gNbBVncim1D5Qy ZrAx6O0Bx747F0r8UNdtj5yBKvcWVG7Q8P4yc68tR7mH5+eiVdH/D6O/rJizxAEA --liOOAslEiF7prFVr-- From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============6973425252976832504==" MIME-Version: 1.0 From: kernel test robot To: kbuild-all@lists.01.org Subject: Re: [PATCH v2 4/4] kbuild: remove guarding from TRIM_UNUSED_KSYMS Date: Wed, 10 Mar 2021 20:55:39 +0800 Message-ID: <202103102058.1xwGQNz1-lkp@intel.com> In-Reply-To: <20210309151737.345722-5-masahiroy@kernel.org> List-Id: --===============6973425252976832504== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Hi Masahiro, I love your patch! Perhaps something to improve: [auto build test WARNING on powerpc/next] [also build test WARNING on linus/master v5.12-rc2 next-20210309] [cannot apply to kbuild/for-next asm-generic/master] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in https://git-scm.com/docs/git-format-patch] url: https://github.com/0day-ci/linux/commits/Masahiro-Yamada/kbuild-bui= ld-speed-improvement-of-CONFIG_TRIM_UNUSED_KSYMS/20210309-232117 base: https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git n= ext config: s390-randconfig-r012-20210308 (attached as .config) compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 820f50= 8b08d7c94b2dd7847e9710d2bc36d3dd45) reproduce (this is a W=3D1 build): wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/= make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # install s390 cross compiling tool for clang build # apt-get install binutils-s390x-linux-gnu # https://github.com/0day-ci/linux/commit/16dfb9e33ee3b9d411560c44c= 016edc6a3e27e47 git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Masahiro-Yamada/kbuild-build-speed= -improvement-of-CONFIG_TRIM_UNUSED_KSYMS/20210309-232117 git checkout 16dfb9e33ee3b9d411560c44c016edc6a3e27e47 # save the attached .config to linux build tree COMPILER_INSTALL_PATH=3D$HOME/0day COMPILER=3Dclang make.cross ARCH= =3Ds390 = If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All warnings (new ones prefixed by >>): In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:464:31: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __raw_readb(PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from mac= ro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:105:32: note: expanded from macro '__swab16' (__builtin_constant_p((__u16)(x)) ? \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from mac= ro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:106:21: note: expanded from macro '__swab16' ___constant_swab16(x) : \ ^ include/uapi/linux/swab.h:15:12: note: expanded from macro '___constant_= swab16' (((__u16)(x) & (__u16)0x00ffU) << 8) | \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from mac= ro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:106:21: note: expanded from macro '__swab16' ___constant_swab16(x) : \ ^ include/uapi/linux/swab.h:16:12: note: expanded from macro '___constant_= swab16' (((__u16)(x) & (__u16)0xff00U) >> 8))) ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from mac= ro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:107:12: note: expanded from macro '__swab16' __fswab16(x)) ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:118:32: note: expanded from macro '__swab32' (__builtin_constant_p((__u32)(x)) ? \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:19:12: note: expanded from macro '___constant_= swab32' (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:20:12: note: expanded from macro '___constant_= swab32' (((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:21:12: note: expanded from macro '___constant_= swab32' (((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \ ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:22:12: note: expanded from macro '___constant_= swab32' (((__u32)(x) & (__u32)0xff000000UL) >> 24))) ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:120:12: note: expanded from macro '__swab32' __fswab32(x)) ^ In file included from drivers/spi/spi-mux.c:10: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:501:33: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writeb(value, PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:511:59: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:521:59: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:609:20: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsb(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:617:20: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsw(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:625:20: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsl(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:634:21: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesb(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:643:21: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesw(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:652:21: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesl(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ 20 warnings generated. -- In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:464:31: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __raw_readb(PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from mac= ro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:105:32: note: expanded from macro '__swab16' (__builtin_constant_p((__u16)(x)) ? \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from mac= ro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:106:21: note: expanded from macro '__swab16' ___constant_swab16(x) : \ ^ include/uapi/linux/swab.h:15:12: note: expanded from macro '___constant_= swab16' (((__u16)(x) & (__u16)0x00ffU) << 8) | \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from mac= ro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:106:21: note: expanded from macro '__swab16' ___constant_swab16(x) : \ ^ include/uapi/linux/swab.h:16:12: note: expanded from macro '___constant_= swab16' (((__u16)(x) & (__u16)0xff00U) >> 8))) ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:477:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:36:59: note: expanded from mac= ro '__le16_to_cpu' #define __le16_to_cpu(x) __swab16((__force __u16)(__le16)(x)) ^ include/uapi/linux/swab.h:107:12: note: expanded from macro '__swab16' __fswab16(x)) ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:118:32: note: expanded from macro '__swab32' (__builtin_constant_p((__u32)(x)) ? \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:19:12: note: expanded from macro '___constant_= swab32' (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:20:12: note: expanded from macro '___constant_= swab32' (((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:21:12: note: expanded from macro '___constant_= swab32' (((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \ ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:119:21: note: expanded from macro '__swab32' ___constant_swab32(x) : \ ^ include/uapi/linux/swab.h:22:12: note: expanded from macro '___constant_= swab32' (((__u32)(x) & (__u32)0xff000000UL) >> 24))) ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:490:61: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] val =3D __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + a= ddr)); ~~~~~~~~~~ ^ include/uapi/linux/byteorder/big_endian.h:34:59: note: expanded from mac= ro '__le32_to_cpu' #define __le32_to_cpu(x) __swab32((__force __u32)(__le32)(x)) ^ include/uapi/linux/swab.h:120:12: note: expanded from macro '__swab32' __fswab32(x)) ^ In file included from drivers/spi/spi-sc18is602.c:11: In file included from include/linux/spi/spi.h:15: In file included from include/linux/scatterlist.h:9: In file included from arch/s390/include/asm/io.h:80: >> include/asm-generic/io.h:501:33: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writeb(value, PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:511:59: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:521:59: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] __raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:609:20: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsb(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:617:20: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsw(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:625:20: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] readsl(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:634:21: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesb(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:643:21: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesw(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ >> include/asm-generic/io.h:652:21: warning: performing pointer arithmetic = on a null pointer has undefined behavior [-Wnull-pointer-arithmetic] writesl(PCI_IOBASE + addr, buffer, count); ~~~~~~~~~~ ^ drivers/spi/spi-sc18is602.c:265:12: warning: cast to smaller integer typ= e 'enum chips' from 'const void *' [-Wvoid-pointer-to-enum-cast] hw->id =3D (enum chips)of_device_get_match_data(&client-= >dev); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~= ~~~ 21 warnings generated. .. --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============6973425252976832504== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICKXkR2AAAy5jb25maWcAjDzZcuM4ku/9FYruiI3Zh+qyZbuO3fADSIISWiTBIkDJ9gtCZauq teMrJLm7a75+MwEeAAhK1THjkjITVyKRJ6DffvltQt4OL0/rw/Z+/fj4Y/J987zZrQ+bh8m37ePm fycJnxRcTmjC5O9AnG2f3/55v7/4fDa5+v18+vvZu939dLLY7J43j5P45fnb9vsbNN++PP/y2y8x L1I2U3GslrQSjBdK0ht5/ev94/r5++SvzW4PdJPzi9/Pfj+b/Ov79vA/79/D36ftbveye//4+NeT et29/N/m/jD5ND37dnX26evZp4eP958vv04fHj5+uvy4+fzx/Oxh+vX+4sPDxcPD5dV//9qOOuuH vT6zpsKEijNSzK5/dED82tGeX5zBfy0uS7BBlCY9OYBa2unF1dm0g1sIe8A5EYqIXM245NagLkLx Wpa1DOJZkbGCWiheCFnVseSV6KGs+qJWvFr0kKhmWSJZTpUkUUaV4JU1gJxXlMDqipTDHyAR2BR2 7bfJTMvA42S/Oby99vvICiYVLZaKVLBaljN5fdGvnscka5f/668hsCK1zQE9PSVIJi36OVlStaBV QTM1u2NlT25jIsBMw6jsLidhzM3dWAs+hrgMI+oi5nlZUSEoysVvk4bGmvdku588vxyQhQO8nv0x AlyDjXexeh3DJvx4j5fH0PaCAgMnNCV1JrUAWHvVgudcyILk9PrXfz2/PG/gCHb9ixUJs0LciiUr 48BgKyLjufpS09oW+YoLoXKa8+pWESlJPLeZUAuasSjQmd41UkGHpAYNBqOCOGatnMORmezfvu5/ 7A+bp17OZ7SgFYv1iWLFHzSWKNM/Quh4bosoQhKeE1aEYGrOaIVzuR32lQuGlKOIQbeiJJWg4Taa nkb1LBWaSZvnh8nLN2+1fiOtJ5Y9gzx0DAd5QZe0kKLlntw+gQYPMVCyeKF4QcWcWwqn4Gp+B8or zzU3u80DYAlj8ISFxMG0YklGvZ6cLthsrkB89Soq4Upcs/zBdPvmIPk0LyX0W9CgtLYES57VhSTV bWCiDU0/y7ZRzKHNAGxESjMyLuv3cr3/9+QAU5ysYbr7w/qwn6zv71/eng/b5+89a5esgh7LWpFY 98tsQxZAqoJItrR4F4kEpsBjOOtIJscxanlh87gULMjXn5h9d4phakzwjNirr+J6IgIyBGxSgBvy 0wC7ecFXRW9AgmRgU4TTg+7TA4HZE7qPRtIDqAGoTrypYXsh4eD04m1hCkrBztFZHGVMSPtIumvv VMbCfLh+6lfZwvQOBWWULeZgzz3p76wwmttUiTlL5fX5RxuOm5KTGxs/7VnOCrkAG51Sv48Ls3vi /s/Nw9vjZjf5tlkf3nabvQY36wtg2661UhZ1WYJTIlRR50RFBByx2JHoxguCWZxPP1ngWcXrUthi ALYhngUZE2WLpkGAMwahRDx3TXlKWKUsXLBnOG2nSJr+S5aE9qXBVon2WfxGKYjrHa3C/ZZg8+SR PhO6ZDEN9Aot8XSHVC3YcLAroAAc24rbExpIW4zCpRW0ChMDAzxaYFm8KDlsLWpu8GXDqlezVnuO Y1sINisVsF7QDzGR7jb6OLWcBnqoaEYso4wCA+zT7k5lOf76O8mhQ8HrCpjbu0JV0nqrvXAkQ0ev RzVuqk19cxcWsmTUudOosGMHqDshQ85cxDnaJK1g7O2IFQerlLM7qlJeoUmGf3I4kDQkZB61gA+W cwJehLScCO2F1Sw5/+DTgOaOqTaGoJyJK6+jSt3rKQcflKHkOZ3jLvnOTDonheNIlFywm8ZpsA0N aj3/uypyZgcvlpaiWQocrWwrS8A5S2tn8BqCX+8rHAuPSwYc5+VNPLdHKLndl2CzgmR2UKrXYAO0 r2YDxBxUZP+VMCvqYVzVlaN4SbJksISGhRZzoJOIVBWz2b1AkttcDCGGEXi+Gi+k18pl2vYe2GJt HVYEdEMbZCD9H0z62kYj05CcL4CJlh0W9IsjXHlEkyQY7eh9QPFXrr/bJDnKze7by+5p/Xy/mdC/ Ns/g6hCwdjE6O+BgGo+uEZy+k6Dr9JM9du5dbjozHqUjsiKrI+Pz22mCvCTAOJ0S6DViRkKBEnZg d0ci2OlqRlv+ezg0TejMqApOFM/9AXr8nFQJOFZh4yjmdZpmwGwCA4EgcNDRvBqZnXZUIOqRjNgn 4VZImquESILJF5ayuPUuLe+dpywD8Q4ZMdQ62go5sZKbAelkP7d8vjsIFlRiJxtwghHKVpEwYvmA GDqBCWq9HWvyEMcu9AyGuDbwmq8oBDcBhLPXFrA7bUovyxGTlgxnFFWU2EpuBoy0zj+Gy/oYOmEX 4zhL8Beto+V6cjVwO6KOKhCkgK0mCV8pnqbgtlyf/XP+6cz6r2PIxecziz3a9PMcJpKC3e0WZE/a ZLYyOBegpK6cI5wBD0pMJrQHuNy93G/2+5fd5PDj1YQqltNqN831mu4+n52plBJZV/aCHIrPJynU +dnnEzTnpzo5//zBpuid3rZ9QLL7poEWND4PZ6DaVhdHsWGfo8VeHZnNmZJ14RgC/N5qmWC3mgD3 4hj281Es7kHo8Gvs+dlgOsi1I/2Ncq9pHGZegwzzrkGGWPfhMmLSV+vWKbHNXFHpyOD6w2UnRlyW Wa2Vk6Ol9dmScJwhrrsNTml+B2wLsxVQ06tR1MVZSB5Nd9bxnt9dn1tnf0FvaOxplaF1aRKWBY9C oQC4jLzJldtupIah7jnSpE1OD9uhGxf2sam2WKiBgub9mL7RCinfPL3sfvhpdqNPdX4PnC2wJjiA r2479MA+a7xp1CZMGxk4RVPBp6U/UkMlygzUcJknqpRoPSyHkIAbO78VOBkQVHF9+cEyvWDgjJkL BREYARqsZxPVrAa/4Xp69aEFr0hVqOQWQlQwX22TjtMOI01q9z0PZSa/JOD2PnXmI2Z4YtK60Cle MCB96kOnHbjjMsdzEePB6TsQMay5dlQyJUmORIH1LlPws+N4pfM6bVLWmaeeevL29Aqw19eX3cEq olVEzFVS56W9cIe2D85WrclbbneHt/Xj9j9eSQ6MtKSxDohZJWuSsTvtNgHjqbCTla1w9XFinof8 9bLMtA+G/r4lQS3YDT1aKHc4h8ZfzW9LiNzSUArBVGCWuWciAYIZbzcTb2PsIMiGq4rXbv60ww6C JwQScVvEwJEwVOG/ga7QKUSP7EZp3wWjXbcDlIrQBIsl7EoCgr+gJtXlUyx1plcPz/gw3kYS8Njc wNHdbWcidrYR2+rtqAEgKx7Wf5pCC0xQ/XmyZ9KFm8dvh83+YDlcZpxixQpMkmapRAG0TkjfxKlN rnf3f24Pm3tUp+8eNq9ADZHT5OUVB9v758aNzrWp8WCtawwbX906Fsc4tEEO/AHHUUG8Q0MxrN4F mkJEwjBoqyFih7Adk1kx5tg9PQvBrK6IgkSqCMtm/nb6frWBVlSGEQaq4EinbWbFxrc6T9Gq4lWo zKXJnJxHX0zTPc45X3hICIcwtSTZrOZ1IO4AX0WXcpris8cCVLkpBBEsvW0zbEMCCB8ak+UhMVsg OhOBmXplquQe3cUUrBSwW0JsnCpgN0985mDRPedJU7b2WVvRmVAEpVWbKrOboNR8TjUpBxukEwLY PgTXyVPTZ6PmB3zv5e041s64tGY6r9WMyDmMYWImDNGDaCxZnCABvWI+DTbIyIypGAyyWGaqzSkw m6Njf4+iaWfuDozgEl4PvSKdMGJlrExxtL2NECBqciM/RcuzxKIPMV7QGAmOoFQKJ9vJUPpNMsl1 /dHr5Gi9b4zCK5f2Zwf4CZwHYkwX/kQ/cG5Hjn+BHiiqtXk9o4E9NIvnqVQJ9HvrYeFwtX4sjTFn Y0kZT+oMFBfqQ8yroiR7rdF20xs4xKC+8LPnQWoaHBpxQMJXhU/ScUSPoIMMJ4HdnPOMGd+3S9NY vmCG6Z8IEOCZJsK6jILiIthM1LC2IrkYIIinZxvROo41Siuwa3oly5yUllPc2voOOpZg1TIhQTHL Nq6qVlaK+gjKb252LdjcQXWTwxjCzmaGHL5uEBMGxdVt6StzxC4TwXUCcCwlpfOiWtHoHGPrG89i vnz3db3fPEz+bRKxr7uXb9tHp96ORA0HAkNrrEkv6gSmZfGGmD65eGRgZ3PxChsGbqwIJidPuEBt V5ivw6qC7SPotLzIcWJn3snzjyKa5BjLv8SprDXIukBEKOETsp9Dw+r3J6q4uy02Ena3lCyUz22Q 7XWmwAgtanBNa4TMvW7VYFGQVipnQpg7Fk3hVLFci1ww0cxy4BaotUQt3GKJDVWrOZM6dW5VF1ud qO8vZOB21ZbhiNxwHIuXIhYM1NcXN5Zry5qRmAWBGYuGcAxaZhWTwfJog1LSTaG1BJghD1YgsSCf Jzq5oq1v5bdeRaG6n+kXz3IqvAVjnrgkmd+PuTnZ6g4QKrtXkxNe7w5bPC8T+eN141ZvsNagfWSS LLEOGhRzkXDRk/bToilzwH1WyBvR2cdBdg9XkX/BTMUAhgZbh44m4cH72xbOMoCScZPuS8DnRoaE 1tFTLW4j2JEux9GCo/SLk7hwxuvzCu1NKvDimVtVJZ6OFsW5p1Kb7RIl3ketbl3BHqNQ0fwI0Yk+ fq4D95rdKIkgg+yZTYaq8uhkDMHx6TQ0xyfUEzU3K8K0+v7vUT5rip9Aj865pxidsUMyzkJNdoyF FsHx6ZxioUd0lIUr0H/0OA8Nyc/gR6dtkYzO2qUZ56OhO8ZIm+LElE6x0qca8PLoiT912E+cnVPH 5idPzNHDckw4T8jlKZH8SWk8LohHN/3Ufp/c6p/dZdcdJ5JjhqbKV5arqa+96K0wEZsdK1crAQHA CFIPOoLroxRz0QRmSspSU2gLSf/Z3L8d1l8fN/qxy0Tfwjg41jNiRZpLjBPHApSeAoMtu4beYERc sdLJoTcIcB9DN54xL+nn+cdmapeR8vXz+vvmKZgF7epFVnjWV5husPRDQ6gl/MEw0i9CDSj8AJ/m xp/BypAa4lMipJrZbmxThrKvB7uYQRHLhTdTGkW394i495hmvPzVlLyk8cuwqnrZbxF4aV6kri+x VBRl3EnS5GxWET+oxxSpaqPRtgNkFUmSSsmu5tuLDATJwZt4mJVrvS27wUKE6jQtF/Sm5qzQ411f nn3uCm0juZ2+UB3Aw0pW5DYc9QSoc3O5zO41zih42AQczdCBcC7Z5MR63GABYRAirrurzXcl51nv xd5FdWJXOO4uUp6FHPo7HRXrfemJG5g+4MGYFPhKq8rNaur7ooERdAJcE2BOaWGExb4zhkk4HCnE UDgzSjphnTYQINUQhs1LfRkz9WsLqAJLSU22jTi5iHHd0U+poHIQNyWbv7b3m0my2/5l4g37dDvR iv+lecrihOYA1gcnqoN3hwFLRJn7LRB29OZIR1TyFcQiMLWfIENDNSQekPbXY53VweJl7q43F2wA CL7paXF6z1KQOEwvChdfmRxWW5Z3X9QhgZB15Fa4sTY5ABLpdUxj4s2b8aXHcbwJO8ZBkGjBgtcp GwVs5KC/J9KDQbnG7HhLJeZlPNYcK4jDwB66vH95PuxeHvH9wYMvqNgwlfD33L6TglB8zta+43ga INpnIk/Opt/g/cIbX0BBw8YVx8q0bhs4RPvt9+fVerfR041f4IPwC/+6o2TlSVmy0l0OobQcwsqM BCgROtKJRnk9gaUUmiP95YMj0zeOyctX4Pr2EdEbf3m9ChqnMp7Y+mGDV2M1ut/S/fCOhJ5+TBI6 PJUNNLTeFjXgXIsIsM9GHeszyMg/Pk7PaQA07KiBU8cXPM2PLtUUPgPd+aDPD68v22eXg3h9VV+0 9PRDA22eDqS+/oZJptoyjSoIJChk5OKtmXaz6ea3/3t7uP/z5DEWK/gfk/Fc0tiWz+NdWM7HTabG LE9MqsRdaQ4mNOSkAKG5CtRM/939evcw+brbPny375fegitkuTP6q+JTHwIqhs99oGQ+BJRRe6HS peRiziL3hQkpWcL4QAnpasL2vjHlE96FDv09e1OnmdOspKHb2Qldyry0vY4WonL37SN4NUVCMqfM WVam+5RBRAhOnHkX3vIx3e6e/kYN8/gCYr/r+ZiudEnCDvc6kPauEnyt1iMxyCHdIFZyvW+lC/Bm lTbjggSdfQ6Ke9+kLSMEpd5fXDul5uHD0g4FW39OFx7CuDAUz2RzTSip2BK5g1dDegPWPfHF2i/4 Ewb9I4Re1hl8IRFYO8nsUlFFZ06QZ74rNo0HMJGxHA/Kkw+3L1B0sJwNCPPcvjDVjmTnJVrYRRwa RZFlbrk6eGdFzEllBCZ19x6Rqdbkuv4b3MWRA6TFN3rbTx60q+zm5PmNpKHYIJ8z5TCnAfhvO1ow qr/eI+mmZA/b7WNh3znCbwrEGcMBKyzS4ByffGpUULhNU1alASKbpI5u+hHaeUvr0g980dKJy/WK Ma/r3d6vY0i8M/BRF1VCuhrxVlXJ9m8RxdMO6nQJ+65fxA26DRRs2lnpadXwEXwXLICY9zpyt37e P+rLbpNs/cMxUzhSlC3ghHrTMtW7J3dOJnVS8cAqU2lxsxh8U9XKXiBDWOgBYpronuzblyJNwg+L Ra7CvWi28tJbUVf0ggOVEyH7dFtF8vcVz9+nj+s9mOQ/t69De653MWU+R/6gCY21YhqZBxwCX681 XWH1Tj9W9AvODbrgoz9S0ZJEYJRuMX72CD2yzCILjTSjPKcy+OMBSILqKSLFQq1YIufq3GWrh50e xV66WBycnQdgU3+aEFUdWSBWfDP8BZ8hj/NEyMTfNcSAyQ+5Sy26lsxVD+Cn5O5MK/cFgNYDkQCX IXhajwiZiUnWr6/b5+8tEDOphmp9j5f1PUkE6w0LRvaWrJj5ko633mGrvVU34KaUOypYLRlPT5LM SsZ1pm6cMhhAI0bvmVrinb3Kmz7EJobZfSh2gjndHd536FCvt8+bhwl01dia8Gku8/jq6tzdYwPD 12opu/FmZVC+vQMMlo/TjIi5z/AO0VQi9DvAsVPWE4Os+3KVx/NyerGYXn0YaS2EnF5lfjORAR9H WpTzgUDD/30YfAefXZLMvKS2E7INFtwuvLKD2PPpp4EJmRrLatIK2/2/3/HndzHu3CBR57KOx7OL 4Dk6vcu6rwIcene/EdLerXZ1S0ERN8Kniqx0085YrP9+D/Z2DTHbox5l8s2c6D7gDYwLUTfJmMtu C+EmI31kIgO4mKQ0AM5vWOwvUCPwrI4eU02B5w5zh8epmgzCCLc0CanwaaV7sjTCnPlslreOVb7d 37vcAqPup7i65vhHsDywahOVPgWmmzCx4AWmukaXha63LwCmDBfHIHXfQc6GKZ1uACAK8hvgmACY EwgLgi98fcqo+emotrIWGLzFaeHWU8xK1L7/Zf6dQnSfT55M5jyo8zSZy9kv+ofWWhelG+J0x7/4 LPT1eAPUN2Yv0XNvfxhuyH38pYZViZs1fLR2nBarq0tdmsvGZNJutaB20guxdcRchgBArTL9EkDM OUT8ntLTBBGNml+am565c0QsVhHzI74b0syymkZjxlEP4T1nA/D8FiJ8JwxLpBXI8tT+rOqCSbck A0AwMVI61+cBSEmV3YZRCx794QCahwwODF0A5+UIwJzAl+N9aYi5luh728Veg+DZ0h2Vg6l0fvoE nHf9DP3JAyhy8+nTx88fhggwRpeD9liRVG7CvrkUODj8xTKnw6Q3Qv2f1GhuFSKqh2pC/Qsg4GvN PXhKItBY1jYaaOwBJKlmVNpqzQJjXUOAkNahH8yxyDKIhMa6SOOgiXWW3ulpK1/QBmD/z9mVNbmN 6+q/0o8zVSd3tFiW/UgttpXW1qJsq/Oi6kn63KSms1TSc07m31+CpCSChDxT9yGL8UEkuIMgCOY1 FyNaDAQelhcvyBb5WRYF0TBmrRlozSBKCwzFLc0thrjZuaoeoTNRVtATq/vG6E19cahU6xgpSGI8 DD515JnyfRjwjeebX4j1rWz4ucvBTADRishbf+1YlIa9h7UZ3++8gJlBSQpeBnvPC21K4Bl3NXUt 9gKJIjPMgAaSkx/HyJF1QmSee2+gLzxX6TaM6PvgGfe3OxqCSaCAU4e0DbVNnd5906olMsnr2Wf+ Rp1GjTw75JSDCfidjF3PDc27vbSsNk+1TgUvxF/3+aNYVxIz8TSAEe4u4rlY2yp3AVf0kfXBxkxl IUdksTVe5keWUqq8xis2bHdxhHqVQvZhOlBa/AwPw8YIIqTJYvc87vanNheV89nC8tz3vA3SHXCZ J/40iX1vGh+IZkdoWYijmGXO1WylUAEWn38+/bgrvvx4/f7nZxkW5sfHp+9CGX8FSxNkefcCessH MWt8+gb/NY/V/h9fUxOOnigoBM8tcL+JwXa/NTb0x7y+PmBjsvg9q8D69mGXp7ASPS53EfL0hC7j J2k1Xqh7LLIvszKFiFVIt5/6+BrZ6tUnlrCajYw+34aIabTxF83Yanuc8mLaKjmjQXrmV41hBO1Y kUFEUxTNJzVdBuQ3VoQ4SYNQgNZV6UUCnbUKPfCLaOQ//nX3+vTt+V93afZG9NpfF6GmlZUbYqWn TtEMXWCmHQm+FO0LpHwpxClmTvAjk6VsjkdLbccMPGW1Or2gi9lPnfmHVcnS0C+r9TOmQ1Blt7ol vSwS8Q/5gVv7QJceAbwio9JJnq6dhVh21pbcTpVcZTibtTSzk901TmOXsdSpfkEXiye/ric05lXq lEuQWXlmZG+n+vY8AYg6WmoOrvdbx9lMnmBW2I6m4zYlDVz3g8kAQ/LukVFeoLXydEtZMozT7/9+ ev0oJP7yhh8Od1+eXsXu6e4TBND699P7Z6NzQBLslBaWsFWTwFWtUroBlUVqTEbzJ/O8ZUx7QE7z CzOrXxIfmq6gtCmZWiEWW38bDJYQDE6RJ+mWZgGIF2WwIZKT2OEw1QgU/r1dK+///PH69fNdBlGl jRpZDrUzMYdmZMxpmfcD+PNaovJhY9QCRH6o1BylxBAUWhbJZmYum7QohrXMq4tTF/VljRnWY3At tGQtSqI+KW1TQZerlcC5tLvLpbB7+6XoIX72fJb1tzVgjgtmZqAoVWZTul5uMRCtFzWH9h2a3O62 MVWlEk6rbLsZrKTSR3VjDlPzA+uc5E9tH24p5WpGYzt1IA5BTVFDMv0hHOkeKTmKfhf4oZWaJA5O am+lF1ZNrjGSoWJiw0yGIZRwnfepgJ1066J+y0Jau1cMfBdvyJBOEm7KDPq9ky6cVVlFxwxiuAZe sN68MJzBoIJrp2NZwR/t9u2y1KKgADeKAgaFDt4WsL8WA2u78xyizTZ5o9gl7bviUOar5VBjDH9y LeqkIWyIbdG8+frl5S97yFnjTPZ8T+qEWMRKN4XbfnbxoHkcsbp3EMpq1bfm308vL78/vf/j7re7 l+f/fXpvmg3RRKjP8tdqRG2HDDuaobFNWlyFj+GyEU7EGeW3U2VS+/TM9CTFdyku0ybaWhnNZhg6 L+mnawifSH9vMw1FURsisvtrBm024C4n5lNeL11+LHhv++BP1ZVVU9gVCjPdROzdm/xSBe8x/EX0 dk4d4VdiT3HMO3lJhbZOQyIF2IULbkqXSQ9jMZJ6cI3CFyczuEcMl+vbPENUdUH+s0HhNWtxEH5B 7E+FPCu/FHDNGt1VgERko+AiqdrkFaXOCFieuk2NuZDzhFvpiA0inUKKXcIEpSqkMmimB50Omayq 8V1OOknA97NJEH8x08cH2rsF8ax4MyKeE6cceRBL0TBUkkzGm8aCZef1zOyLBCamnPNoCQ4lu8/t jOB0tKdMKtBfpBul1WoQ+F02MaUwSemcK+La7umYCMUuvpAjgywNwBAvYeUADeBW7kBIe1rTtOCP p/Omd5RJS8AaPJy5FTdWUWAnucoOu8Cl2JoGEfH4EZ3TagRF6dI0vQWeNOciz/M7P9xv7n45fPr+ fBV/fnXtCIeiy6+FaR6fKGOD9jYzWZQdeXvMQN1wK/7jdMP7liRT+vUFOWeIn2Mrpk9nJSy+fPvz ddUsUtTq7SPDcUkQxHJHRs1X4OEARxylFeRBYeou2H1FuusoloqJGXS4V16Ls0PXCwRpnPdIaHnW nzUQqyGnNiCK4W3zKGDj+ryk5hdFtFLLL9b6ZdTV2g0b9aUY10lj+SZPNLGXoz25DIY2ina7f8JE xU1dWPr7xNAzZ/pD73umiR0BMQ0E/tYjSwMuffcQRmi7o23FM2d5L8S5JS8czpN5SA8bCJVHBnmY 2fqUbTf+liixQHYbf0cgqqORuZbVLgzCWxkCRxiSqQ5xGO3JZKuUGjUL3HZ+gA5iZqjOrz3eKdkc TZvXMK1zog05q/i5PhLSHsV25FDw0xRR3eXgfXNlV/ZIFkikajWsy1M88G1An9AswovRTtlQjFYM RY8fiLL1VSC2Mef0pBZUGx7kQHA/S1nr+8NAVnaSUgc7xjRjmK3hp1j8AkMLn0gjK5EL5kxPHjOK LNabQvzbthQoFGYm9jcpmeAMClUwOZMskxGBgORlR+tiyYIKjUioEWa0cRdbzxa8AfPS8shZcpbt Rt7FXJgOEGxuTQIyY8e3WVIhuGkuc7QR0d7RPt6gTZME0kfW0tt9hUP54bBlVf4LH4aBMbf0tjMS ln9uTnWQY327wGdOvRgwL3ccnvtaKmeijGLvI/raUgsLEKJla6FnVBENuCBySZukY0Qmx0NwT+Yi VFVKK0C4mCOpJMU+scyrpicwGdyVpRTEiyyH6KbmVZUZ7KssJciFZfi2AHl69ZkonIaDkHp2Zua6 wgMeTUemUIkNayk6HNkflzJBtKumS/4BV0K/8LEwwXV5um6uRSZ+kGK+O+X16UxtJ2eWLNlTjciq PNX3GJ0Mz13SHDt2oExSSz/kkef7hLyg+k1xG2xsaMkoaTPecuDQl2Dczxd4PND+wgvr0NHa38xx 4AXbrg9pGfsTaeOKAp1uFA2aMnopNrmKts9XNnkL14nVV0a/yrEw3Sfix4owbX5knLy4p5nUFC36 e9pUG1f9ltM0T7s8p3QevRIXHC0risqy2N9QvUTDfZWXsPirhcD5PKmYvxI/X28MwsEbk3NPa2PT DmaI423kjU2NlBIT3YeilmEWdwtfVUJjvSmEVIqTPKdv/Rk8mRhRaHozsEsB87OFpK2om7G9dqqI rnCsh6vuYqrNqYls3gKJCabWfHYW90P/du/WvLziL1RyyolRcTzmDDYcjsiV7+1dQbv8eC7h1Rpd zzeqs8v781LmG4x9y7dR4O9oZsR6VjtnR6yWlRUEffjbBNr0EHnbMBzb6mx3IYHtonjjkK+V7hVE 9QpMtvhqht39zotAMKLPyg7TNfDAJjiH6T5lZZGxONh5urpp14KJce9FgRodq+JIpkgPob9cbBvS w+sqNmb+MJo222lmGMpwM6yQbVULg5alyeIqKrjvR/khavyBB9s9syVNKxaidzcQGTvx6HJ3l2Dr DVMVO9UC8Da6DcdrcCej894c/LxvqyL1V1uuq4qNY1uURFpJlhByY1KUKrEoB9ODcKLIRaSxOINM u0LZ/KZioCmBTQmRnUPTqH2phpjLHiFLiLQanZ6+f5CXieFJCdsjRhbhL/QT/sa+vorcsg4ZdTQ1 hU2jnURZJAS1Y1ebpL3DCGZBAkM5Op9Xn3QpgLQhV3G0yW0GZdXh1BJytqoE1ELrAS5NGWseRYZh Z6aXG4KYV2ffu/fNFpuxQ7XzfCyuNrVSbTebYSnLqTJMfnz6/vT+FWIa2C7DvWmNv6DXg0SvLXMV mElF2uIm58Sw0E5Xlyb4FjKEM8vQMdK5Loa9WL76RyNtdXa5StTPJBtPvpSZ9O07942OPaxvn33/ 9PTiXrvQqp50sU+X14Xrr1/e7OCtoh/qO+kT57rlqY+FzhSicDCIPjj0M+v6suhzPFgMAF6XOctb x77FgX3bDaJR2ag3C/gtGdJLg7w4WC8sImBK9kYCaVoPLZWABP5JAv624PEwWK6vNryO4HgBDmpt jjSepNU2HEj3IcWg5563PYNXhXonAwt3e/ttvjF5hCsChGT6A2Bel077ardc8jl1I2ZBV5AuXRdS YKLTyUiLTqfr2sD5QNCWXhoGTiEOvBzL9nYZJE9Rgy8HWcMWfqOLi1/5IKNfFMciFQOffA1Sj8q8 hrfWIrfHtF2GHC7xlGFx18pLNWPmU78dvHbf4+UxfUxLlpmW7/TxHRh+zPtYzcDU9bvS1BkkmVdM B2xeSv1Yp/J040gfWBacOnqsx1NWok3pbF/vyZPdunnXVGjs1OeyXGFW71HC20jmjk6/Uok2RqfL FFLEaQIZUvzMkZ9MJ21ktFtTSx+pqRDXbmcvhII4qsd8zUjVQJURlzLLYVchcMNhXDsulyzq0Wxl zDvAew84bV7YBDG5Iv0ViFd4czJraA8WJQlsQpsVQ47gSBxBCIHFAuw+jzcT1YPA8gGzW9+OCduE hsq6AHN0cQfBj3Qu9DTtuxo9Wr9gQ9GeaO8PsJeLkW562uQXdHdN/L5HBLgqbPc7OHOXdIiwYSgR 4jdW60SvOaqH52QNYfcE8aetHM2a/wYB5t5b2hblwtXXYRBTjx8C4EfIjCUp1Kq6zA5p2dqDFIOX Pgi8lXF8qmB0YudZ+KY5kO//witcPWtn/1VVaLgxcPdx0k5dvWn6ahTbV3NhX+jR3jNFuFTpyn3N ppZOJuSED8ldqjNqLbFwlo9W2K4lRpqjGi+dRw2P7sx7/SgmhUBMmDm+lDqVF3tL13HBVFjEj1Ee 7cFVX0yew/ovwxyo8nVk0pdAoNV5mPKu/nx5/fTt5fmnKBDIIW/2U8KI9T9R2x6Rdlnmtfkwj050 OgV3qCpDi1z26Sb0trboALUp20cbn57FEM/P2zxFLaYO6pBg4uhyNK8AOctXPnWSr8ohbcuM7Cc3 K9aUQkf9wvE2AeA4mJVsg/LYoCdbJ6KoDLM3zbs+CNe0tKaOH3cnUhb0j19/vNIR8FBBWVn4UUj5 Gs/oNrTFFMQhtFuWVVlMxr/Q4M73fZxQscP3OiXNegITgeBrSz+DC2gtz7BIuy+glyIrmOitZywE L8Q2fR85xG3oWQ1W8P12wHzgafyXRWi7ZpoL5dCXL3Te/Q6RtXR0lF8+i7Z5+evu+fPvzx8+PH+4 +01zvRGbTgib8isemylE7JKDD2UuVMriWMvQd3jjZIFiu36xRrOBGldTrHGysKQr5kXBllf5hTal ALpyjgxQo7xBkNCiny/yIIG7+3CwOxwvqj5fMZwLWG2QnEU5/ylm9y9CrRc8v6mh8vTh6dsrFSRS 1kPRwDH6GZk7gV7WgS2RvsW+KlLXJE1/OL97NzZCAVypmJ41XGibToP0Rf24dqQuex7EHpCuXbr3 Na8f1eyki2l0QfO+5+qMgjo/CgQsKW6vkiR969VpLInBhePzmlOq6nXgBA1dY6WY+tKrmBTtHi29 p8/owStz6Z2ZQ2PlTbOaA2UKOLY4215NsrnzEnuXBaE1kqItJM+JDK6E4hXCweyciUmTeqtSqNri rnr6AR10ubbmuvfJe4vScIBTYoO60yiWdIhf/9nExGKTMBxGXJLPPWwfSko7BNyJlAvEZb6w6Fd9 BxXT0E0KTdMBGpEsMMxWxADjEpgGnArFUyVQyir2xrJsMVWZFxL8MRCdFBs1/Gzh2oEFA+07BjAY A+zINgbMU38n1hkvwHnNBjmzOwxmRA+gDBCFx5bHnfIM8N1j/VC14/EBX8xuZRA21NkM3cbV3EGa 8zBr+4K//f719ev7ry+6l1p9UvwBF1Yk/OJznZv3hAHqy3wbDB4mWnPNTFIPG37GlaAQ/igGVSVf TLCeITY7lx0rRccNXTaiK07jbevenm779u79y9f3f9gqWf5Fvr/Rnh5FZ5Ovudd5D7eiIE6bLALv WQVx4u5ev4r0nu/ExC0WpQ8yeKRYqWSqP/7HnLTdzKYiaM3WOI/QcVg1MB67Br0LLehIgTf4QQte Hjk3v4D/0VkgYMpTbN6CkHs7fGrooKhn2qiLwBt6ZU7QBz8yre4zva8O+NqcBtSpN9FJJgZ5+Ex9 2aR52ayErp7kn2O5c1sdUgHLnr88/3j6cfft05f3r99fqCV6jcXNrBQ51exIXtuaBYLdKXOrJ+Wb uPSjFSBcA/bG/AUFRDOqJsiIS/JKiwrKFPnBxNEcrH3l9InzNrvanqLJZCaNF9+iTtFtMVW6P3vL /liFzPr89O2bUMNl8zhKoPwu3gyDWp/MoLftfEJJ9gAl3Wo8NuUCc2WtVV/joYd/PN+ji0SoyAru bDd1ST6VV9rvSqLg1ZteqNNvVV/JbsvNS7mKmtfv/CB2suKsYlEWiP7RJOf1PNUKdwtv6EVVoY88 XXGDkfg1zfYh6WMl4fnFBdSIcM1QR6LAD5xQXWPe20nq889vYk53u4y+K2HnpKg4/JZGaruzH+FF hcyufNmFPYoa2A0lrSihXVpN1TLg2pMYaYrUMLj22An2bZEGO98z64+oHzXkDtntekuy2IuCnVUS QfV3gV2bSSaE9avrxRmWyolnvZco/50bOK13Suwtq9+NvRlCWQ2lNtxvQoe4i6Nt5MinJuHVYadd 9JzP3JUK4/oiwg0G7SO2lrPE9/hdVgU8VMOOMu+oQSfdmpyPBHm/tyw20/hy+8H8fsPt/tHvBref ix2X2KmP/tatMnhXQ4JkHAzlO5alYaDlNx6BoOQDjfemfGKp8LcbpyqkL8DeX52X1LC2V7EqDcPd zl4I2oI3vHNKOnTM33grYVldsdXlNZ7cLg6yK8zJEZ/J5C6fvr/+KVTWG0spOx67/Mj6xi1AJTZM 55aUn0x4SvfqTwu6/+a/n7QZY9mNzJlcfb3ZlperGqotFpaMBxt8BoGxlfhsJpN/pYO1LjwrBrKF gR8Ls96J8pnl5i9P/zHdeUQ6eqN0ys3oMzOdg6HBJUP5sMKLIWr6QBxmjA386XYFCJBB2YSE6v13 2Zm2Wgz4q4UIqQt0mGO39nHkrfSdmSM2w1tgYFWkXe5RMxRm8WOiP+h2n/Vz+R4ZRPRER0cGeT3c sM0E/+3ZilHTZC77NNhH1KJpcs1+z8ZuAsEyszWpb+h+Ltvt43LN0+XyFYeqyWiFFGJtVmtcKGt4 p7R8dCVX9NWQE5NSz7J0TBgY3gyfYe0tDLYS881LTZbpo4NoeLJFUomM4NAQYkqABuptjYVG5zqy tN/tNxGKnTJh0vGeSHTGr4GHz6knBLr8ltInTQZzsCC6v0IPKCF5Qu3hp3ILFF1W0yE26I+mJJOH IB6Gwa0sDdh+2TZ8yqjYFzZX1o/nNmOi+ex78XOh19XZiUUoEH7sbW5VtWYJqBwkFpD6yVSDk8+/ 4dqkkYK3kLBhWNeASHW3N72jJwD0YryDnJCVJXFJUbYbkWIfbiM0ty5IuvG3AX3aa0jqb6I4vsmU 5b2Mkq24t/i4k0pSavE3S6Nu27hVKvrGxo8GqjwS2t9KFjiCKHYrCYA4jMjsIsiOaBCAdn+XXbTf eWsfb0kvy3lcVkm4id1xfmTnY65WlQ0xW02ua+6HXR95IdHlul7MbhEl5DnlvufRw2suiNqW/g3P fr+PqDX8dEUh8+VPoVpnNkmffym7l3JEVhEJCb9lHWM4i0Pf8Cg36Bsf3V1DCKXBLQyV7wU+lSYA 0RqwXQP2K0C4kocfxySwF/ojBfTx4K8Aoe/RddBDiK6blQAcpIAC2AYrQLwixwYHG56hU39bCh6S KfI03uJYDDM0QHz7+tbJx5xIm+cZkXg/tGTSqfiLFd0IDyrROpXF2HLaCjjxSWe8PqfjoE48fEtF 44YI2VQX1Ze3mBmeDmFkMxTR/cgq+lbyxHOIfbEToU7tTY5dcDhSORziKIyjlYi2mudIPus+o2Xk 73jlFksAgUcCQvFilDACIA9VJ1gaoVlNfXoqTls/vNVli6RieUXWclK1ZNS+mQHM1XqmdL/ud/GN b9+mG2JMCmW48wOqA8nodsecAKYjFEoItRxR+1HMQcxfGrA1Rhteu8uH+P6PsmtplhNX0n/Fq9lN BG+oRS8oEFX48DpIVFHeEB63+7bjuu0Ouzvi9r+fTAGFJFKcmYUflV+i9yNTSmWe6Oe3Oo/thdOT B+QLyum+yoHGp1RNAs8jWlsCge2LiOoFCRDzGAWs2WBsV3KEvKOhgAyRE5EzXWIu5ZxI44gSukgn omPlyV5MtceM+OQOhB7oYQU7LkgU+cTeKQFqtEsgJJpZAvayn6hPss4nhQCRRSEpV4iOe34S0Xad z2RZU3juuc7miX7M28ewsvmHPLDQ2yww1iFWR9RJzwZTGyxQfZJKDe6aEleASoyhqk7I3BIyt4TM LSFzo/oQqNQsrU9kbqfQ88mOlZDFXlfnOVoYuyyJ/YicCwgFh1O6Edl8hlkaLqVXPBMwZ4lqIRBT vQZAnDhE8zRdVhuvzdZSFkl4UmZEp5vwPvlq4wWLKtp6pP9jjYMq7ZlVU1cQuxXsqVNWFB1RjrLh 3QC6ecc7sjhl74eed9ytwJM4EW1zu/F0PAzMF6omE6+ixPWP+riqvdCJCCVCbmfkbJoB7VCR2uj8 hPSmbOwXhBI17wUOvT95jn1pB+xwb53XXWp+IxIElJ6DZylRQm1MHbQCudt1dRRHgaAfwy0sI4MN kcjuNQz4e9dJUmKOwFIfOAG15QES+lF8okozZPnJ8HZMcHgOUZgx75hL5fehilzqA3QoUahB7laA nwUnApNwUMSI3gAytQcC2f8PSc5IkWUxMj9Sc2oGkkJMfczqzLzW23N4oE1bPo7wbPbga17zLIhr qpoLcvLISkn07J+OJjUXgsch3Sh1DdLKW7u76yV58sZxBY8Tj5gXEogpFR4aJaHV57JJPedIPEQG ancAuu/R8lJMrCziWmeUpCbqznXI5pbIsTAkWY6aChiMWFoqciiNAkPoEhvsrUyjJCLVzJtwPfco zZtIPOoM6J74ceyTejRCiUu5xFI5Ti5xriEBL7elejqaYZKBXGJnBNcay1skhbGCFV8QO/UMRaoL TAWKvPha2BBGQrM1BjFGMb5n7TrTUwDfmKR4lSqGowsBQzOJkus+WVaM1ay/sAZdMSyXbbOT6qnm WxyUlVnGP9wuqxYqvt6TkSLRMzl9QLKy5kz6gp8uLQYYYt10Lzl9bUd9UeCRFL+m5NsC6gP09TH7 ottXXE+Qqpe1kAQfWuFPiyk+AWsF2U6du2HlIpLP2a3o2avSrbsSsnqYPXkclM60yRflxNvsIF/1 PnPNW73vJh45r6MUPbO1nJdn44k/+eblnNWpyq6Q9V9zsCW0EKIS1zjo+7UnB1TczjE/LD5OZeG5 1Gk2ZTXV7BqbYc05Y+Y18vbO87e/v31Ci3F7VO0iN/yHIEW59lWp3I9dzR3NSvUskUtq2eldCCo7 ySC/T4WXxI7tgY9kkS7w8F2H9rh7g65VlmdmwaSPVIe8Z5Lw007QrNDYec5oc5Ja5Dtj6Y2mv+FV 6NrrEdnmpmH1k+iHZoEk2eKv+omTl3Ebqt3vyn7Bk2+fjJeyoqGnF285RzdcpyiIvcmWY3biM/LU +Qlq8utCdcnbUwnO7+8UyiUVTAabwYN0M3uQof1xtLtKU3kORkPnRd7JTPtaRiA7ybakrv4EPgzk ZabVD6mQz+598QJXHcAZFRAFEa55Gy7WwN1dLQyy9G2tT2xpvJrVba4vLgi9sNpWHoSTpKsTUn3b 0NDsQ0mOSHOpecrMt+677pL34p4tM8U+dkdNIop62o0uSU8CSupb4OTkxMRXyckSe/SJkxrRhibG siEi41xspdrTWU9R1XZjH+SzeeoyTa4NiOk5a7adCh09Tuqce9OPpwPI+aptW29Wus2HNKb/NLdV ieu1vdYMfRaKMLF1Er7LSXafNKGIXPqmHnHOsqMNiJdBHI3ERsnrUNednkS7NZ1keXkkMMiptS89 j6HjrHk9v0rP6E5sV0g9VVDIrFWQtm1muwh86ef74TgJntE+s5HNNGOfaUmc7Bpa4MNKyq+kHDHS Ul2RZzseuU446pTQUY+eZko87jKS9IS2ttkYLLdiTwbPpa171rpAJclNUsHRlF8bFKs9vTkuJD2J rMkRZvYKfbe90kxHmxkwwWLt06ey4l4Fjn8wwoAhcoI3huC9cr3YP+apaj8kLW1lGc2wCZIoHxoY C9WYhKExJJ/XtKZI15cf2iY9bMGVhw7RI+tWJ4Hq0W+hGY8cNuqB0LAwEKIUIqFz/OnpFBiLc3ut 5+cw40gj8vnMP/Q3JrL4TNUTWh9KqiWZX1VtxNUfq+56YhNGllMG9UnFoZbyTJc6y9+8JdvMaDeO ohwZjJi2EumF0Ymgj6ph9hrHh9ryjH9jR/Vbat/kBzt2EHkuMPPprFHbSiLqJFjn0TUyBctD/5SQ yKyx/UHlShivUTz68DAgdbSpEPECa4NtdsNKhxrKh4GEVKZ7dUHDXMullsbkkXZXBotLd2KRNqEf Wp6PGWxJcpyP7qxgo5e8Ovm6PK2BkRe79LPTje3oNbDCBRu+ekpuIGTfSPPd0YaElmIvO+gbpZGi BlWaebuwJA1gFFN3qxsPpWzoaEi+cNN4DL1Dw5IoOFFtIiFdxNdBUDTeyjc50bNEQrFvrRPqG/+H Oqlak4mp5gIGpt2gm5gXkQXOOheakP6uC7UwWSqSJOHJhkTk2lR3r/HJcyxNA/qV+9Y6IZmOx+te e9swq18BhSVLYam3fb/oUscpFMmoSioqMnxgs19iKvEbLE0RLTIbXG8sYZLnRBfhXlPk1wz9Qc7O NmgQw3TcNPOKjaFPeXdmff9AfyFbKI4pFYuTlv0Xi564B0AwopunF0FCXpuqLKbGqmL1zXIQujHx 6hKa8X/3TKaEpkCgWDoRKScAlHgBOS0kFDdUc+DtvRv55Nx8KnAWzPMjy0ibtTMyYJ3JFFvEJom6 ZHQig8nQxUyUdAxgMJ1ccoG/Sb8qBPDUCygkcMjETMneGP5Vei7PapiBzBC0e3RBpQVwr8qeDGKQ rWFW9HiX/dSwJ0R8Bwx9Fj5DtPyh0SOS/v6WKXQ1K942DyovjSdtHu1xgfCurSOzrkE4fznnluzH unsr93J+fXHYGnVNpS8bGL3uko/PmNlxNUM3hEjv9UPqJx0fDNq8yM1cBMccNvzHxz9///Lp595t U66+/oUfs5Oy/FxSVK7cXyA176Z0GFevozr2UvPFx6WeEtKL8wppnxRndNjyvHykwPbG+rQC8fUX WB632iMDOledoBVyjERb3+nb3KXU0Jp66kIYzXDr05osP3CS9As6lcILQaJiWGcbht/xK74lpVCe XdnTbx8eB3z+9un7r59/vPv+493vn7/+Cf9Dv5DaY3b8bnYGGzsOfTS2svCyciPqWdLKgK7UBGg8 p0R7cLaDzbBPiq8PW4llkdO+3seakE3WwoiejUeWtFRWlbNPc6aaK2w0qZ93QjswQDSt80tHHU8i 2LTDjaWDWtuFtMaWyMRITTSDeY7tHpLk1ZjgF5+G61o5ZdehbuBXfYisOL4FrsrLVZjVvV1Il90S gpGpt9yQV2ZHp7Y44rguXNKL59DijOyILO3Rg981r6kDtSdLdcuNgryOlU44g85q8HRpw6r1PVz+ 5eefXz/+8677+O3z192EkKxTehbTw/GdcXSimFaSFeZexjbnsBiRUSoUTj7w6YPjiEnUYRdOjfDD 8BSZDTkzn1s2XUtUwLz4RF+q6czi5jrufYCeruyzeWaHFXoig8BuLPuWnum8rLuK0UVmVZmn00vu h8L1aUuzjblg5Vg20wsUGjZP75w6lHCm8T/QyqV4OLHjBXnpRanv5FQZSwyB8gL/nHzV5JNgKE9J 4mYkS9O0FTp6duLThyylK/w+L6dKQHlq5oS0HL4xv1zTPOWT4I6q/yt42Vzykndo/fSSO6c4dwI6 24qlOZa/Ei+Q1tV3g+j+Rmsrn0BBr7mbeJSRotLPc0zlqcpPTkCWtwLw7Pjhq0O2McKXIIx9ug4o PDZV4gTJtbKo0Qpze0ux9HLCkOduJG8UxZ6l5xSuk+O+NV/qtBElOvROCyeM7yx8q8BtVdZsnKos x/82A4x0+n5P+aQvOZPRhluB1+QnyrmTws5z/AOzR3hhEk+hLzhdVfg7Bfm5zKbbbXSdwvGD5o2h alGQqW7u00dewqLT11Hsqo8bSJZEM85WWNrm3E79GaZSrtvE70ckj3I3yo8rsPEy/5qS41Nhifz3 zuj4b3LVZNkNFt0JpZ0t52+xJUnqgBDCg9BjhUM2rcqdpsfFawtIxda2rHxpp8C/3wqXuh1ROKUK Vb3CwOtdPlqKNTNxx49vcX7Xb70JtsAXbsUsL0DUvUfAQIGJyEUc/z+5qcMDC29yupGVQh00zcbA C9KX7ogjjML0paY4RN5OooJRfudXn+wu0QFH7niJgLXA0m4LT+DXgqVvNYNk7i7uG8um6IfqsUgk 8XR/HS+WlfNWclC62hGn88k7He8isO51DAbf2HVOGGZe7KmiuiGKaVJcX+ZqCAlF1FkRTZorv/31 +cdvHz99fnf+8eXXf5lqgvTTvZtx2RU6He8aUQXyjfm/bsVAaqTPDh2u4Etc1Cpxilz3CBvGzGxJ FK4mPAigDlykvIwqxLXs8P1D3o1oVHZh0zkJnZs/FXc9u+ZebYq3kRNqXp1o/IB0oTO3KmpBU8eT yPP2Xf4EA7v0Duoh/CkT2t5q5ihPjmpJthLnF4MaEeXLtZd1lfpaNuiJLIt8aEAXhEADb/m1PKez VUAceYfoTrQycOo+hWBLjjLR31RJHPbToqMdRyw4b6IQOlK9T1m/7HLX4476zEjqXTLcPaxdaTNG fnCAxtodrIbmnVlU7cPIoy4xVvU+zW9x6O4WKwXCkxRLAnJq1te8S8IgolaH/dRWP2eiSW/lzcx7 IR/Zt2Md+6y7DHqT1CPXlx0gFGdj4Sj7HlS5V1YPZsaX2vUGn5wIeLmALNcx8cNY0VxWAPURT3WP ogJ+4NJAoA6VFahL2EL8V7FHetal2qnUCsDWFyaaMqogsR9Sx5pyMZPHHcY5WV4YI613vcRsq/pi k3ExLorBzNNbejnWr0GEZo2Qh4LT61D2L3w9Eit+fPzj87v/+fu33zD0gXmQVJxBG87RocNWC6A1 rSiLh0raqrSeHcqTRO2rXPUcginDn6Ksqh42kR2Qtd0DUkl3ACj+F3YGNVVD+IPTaSFApoUAnVbR 9qy8NBNr8jJttCqcW3Hd6M9eQAT+mQFyMwAOyEbA+r1nMmrRqi+OsdlYAQoHyyfVlTcy3y4pegRX ebcjLJWKzvWWw1GuJYHnMlh9MceK3Q+IZ5yx3YsH7A0517WculrbKGcKdEzRotSwCAx03bMH6FWe o2pBKlWOHr3J2w4jkvfk7QC2j5tLo3MtvTlWkVHGJYARbSy24fOB5D/Up892t3V+X96oGY3jOQ70 Ks8OVI0izkRYvDCCGEhQtnxWvgcX5etAGw9ubHRAxA23tsjzyFir43xmbLMO3Djebq2Zz2aRBhyp eLjqw9QniT7FnWFbdpw+kUNkt7RqaGkZeg1rYWUp9eXu5dG3Rov5sBnQKdzaNm9b1+C/CZAkrYUV IBnSkTSx+v3LbmZSmh/OubSvtYA2Gw22lBREiJv+6k0Ds4GLljpBxQYz7bwljWdDQTsaAXjIKREF 580ZRIpRBKGxYuy912HDzWaJ+jxjqNm2epgTpJ+hkcn3TlhaDouKE+s7SR27mvZG7qlycT1//PTv r1/+9ftf7/7rXZXlZgxx5cgdD8iyKuV8uQIlivMc6Rqj9q7tyfEici+k+ntjQYOSP6hv9x4ydyzy Zv1eqT7PNnBv3LthaY42RrRnTY0ndugEDgx5Nqaq9iPfSenqSfBEjj+FCYTwkBoTGkusBiVQKrDa j+6QxUSRyvAWek5c0ZE5N7ZzHrmkhZuSe5+NWdPQzbfYGr9Ve0bHanxjOK9lAUEFXzorKwrsmrBE kmIJXnStskj2/dvP719B+lgUnlkKIe7gh7p+7GMSa2T4txrqhv+SODTet3eMU/uc2LCYwf5TgPC1 T5kAFw+mGFS5TnvNWzHF3bdi90B4i5V6XO+1FKCFKiIh/prkkTpGbtWeoCkQ9IVLWWIqLFk1CM8L VPvynfnD+hlvh0Z1CIA/p5bz3cMbHYFWYrBoldQ+wbUEm/wZFVghdVmtE673nHU6ibPXdUnU6H16 r0Fo04lQMDSb2FoTiXU5Qo8BpE7RJXsk04WX6Fzmf/TPlqBYkG7T9haHhVjw+Wp8go1sSslnFDKX vs2mgpt53PDZGWcSLux5bGxlI14sWawCr0lav9ahTFQTCAZlbtieLH0xYKye3mxJ2Uk4DS1FeH64 dIPxKXbkHD+cxvZUkAT2wPwsnBtVxWLpfCmGV9NJW3pavWrRpVQU4RnjmkckWTIZo31wo1C3WJX8 3RDQbmZwGMBIqdPGG4P9INWGjlxQr/l/p3//+uW7GgLrSdPmU57iHJWWQiDnfmC/RIFWYP3JDZLo AJqIFGXP7mVvjJeVOmlKrGz53ZxtR/VoFyklX9RcrQwyTXyobCnJmZ1bI7NnMfLyUjrOSCaJuEh5 lloWrI2rbsWwz2CJXK8Pfd3nwdw/Zb7f3a7qOQr82Lyyi541F3FVewJwWOCIUg5XzScyJLPF8ZrD r/z5+dOXj19lGXbqPvKnAV7C6kVJs2yQ96BGGQDoB1qol2jXWSKsP9GSOlWTKB/4LrcBx6o1wTOr XkrqzGUGRdtNRaE3zrm8nFmDZK2+2RUvf01aCb8e+veLo16TOBjeT5FapxnMM1o7RRyW8rx8YQ96 NZfpSuNFOwyNI0oU9M5OaLmtkHwPmPLktoYojKtL2+BdvG4ftVInSzgI/JahzSLl4FeClepNbKYw zUXFTGsNpg/QJjrPhdXnsjdmy6VQLTQlpWr7sh24zndtK8FeFE75ezcCbiVscnlpjsCLiBLfNmSh oPMkMXr+5UHpdYgMmQwfp2d9TysYqmZx2F3aMOwK9OgJAVNhKDF+nh0VtqK9T899atZE3MvmSh5r zvVvMKKkUMUCpFfZGmhDJTKjAyvWtDej87F19qvRSsUfXWdIwDNiGaSI90N9rliX5h49VpHncgqc eUhon96vjFXmEDcmOXRnDYPO1qw1dG7fGhOhTh8F6Pa71bVn87yzZ4ehMXlbUKdBEsfr3Z4ZixZI wKIkl/NG0O+hZ6wvqWM6xEA6YS/mYOnSBm+fYBZS3sYkB2ugrRphFqNjIq0ejX1j6WApRk3UisNa Iw0aMvtqipfbfK+daSsymh/qY6/H46Sc6Q0KQniWCp0G2wLRJosxiiVDtJ9QpCe0pjDXJelyHhS4 fcqCkWLLgsG4BSlAjRcvgaHpKnOF7NVXRXKNQdunlJep2k9P4tF04KAji/ftAzOxlA12LGPSw+LH mVwd9LXnCmuLrYbi2g9cPIOQbzd4Ct2+NQ0oTE0d9/WGGLziA+uN0t1T3LN0UlmCPGiMibGEsW12 EiZntoXO8MhBpDqY8bMnuuk60L72pZRUdbbGxlDA6GNR0fkpefAZ2I4UVPFl2SysGnOSmuYL8/zs QYt+p6b9NNvXM3ymjzfpcp2hh9oGT5cWpChj4VCM7LX0n6qRWhKl3O01K/X7vG18IL5o8DoRw4rr rkOQCrvdZFk/ER4qGTVemZ1zUk1jPG9Gctrj1pfy6ZrlWt5mpoZqqCbRNLDuZmxq2H19fLMqCPWX n58+f/368dvn73//lD31/U/0N/BTHwGrnz881iu50QgFJFs2pZDLZcm4WTL7EYna/OIiheIhE9Uu B2hQLltUhp/hZ9kRejOBxgI6BOwx+exS8RdPhedO2kb6959/4YHcXz++f/2K5/mmaiQ7JIpHx5Ht rmU14kAxe2Om5ueL5jXoCaA/PdDrGFd9vGzoFqFYazi25GRrsnHwXOfa/S9lz7LdOK7jr3jZvegp PSw/ZlayJMfqSLZKlB2nNj7uRJXyuYmdaztnuubrByApi6CgVN9VYgB8iA8QAEGg20VMMOWOtt1e zmGYoYwuQRqTkZQ9126P0Kw+75DIJq7b7c0NDP1a0f6Uk3A0Qhe8Tk+RnEYnbKAybRvamc0ZVTcy g+h1f7mQnODmGmEfAci9gxYzU2ZF4EOcU0CV3/TqJZwA/z2QH1etSrxOfK7fgcFcBqfjQEQiHfz1 cR3MsnvcbzsRD972P5sE9/vXy2nwVz041vVz/fw/A0xhb9a0qF/fB99P58Hb6VwPDsfvJ/tDGkrb 0oADkb7tXw7HF+P9EJ3lOJr0vEyRaBQxQZLpJZD+S589uZO1yKmKS/7OWLKEh4i73dEoz16bCJNB JTuffLd/fqmvX+KP/esfZzSvv52e68G5/vfH4VwrhqZIGp4/uMrBr4/7v17rZ3t4ZEPA5NJigU/q PuniLsaQKCW5QWhxtlfBDaOtrJ8NjAecLozuYS6ESFBMnPfxzLYt2Wc4CyO7UXSrTOOEtyM0rMLK OHhbS3K8ejbTWogx6/clF6g0fVrnpzKHRva1i4FrjVd0uSus8pX8tMVdmJYRRse1GJBGlve+a8ZL MHDKmsT3eOGbGdUMzMMCpP5FElZslWh7RFtaAvpn57xq6i6AG2/t5d4glelml3MRKQy6JC+SO7b6 eRWnmB++Z0Q3wI8584ZBkhbh157uscY8s1vxXdKVmCwkaAR8zyeu53f4QIsM2NBj5lqS/gts3Wnx wMPXa7avaKYD9XZXxGHPQGqKz3t0n4m0r/xqhk7FUT9L1YR5VIGiwj7sN6lQbWU/JV+J8ZjG+LCw EzYlpkm0XffO6jLc5CE/6EXm+TTmvoFcVeloEvximX+NwvWWbfYrsGKUxNmGRREVk23AFhThnGcV iNgVIWgyMV8wTUrQItMSNrfoCLwN0WM+Y1PKGTQ9y1+6yP0JpwDPdx46yokex0Jf07GDnC/TZcIZ j6waot4qtqiQ7vJfLtOHVCxmq+UvmLUQa9cMxWLOaOWx8HURjydzO5OI2cNfMCV1Mr+1ZxxVgHoO uyRP2WC8GmdG7pGCZryuukt1I5I7u9dZcreq7AzElKJX2m6Oh+hxHI182lr02KQwp4d93LFWErw8 L9B036dJ4iWOfirSNiihu3yOmRRFpbJ70lWddbQNEHFAI92ksxKjePQ0l64ewhLkmpJ+HCoAFJIs MI+1VAzm6bZal4mtD+HF4txi+49At6Wg5Jschq21+hZrFHhmXuBuO3r3QoBqC//4AfvqyiQZjpyh NTDp8n4Hgwlqrf4qS3oLVwIOF1Y6K378vBye9q+DbP8TdNjO9Z5UbBbGPC1XhdI5oyTd0A+UOQxl AKE23mi42KwQaXbqBlQh3mePjWWgbwZBuvQdYoL6pOukRyFICJ0BUVAt887TLOGNa13SPhFaU+Gn 47XXAzUbaKzWt3bLdb5TLj/CoOtKtu0U1efD+4/6DF/aWhvoDDUa+dp0pJdtl11Yoy53bD/b0Bvz BnSpj22wqp4RQKRvn3LLworo20ChHmmuoBjMTDPtSGszoO1vF44izxt79qdo8C7OOd9qY1K2KWwe a/sqGwYzmMorrLF6mCuRnSG6RWcgWxQrAbK+ZUxBi4INAoaczSiwWSE2NFzHtrVvzpLO4cOEaJah jZsLG7IOzQBYugbiIKNgxAlBgRpLiAWuIku4Uv/aTTdQ9ituSDVqlNE1uNWMTXlKaPoH40Yyh0nY ib7edcfMQMnB6+ueQutHQP1GEkLOJ4Cw6HB6fvXdzIQZuHbm+tqoqP3rxqW0geT9XD+d3t5Pl/p5 8HQ6fj+8fJz3jC2Y3pJIsYAuZL1B7YE0wMwAdjb4vCNWz9fLCOXbHhc4xQDapfE5+6hQSqlslnWn V24fr0TXNH0ydUrqCehrFpc95vmh5253Su/Qilx0q0dov2ufQcPtPbzxMvptMMBfT/5NIHgsEmKb kQBYVQVnVlXIRewL4XueIeXrUjJy3GTbrU9U0C3XyoFwW6vVz/f6j0jFRn5/rf+uz1/i2vg1EP97 uD796N5jqcpzjHGS+iiuOYHv2XLJf1q73a3w9Vqfj/trPcjRDNkRyVQnMEBYVmkLNsHol0ctlutd TyNkutEbWTykFcl8kRuHYvFQoudkwgG7QW+AajfLVhFvFxaw+2Fb98Vgg7Io23amExBfRPwFS39y IUPq6Xs8hDgRLyLjhLuBQIuQVjiBOb3M5dZS8FdnBj6r5rk9Hgq1AiGgDAWrMVGqJn18TyXVlPMG JTTxQ5SLRcTXgY4/y6gnsvyNao5/2XzkLU2eZrMkXFd0LNHCUlJQlc5zKGONeWFNQjQbmwEiEbTB oHwxWXoSvIZdaZGumQ9eQz/TEazxvu9Av0F08yqi1C7boNasY6vs79fOOlqIr9aX64fvTAM5y57b 0d0mS9MhyJhgFaCyAw9zK4F0nuSYXo5rBi948a603fTy5lQ+JSLuTTfoTroi8e5TLZH0IYpW2Yq3 U0jKWYk69hItEosH1FyXd/SFidzM+OqEMbLIGsKl73gBGwlI4TEzJzEhqoajfOR7fAKTliD4hKAv 7LpClo7jDl13aA1qkrmYbps8bpUImcPBsagl0OvMAb5TGnKWpRt2asaRkFCMgczVpeH92VUkVU+e GdUe5jIZdjsJYPatmMYGznZrf24RBNst4x5xw7LZM1uszxZijXAaOwkclymE77f6RyPre6nWjmjA jn+wbRLO2aiRbxdoMlpUYbXubsPel3gaG7neUDiToLPuiwf+xbBE3gLk9lU8iz2MRm5NW+UH0+7Q V1GIwYb7qqqyKJi6nTXQjf5+2wnB3xawzdBE4anw3Xnmu9Ntp1MaZb3qtJiMvEf/6/Vw/Ndv7u9S iCrvZgP99O3jiBE4GZeowW+tC9rvHTY1Q6MdJ/JKbDeZkPrAbAtT0lcIQ3JaoyfQR+jR9DNTYy2T CDUbqzOyo+nYLtDGoVahAF73lx+DPUiV1ekMoixlyLfhq86Hlxciu5o+ON1V3DjnyDdSvQtFE63g lFisKrunGhun4t4ajAaVV3Fvy4sEJFAQXDhTJCFkH5MTiojGQeWJQtBFN2nFKbGEjrp00S/VXlVy JuXQH96v6JdwGVzV+LfLdFlfvx9Q8tfq2eA3nKbr/gza2+/8LEkju8AgIf1fGsJ09R64DVURLk23 dQuH71bspXgbpLWVOI/2r+patvGrZrhh+X3HdFUJ9+kMw1yatxKu+whCSYjRFWzbLOz5/b8+3nEo 5ZvMy3tdP/0wWwRpPbxfW29oWydKrnRbOMbUlp0Y1yqCVx7O1vOuk514XEbSoG0OlniQcN7aoWvq jodC7PLVJmmDuph9Q2yfJqXRIsnmqLTRIIsKBxvNTjzcxDCiH3ebifW2c2eEt0SZ6fO1iIfD8cTp cDYNbwFpDjWKKE3xasygq9zRvRnVDLCeIQgXYSn9DQoZHbdVeXXQSIlsczBrcLmSUxK0Y6AQSrqF U0uIvlAS+gNh1YLqxjuymiSc/mjgmwcDZi8MGxx9cA4/d1HKt4m4Ii436GuTll85SxJQxBh5W1GQ VnZhElEAHFzRSvh28+jvqL15eruxTCrW1IvFyzV9oIvAfD7yuKjcmzkgU1g2a2lFMVx1EEN/wYaQ lOaOkHDeBCBReePObAP7ozhgaIruA1SEmh26ufaWsNNgpKok1jSo463KR83aSOMNfsmF6t7IWzlE kjIqHTN6JfYVwYclQrs9tyGutIfw0/l0OX2/DhY/3+vzH5vBy0d9uRLH7SZj2S9IbwbiMnmcUVFY g3aJ4M3lIDzfpexTiltsELM2DdsVKZv1cYEREqLMEDPgB85otloB1ze4kibEd7PAJAyDneJTViU3 WCfJhYEyMgi1rICgp8MJF4DOIFIZWt4YjEgDEjvNQgUu2ydAuUTxo7jhkGdghGjM6VEGSRRHydgZ sV1D3NQLenoQCRktKuJDWhiE4TbFv8B5Pu+KmQ2xi73l4uSasLSuLsEmCthPbLLC8dWqNHyYPp6p XV11Qs0k/t7iAXSEpW2VVULM6+npXwNx+jiTxOatCQndfNE1FDZINRrO2NOcrcSoAySr2Yrj4IoX h2ZebwVqn1Ao3936WJ8PTwOJHBR7kGRR+B2ILmf5FSltRwo35hVfA9aPGEIhqkW5Wt8ZR+pqvmtO hobl+FOHhUXRww0uO1nWb6dr/X4+PXGDXSb4XghjN7DDzBRWlb6/XV66VwhlkQvD2VP+3C2FDdFn jXHZQ+u7fRCG8NDv+JVofAJ94+Fwro3AgQoB/f9N/Lxc67fB6jiIfhzef0fR9+nwHSYmpipk+PZ6 egGwOEVkSJqsFQxaxVI6n/bPT6e3voIsXnnkb4sv83NdX572sC6+ns7p175KfkWqNLH/yrd9FXRw EplIl/JBdrjWCjv7OLyi6nYbJM7wmVbJFsMGoIpSlStQVkp2mfzz2mX1Xz/2rzBOvQPJ4ttFgcb9 ZkVsD6CO/d1XEYe9KUr/aMnchFrMF7SZl8nXpmX9c3B3AsLjiY6cRsJZv2nC6K6WcZKHS85hzqQu khJf26ADWrttCAF65Ak4+tuNb6JvCU6JXmWWBwYDsl9X+dPfw9xutR+vQp8wn5Bsq6h9xpT8fQX9 s3n3wtSoyDHf+A4dSXsr3M1FCAIH8QnWmB5bscYa+SE7CN83U5G2cCs9okboA7cDrpaBa9oPNbys MIVj2GlX5EFgmjQ1uPFv4xCwzvEu2KP55KXwzR1spiUHfmhnMOOcucF20YwjRR26D54s70iEPgOL Fyo6ly7F38swnEBFwdrAAhKF7iHBqn/ngi1DP6ZpVeCmuZF4Jol46ERk0uCGvKdrTYgfdWA8PdWv 9fn0Vl/JcRfGqXBHnhl4vwFNTdA288deB6BvI28z24D7wlnO8tCd8K+jAOWx710AQZLWqd/YRAdG 7kZneQSLWz0Q4aF2HQaGZl0IPdNAEoe+FZ06D8vY4QKEKYwxkBJgXtfKqax0qz7I16IHh69yP8Oj PbvB33p2vxUxH6Xvfhv9icly2Fzoke/55J44HA9JwnMF0ONnXM8qcE8ac8BaWWcBNBmydzOAmQaB 2ySrM0sgvLeEwfvybQRrglzrAGjkBZzqJ6JQ3zQaGvE9qJhc5xAzC3XMqUbiovtL7bnjHsQwfBD3 fHg5XPevaNGEY8TegXC83uUYKjerQnOLjZ2pWwZ0f41d1kaDiCnZn2NvNKK/p67126I383jD7+GY lh85I6srANmlGKVJBvYHyYpz6yJ0HXYB5xWfLUeiJjtuphFl7kf8bX3b2DwE4fdkMrbanbL5PxEx JHxvPJ1uadHpkI3mD1xTqseh6RobRZhP1bWAeBtOQXG29CgkWW6SbFU0ERJXJN7LZOiTZbHYjl1u pNJl6G23uuJWJJZ3tgjl7iWqyBua6bclYBJYgOnIBpABRtHF8bhhQozr0p2mYPwtMuK8IbvhAeOP zA0fbmnyjDwqQPLYUsCQpqVA0JQdPBkeCl1ZVEplOj15stx9c9UokuoKb+RNe8Z2Ga51hmrD3I2S GYhPfAkZInaDIubNbH8rektavEs/KSwJNlYvWwwg+LTxIpaSbb6Ku9fcrUOhrMCZuFzzDZK+Mmyg Q+GwHgoK73qub3AjDXQmwjWzgzW0E+EEXfDIFSNvZIGhAjewYeOpKQQr2MQfDjv9FpPRhHtEp6uW fgSkoiqLhsGQCAub+ch17AVimJ8LfMAMQkIviTZWbTv45iT67NQxz6X5+XS8gt77bBxGKFKUCZyG 2j+R1mmU0FaI91dQNa3jbOKbJ88ij4ZeQCprSyl96kf9Jh+riPp4OZG6qgw2R7HQcVoMviwRybdV izEEyWTEZgiPIjGhglsafkUBg6EtcjF2zBxeIop9pyOOKCgf8V3htLOwWQbjepWYVELcFayroCiE KX5tvk30GdQYDu0BU2EQD88aMIBZHESnt7fTkcSsZAnMmc+FHk+hRTtlmBJFU86o1JRBRaHLdQLp NIaKThWWDEub5XFEJrdwemJ0Eie17GEH7NW65cWuwDEjisJvf+TQ31TKCIYeWT0IGfZJL4DiclkB Iph66CMhElI3Qi2AbwEc2tuRNyzpmCBwYglpCOkRyBE5HdEhB9g4sEROgHBMDxEjlxaleZAkpHeA xmOHP1UQxzrrgjRmPXEGZjNho7zGxQpjsJsilhgOPdI9kFvcEe+cBhINSTufjzyf/A63gWtLPMGE PdFAwhiOzTQ8CJh69qkInXUmHjqi8QcM4INgTJL2IGzsu13YyDX6qg4cNRZGNqRP9oiKHwUs4vnj 7a0JpN3Z9Mok2IlD3AaIsivQmVLqf3/Ux6efA/HzeP1RXw7/hw5hcSy+FFnWmLfV1Yi8lNhfT+cv 8eFyPR/++kC/B3MLT9GR0eSMn5WTNRc/9pf6jwzI6udBdjq9D36Ddn8ffL/162L0y2xrDkI34QcA GLtm6/9p3W3qg0/HhDC1l5/n0+Xp9F7DYDenpbEd0HLjsKefwrn0YXcD5GwX2gxEeeK2FN7UqgJg w4C33Ny5I2K5wd+21UXCCB+bb0PhgY5g0rUwWt6AW8plXqx9J+icznQRVxjyc6UMJ5wCVd35nuNw O6c7EeoUrvev1x+GKNNAz9dBqd6UHA9XKuXMk+HQ4msSxCn6aPt1XOLFryAkmQbbnoE0u6g6+PF2 eD5cf7KrKvd8l03YtqhM5rNAEd1UtwDgOS5ZLYtKeCyXXFRrz6hLpGNluzF+e2QeOj1WXAt2/hW9 Td/q/eXjXL/VILB+wAh0TJ7EpqhBI2ZzDMe8gqSx7F6b5alL61KQHklRI609sBKTMUnToiG21e0G 50/5+3xrntLpcrNLo3wI+9rhoXb9BMe3gSSw3UZyuxEbvokgop2B4OS6TOSjWGz74Kyc2OA+qW+X +uQY/GS5mBXgXNOI6ya0vaVQDpYytwfLnf+Md8JnjQ1hvEaLibkkM99x6W9gRaZ9sIjF1KeWFAmb sjJNKMa+RxKqLNyxeaDhb1PgjXKgn7gUQJV5gPisHQ0QI3P74u9RYNR1V3hh4ZjKvILAFzqOedny FZR4Fz6eppNotAWRwWnkctIpJTGzXkmIawpkf4rQ9UyRqSxKJ6DCflaVAStpZhuYpmFkmOWBIQPz 7pi4EMapBMtVCKey0Z1VUcG0GoNVQPfkSxjCIF3X9MbE32ayTlHd+765fmATrDep8AIGRLdTCyY7 qYqEP3SHFsC8FGrGvIIRDkzLnARMLMDYLAqAYeCTR/WBO/EM/9NNtMyG5DGQgvjGB22SPBs5RHeW kLEJyUauucy/wXB7nkMEObqFlZfe/uVYX5V5n93c95PpmLXMI8LoY3jvTKdkH6p7pzy8W7JA9pZK IuhTwPAOWAt93ecHnpknT/NCWZa/Smra+wxtXjRZE7/Io2Ay9HsR1jqzkORzGmSZ+5a1mGL6jC+U yBINH8M8XITwRwS+wyov7HSrhdC+VrbsZvmaWGkIoRZOnl4PR2YN3U4jBi8Jmtcigz8Gl+v++Awa 27GmrS9K+TSEvxSWD+fLdVH13Bnjaw1M08KjxaOYCwN16zDfLX0KHkEGle9g9seXj1f4//10OaAi xm0fyeeHu2LFO77/k9qImvR+usJRfmivu03rgjfmbvViAXyBSOGo0w/ZWHASM3E7xJMxKyuixs8f U4hxfXpnQRmhpCCSQFVktrzf89nskMBMmdJwlhdT1+F1HFpE6c/n+oKSkjGJzcDOCmfk5HcmryrI xbn6bfMzCbM2aJwtgG3zcXLjAmQoTsJZFHT60qjAgWMfMReZa94DqN+0ZxrW0SozYLOcNpSLYETN ywrSw6E0kvJwgPnjDtuVYch4KCsIK4zV8SoYOnwWzEXhOSOui9+KEAQ+w5avAbTRBti01xhD7IXS CsdHjJ/bXT/Cn/rkoqBLrJfg6e/DG6p+yA+eD8h6npgFKQW9wBSaMM9WKV0CdxvTmjfTsTAbeQsz +7bC4Dwej4emqCrKuUMzR22n1pI0UUFPPGCshuMJKNf4DnWZ2mSBnzmd5LLGaH86JtqL9nJ6xTeb v3RI8MSUKMeecC0ryC/qUodW/faOdjiWW0iG74QYVC43nuWj5XU6oZe6aa7yrq+i1dqOm5Ftp87I ZQ0lEmVdPuagc3C2Lokg9twKDj0q71OUxzMnNMa4k2DEThI3IDctoCJx4OAncANO10ZMGpPwOAhK /r+yJ1tuI9f1/X6FK0/3ViWTSFYc51TlgeqmpB71ll4k2y9diq04qomX8lInOV9/AbLZDZKgZs7D xCMAzZ0gCGIpOVc1xOgwJY2M3E9wmZcF6/OB6KYoSJAb9YGsyNVM0aADpB18d5PJTvueqEUAP0/m T4eb270fBB5JG7i4zEgCUIQtxHp4zFHfP+yebjgTzE2WID1cWy2GPHzoGW+aDb4lYcXgh5Zw6Pgj UDSZTLtVGmFItoAv+EjXRFzAC8TH28gtelFj7OBwkf3uCBSowgiQPYIw5RmvzDS0qFl9Pbn+cXj0 4/QABh0TiJcUNIV6n6JvZSWQjsbH8QocyisxlraVbUG/XzdllEzpfW2IDlxEDU0rDKeVbIh59tgU jZlXUVbDYtPv0i4WRdu0W25deJOMruL62FhdntSv356VufQ4Hr0XnR3JkQC7LIELT2yh51HWrYtc qJiV6stxLuCLPlQM7KCq0iaY4+QSNJbJzTAh0WFwyVqlOJFuChuFyyrJLs6zr31cSYLDvJwp1xlE lheim57nmYqk6bZ3QGJv+SWLzVJWTXzYF1W/KMtVkcsui7MzS/mI2CKSaYHPuVUsa7cBylxFx/kM Vk9oEk6WQZo+XZDqh129Cok1nVhHnL1eBmo0Xdc5KEaJtGEjdGWRxdLhp+sFaeHSkn+nqEQgtiYJ mIK/jFdOt63cSIoztDs1AVB7E5Cbp4fDDTn087gq7DQ0PaibJzlwBNi3IXsTXRQZD8F5LeXAkQnb VT8HxmsD0TKpjoUVEqpPutxJ9PThOaf+uoJ/vNNgtT15edpdK1nST4hTN9z8ac7SkKToBuLGJRrg y4YP9TMQwAI8UlNX0nDVA3TMdmDePvzemI8W5ZLqiNMGeXmJs2dsJEIoHXb0jhbUZctqIHQMMFx8 tCkZZG+sxH+ZRHLmXf0GbCai1UUxdZ8cbMJ5lcQBB3GFjxd8gssFK1upMEwgYl6M2nwanM7zFcNo dyJefvo8tQLX9+B6MmPle0S7OcwR5joncpokz5WozLqiJKd5nRTk1QR/4dnsBMmo0yTTJ/a4BQCk mWjUVJwdr1Ihwf/nMrLCXUSYci4QXztzMoqMCgZbMNOWAQcM9aC4rS3k6fTIIBbWaGdcs+FPAJeo AF/UB2VqhSHtAd2FaBoriqdBYAhamLiIXzGGqpZRWzlhSSjRKR8LGTCzbmH74MysWq2WzmhVDsbJ MP3nPLYuOfg7GH4Co7vOI9hZkspLCQwqRjC1VsQABmLWvWkgUFm1k3xRsGX6A06R7KAzdGQsxp4q FPPhhdcZhJgU4Rve2RpJvrZFw6dyufibtiK+sjYGQooc2B8cW1HVcnIRknipbBAoauh4Axehhg2V Cqf81EljPm8qbzTGgzFJ9RfcipjqwSJlKRBG0zr6hT+vBnF8IxkqbiNRErXsuJZpJ+Mk/1NGgXST pgqMK426MCdng0GnV5z33YglAhYBriIffFXbgZNwXlkhKLThcWHaXTUwHRcUmDw7FUkq0dl+jRor egKB7IZW25cWReAk7OA6UV2WobGsMaeSxYUGkMuKRsS8TeAozdGzJReYL6CmVEPUHCMwuoBEA0zc rrGxQiM4a3fcuuRWg4F8NbDbiip3BkgjPC454hcZMApe/6Nx3LOAKjVqyMxi2rxFbXN+DbNAixZT QRNA1NaWoqsPSxLY3wWMeiouHbQ+RHfXP+wsZYta8X/2XO6pNXn8DgTt9/EmVkfzeDKbOaqLz3CR s87YP4s0kSR2/VWC2bXIXSRemB1tauRr0S8XRf0eWOB7eYH/5g3fjoXiU0R/UcN31mBuXBL8bYIV REUsSwx0Pjv9xOGTAsME1dCrN4fnh/Pzj5/fTd5whG2zOKdbuq/0zoYwxb6+fD8fSswbjx0rUHip KnS1Zefz6Ahqrcjz/vXm4eQ7N7LqXHf0Yghau0bzNnqThYzqEYtKGbpDFBAnAHNIJg3NRaJQ0SpJ 40qSfDxrWeV0Np07ZJOVdpsV4OjhrSm882zVLmWTztlDEC6Ziz5JPBGlhohDy2Qp8ibRPaNBUPDP OMNG1eBPAuHlSa0jl0E/G5lxjclTeodOa7PKrCU7Lpi0HlZ9B6ueL3Ak+XRq5cOwcZ+4pzCL5Pzj B7txBGMJrg6ON7tziP628ednH4KNPz/jGbxDxOu8HCLOCsohmYWG4Yy8RDqYsyONZ42JKMnn07Pg +H5mLXadz6eBFqOPZKAvn2Z2X+AAwAXYnQc+mEw/hicIkOEZUjHqglhTL2eyRfFTvrmndnMNeOY2 1SBCu8DgvYkwiNACNvjPfPsmgQZOZgG4s8TWRXLeVQystb/PRNTB+Sxyt/2IiCRGrQ50QBPkjWxp NosBUxWisVJAD5jLKklTO0mlwS2FTBNeSzqQVDKQXdVQJBEm4OJimAwUeZs0XP1qJBLB5xM3RCDt rhM75Deh6KWE4as2T3C5cwqXottaTzCWgkR7Zu2vX5/w0dcLd4kJE+mJeYlB8L62mMDLuf33Gadh ppAMpOalfQ3RdwMZq0I4+2IJ14AV3E9kJfAKYX2NSCWxJ5FG8g/h/U0QwyLWyyFaH2vW5WpEDMQS CEx5uWy2RbVmMKVoSGwqFYUOxLFY5tDRVsVcLC87kcLFSVgiiUdkyQteCQsoYi4CaR0WcL/DS05d tBUb5RCv4CqxGT5+x3Il05K+jrFo3bM375+/He7fvz7vnzBf77sf+5+P+6c3zJCnhYjLhLv4DSRo LccMIaZwBPnVfjMg5UbruNjmaHkdVIkvg4q0JBO6LInPEF2Bdm1tjctwXhTcyjBy9biWBI2oW2df 3qBv0M3Dv+/f/t7d7d7+fNjdPB7u3z7vvu+hnMPN28P9y/4Wt9Pbb4/f3+gdtt4/3e9/nvzYPd3s lSXKuNO0enh/9/D0++Rwf0Az8sN/draHUhQpaRBvfN1GVDqLu4no+/solcoC9JuOV4KJ0vCxNecz PxIKWHakGq4MpMAqQuVgZCNc/jSGslsSxjYCdktIePU1P0YGHR7iwXvUZXOD/gzWhVKPkM0vVKRf O7mahoHIHpXkqVZDL+j21qDyq0tUiSQ+A8YUFRtyR0fGWJiHgujp9+PLw8k15hR/eDrRO46sBEUM Y7q04vZZ4KkPlyJmgT5pvY5UUu0gwv9kZcW8JUCftMqXHIwlHG4fXsODLRGhxq/L0qde0wcPUwLq +nxSOK/Fkim3hwc/wCDpmOe600GaXarlYjI9z9rUQ+RtygP9mkr11wOrP8ykt80KzmIPrh51nSXZ 9ZGujOHD67efh+t3f+1/n1yrRXr7tHv88dtbm1UtvOJjf4HIyLIQGKAxJ/IM2CquBfNZnXF6NDMU bbWR048fJ59NV8Tryw+0SL3evexvTuS96g8aAf/78PLjRDw/P1wfFCrevey8DkY0m6CZSZp4z9Ct QEQS0w9lkV4q1wx/By6TekKdSkx35NfEimU89H8lgGVuPPXcXDms4hn97Dd3zg10tOBeEgzSVmAM UE5wG5o2Zz5JXYWSjS4W82PoEpoervGC2VAgKG4r4W/rfDVMgjvWAmMpN60/fajw3xhDqBVmYwiM byb8/bTigBd6KmzgRlMaG+v984tfQxWdTv3iFNiv5ILlx/NUrOWUmyONOTK1UE8z+RAnC3/Vs1WR 9e7WlcWcjeWAZD9JYNErkyP+xma4ThZPWIc1s6VWYuK1FIDTj2cc+OOEORpX4tQHZqf+9m1AnJkX Sw+xLT8q/zB90quEpv56ErJmhgGgXcMZGwyzWGxVeG23ToNgQv+Y+RWZhKsyZyY4UOCFz4n4T3D+ rkLoGVNXLI8stEXgKOv5qD/2sip11gx3Tmb+Abct+ujjLHxMgaTn5uHuEQ3PbSncdGGRWtpaw+uu Cm8YzmdTjiteHdkF+mnQLUi9DPYLp9rd3zzcneSvd9/2TyZKAddSzCrSRWWV+ysxruZLE4CewbDs S2OEHcKd4uDYCPcLKbwi/0zwciHRZLO89Jko1GUMAqhw/PPw7WkHV4Gnh9eXwz3DktGbVkj/eFBe tprdGdvMYzQsTq/Go59rEh41yCLHS6Aii4+OA30znBdksORKfpkcIzlWfVBiGXtHxBp3bSFRgLOu tnTtXCnocZ6tQnlzEp+qQGGPFgAMVxfBcfPOFMFjh29ZPubVzbHsQPtUfPKSuw2pI9W0yePUeOL/ TZ8xPYI2JU+mEbdTBzxI4P+kGBzpDzNGpgcKuL5X1FDMQ3VRnmOKOZbETbRBUKgVusCIqxwyiuB8 ZScF2pylxTKJuuUFG0WyvswyiWpBpVPEPCTWrd0gy3ae9jR1O7fJLj5++NxFsurVkbK3JqNDXa6j +hxtBzaIx1KCFmdI+slkqBmLsrB4OcNSLA1ZskQVYSm1aQbaSxjtqP94j9EJvqvbzrPKtPZ8uL3X /iPXP/bXfx3ub0cWqp8HBz1Zr8wlijsPX395Q1WCGi8vGrTmHIcppLIt8lhUl259PLUuGrgzZgar G57YWAT8g06bPs2THNugjD0WX4YADKFTRqtxqHrHQLo5XK7h8KTKYjTdEhWQ5EvKttHfwRrYOWwY iZloyFozDgSLJI/hnwr6PE8cu8kqZh9PoDOZ7PI2m1vJbbR2nfo/qMdmNByJsvIiWi2VzrWSlrQf wZ6Do9oCTc5sCv+OEHVJ03b2V6eOQKQYWp/FKsBMFQlsRzm/5OxgLYIZU7qotqH1pylgSPlyz9zi eLktosn8krl/XYvIFX+4nxGT9DwussA49DQgSA5maGPJCI2lD7/CIxgEJ1tOvdKig4GOx7CCL9KG PQ9ArB1rvqNQUjOBz5h2KpmWh/PtB2mXIVdgi360drxCBKvQN+Td8or6KxFEekVfJsyeY55t4NiJ u7pIC31VYKD40EU3hoWDKiluTrN+K7vojUg7vDuSw0ZUlbjUFuX0pKqLKIGdvJGdIhhR+AIQ0+6g y0ZRUsMO1SSNSGW+pC9YCoeITJTqYcg1SkGciOOqa7qzmWZFpB7oYCoqTOO3UlK98zG2bVFU6LME xG0+PAqS02WbFE06t4uNMssuHkGlrIC1KZR33MX777vXny/oSPpyuH19eH0+udNvB7un/e4Ew6L9 i1wZ8IkIpOUuwzSe9ZfJmYepUf2gsZQdUDS0B1+pg1nmrKIS/uXXJmLtPpFEpHD0Zzi65/aYCPTJ Ctp3mVkdTihOLF2metmTdalS8rhvhsu0sFRJ+PsY+4rSq64RZFqT6iveMsgxlJUJhkYix+Z8EZMV hC5EFSpMm8pa7rAFzI7dxHXh7+OlbDCkRbGIBeOah9+obKhdTi37irwZ0iDdUahLdP7r3IPQTa5A Z78mEwf06Re1sVCgEsSEtC+QvO7mGJq/qHLEBB6AgQQWVdLNfnFeyaYJH7xyJx9+BeJl9wOQY2dC RQJ6Mv01nXrFAiebnP065Q2e+tawwZbQL65wRRP10LgVNIGbAsWyLBoHplUGIBJh9oshS2QNjMpy 6kDDgHw5LFg7WIAj9dnvt0ZYVtDHp8P9y1/aVf5u/0xfdYkpI3D2tVphAVNHhY+Em1FokO9URlQQ ypYpSIfp8Cr2KUjxtUXj2dmwsfq7hVfCQBFf5iJLItcM2wKbp1AijGfzAi9JsqqAjntJ1h/CfxsM Rl3rz/txDo7doH87/Ny/eznc9eL6syK91vAn31JlUUEblIn2l/PJ5ymd6RLOS3QRzMjeXUl0T67h 2IV1Q9mQbnOtfQLQaDITDT2nXYyqEh00Lmnv/nH7/4cmWOtXWbz/9np7i0/Yyf3zy9MrRpOz08IJ vOHCbYhNDKp7QA1ZDETx9m2n+zseDAaLb5WKIENfLP4QsUsKWBAMh307r0UOAnieNHiuWQOtcLQd mhhujSW3DSJS4ByToVENGEVqgWkgcYrXcKaCvqmrZNH4X8XJJmTloAnavJKoFZun0ulhV8zRwUQd 7C5qrpmdU5kEwSZY0Xj4O2Xxg6w0B3qkh1NsHSH9Oio23bwq1jKnC/cfLUV3PaAltZ20gxq1DGUQ i3DkR/KiwRDmVJJW8LJI6sJ1tNAVVUUsGu2BfGzZaeLthbsDKGRwzW/iNiNHg/7tc7u0nfelsO4t Co8CM+UxKJv0I5TJLJVi7RxtY2M3WVcum379OL0eccHd3uehRXMap35Vz1rU1EbSQeATpC309RtK Y31FscaiSRyeonkxrj24GVg3NqfiQIEaXLRNqs0NRrs/hUiU9xtnM6jQ+uCXub35CG7Ug7vddSpS WSqkt7xcC6RxQffXDfh5Ujw8Pr89waDNr4+a169297e2KIDp2dHaqeC9sCw8+qu20sp0nURKjIBx AvDoloBbHFU2gSzox5un7T/hhLp5xWOJ7tXRbopBu2sUG7aWsnS0cVqRhrYJIyf53+fHwz3aK0CD 7l5f9r/28D/7l+s//vjj/0g8MfRWU2Uvlag2pCTt8Vs4plqVk9EIcYSL/Tc1uj2Bm8kiFUtugtRq ggMqIutMHf9oBdfmNVye4fqs1TlGi6iH/y/NTm92L3D/BD56jXpIIr3oqlGnSdQDitd0iuMBO8Kw e8YB0ZraQNn6qTBqOf4L4C4q207JPsOimk7Gou0PB/WACu0H/a8cZrJocy0WHccu4XBf8TRG2Fw4 48sgu23SrPAu6PLaHp0pX3JlZlfFDgm6Dak+IyWcNLnHsBf4GuneMLHjulhytqpu4EW9c9qsmxHh EiaaIFzGbiJClVtP0VuqYPgDS7vpYy55A+bRm8MsQOjvHneU0RpWXYK9ooMz+zeTGprPI1M5XhFN 0WVV4OsGdy/SXH+odbQorb7WxWLRYwJXLimzsmFITNnRCvaxt0y3qWiYGvue9CuL4xv9SqlzUdar wpIvHZRK36h25pYVg+fAXGBB9OOi5G9amoGLPC9QeRf3H8hAwBtDDhuCIzSVpmv1tKayQrKTqZZx 7S6v0Ea0serlgQgD9WUOS2IocbSKxwefPnhocJD7DaWdup0NqXa79UAzauDHvXlUP2bqEKlSpeHg MStB9xf/tFWduNbMZsui/G0mQH/I6Vn6tTWecQ6iEVXTlt1wAHp8xaZhqqB9d4pjKIYoGopbqFSD 9E1L7yxU7gEKrmG2WSmZWmRZXqtrgblAuMkl0rIKzpP0N1Bpew0of4+exhNDnvHZnDkM9SiZY9/n laiV698G1/T0dcqjeqJm//yCggfKWREmRd7d7qkkuG5z9slp6CbezjyBG0RUXDS6vSWVny1qdbPT 4rB6QxEV3qdqhwAVH1WLN0n7xqiRMIECbrT61vrhFwbMHiTRCnatOipg9nBl2FZE6TpuiHmslk5x 69ZalWrLrVmSoyqmZLeIosDPuFVL31XsVSaaAnjS2Yyq9wyKWOEPij9a20pe4PWP2/qqMVpvqLXh tdNLQNaR7cmjH+4B0RScNl+h+0fnOwvoKiz1Pb5NYq/F+oEoVDh69C9gn3iNqlBRGrpT6qFwXikV EPZ+iD5dZ34n8OHJbXF//QqVg35InXKJGvXu+PoNpXGv6+qbRVJlIIhLpwG9j7gNbBVncim1D5Qy ZrAx6O0Bx747F0r8UNdtj5yBKvcWVG7Q8P4yc68tR7mH5+eiVdH/D6O/rJizxAEA --===============6973425252976832504==--