From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 06EFE2C99 for ; Sun, 7 Nov 2021 12:11:07 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10160"; a="219003678" X-IronPort-AV: E=Sophos;i="5.87,216,1631602800"; d="gz'50?scan'50,208,50";a="219003678" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by orsmga106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Nov 2021 04:11:07 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.87,216,1631602800"; d="gz'50?scan'50,208,50";a="601098666" Received: from lkp-server02.sh.intel.com (HELO c20d8bc80006) ([10.239.97.151]) by orsmga004.jf.intel.com with ESMTP; 07 Nov 2021 04:11:05 -0800 Received: from kbuild by c20d8bc80006 with local (Exim 4.92) (envelope-from ) id 1mjh0q-000Aah-Ew; Sun, 07 Nov 2021 12:11:04 +0000 Date: Sun, 7 Nov 2021 20:10:56 +0800 From: kernel test robot To: Jian Shen Cc: llvm@lists.linux.dev, kbuild-all@lists.01.org Subject: Re: [RFCv4 PATCH net-next] net: extend netdev_features_t Message-ID: <202111072012.RLqHHlu2-lkp@intel.com> References: <20211107101519.29264-1-shenjian15@huawei.com> Precedence: bulk X-Mailing-List: llvm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="2oS5YaxWCcQjTEyO" Content-Disposition: inline In-Reply-To: <20211107101519.29264-1-shenjian15@huawei.com> User-Agent: Mutt/1.10.1 (2018-07-13) --2oS5YaxWCcQjTEyO Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Jian, [FYI, it's a private test report for your RFC patch.] [auto build test ERROR on net-next/master] url: https://github.com/0day-ci/linux/commits/Jian-Shen/net-extend-netdev_features_t/20211107-182136 base: https://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git 84882cf72cd774cf16fd338bdbf00f69ac9f9194 config: x86_64-buildonly-randconfig-r001-20211107 (attached as .config) compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project cefc01fa65a7ebcc10cbf3c3bb2278a6a122deaf) 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 # https://github.com/0day-ci/linux/commit/1e2d15fe96b9ee363f2de176506f0b60f79835e0 git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Jian-Shen/net-extend-netdev_features_t/20211107-182136 git checkout 1e2d15fe96b9ee363f2de176506f0b60f79835e0 # save the attached .config to linux build tree mkdir build_dir COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=x86_64 SHELL=/bin/bash kernel/sched/ net/core/ net/tls/ If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All errors (new ones prefixed by >>): In file included from kernel/sched/core.c:13: In file included from kernel/sched/sched.h:50: In file included from include/linux/init_task.h:18: In file included from include/net/net_namespace.h:39: >> include/linux/skbuff.h:3737:50: error: use of undeclared identifier 'NETIF_F_FRAGLIST' ((skb_has_frag_list(skb) && !(features & NETIF_F_FRAGLIST)) || ^ >> include/linux/skbuff.h:3738:46: error: use of undeclared identifier 'NETIF_F_SG' (skb_shinfo(skb)->nr_frags && !(features & NETIF_F_SG))); ^ kernel/sched/core.c:3416:6: warning: no previous prototype for function 'sched_set_stop_task' [-Wmissing-prototypes] void sched_set_stop_task(int cpu, struct task_struct *stop) ^ kernel/sched/core.c:3416:1: note: declare 'static' if the function is not intended to be used outside of this translation unit void sched_set_stop_task(int cpu, struct task_struct *stop) ^ static 1 warning and 2 errors generated. -- In file included from kernel/sched/loadavg.c:9: In file included from kernel/sched/sched.h:50: In file included from include/linux/init_task.h:18: In file included from include/net/net_namespace.h:39: >> include/linux/skbuff.h:3737:50: error: use of undeclared identifier 'NETIF_F_FRAGLIST' ((skb_has_frag_list(skb) && !(features & NETIF_F_FRAGLIST)) || ^ >> include/linux/skbuff.h:3738:46: error: use of undeclared identifier 'NETIF_F_SG' (skb_shinfo(skb)->nr_frags && !(features & NETIF_F_SG))); ^ 2 errors generated. -- In file included from kernel/sched/fair.c:23: In file included from kernel/sched/sched.h:50: In file included from include/linux/init_task.h:18: In file included from include/net/net_namespace.h:39: >> include/linux/skbuff.h:3737:50: error: use of undeclared identifier 'NETIF_F_FRAGLIST' ((skb_has_frag_list(skb) && !(features & NETIF_F_FRAGLIST)) || ^ >> include/linux/skbuff.h:3738:46: error: use of undeclared identifier 'NETIF_F_SG' (skb_shinfo(skb)->nr_frags && !(features & NETIF_F_SG))); ^ kernel/sched/fair.c:10996:6: warning: no previous prototype for function 'task_vruntime_update' [-Wmissing-prototypes] void task_vruntime_update(struct rq *rq, struct task_struct *p, bool in_fi) ^ kernel/sched/fair.c:10996:1: note: declare 'static' if the function is not intended to be used outside of this translation unit void task_vruntime_update(struct rq *rq, struct task_struct *p, bool in_fi) ^ static 1 warning and 2 errors generated. -- In file included from kernel/sched/rt.c:6: In file included from kernel/sched/sched.h:50: In file included from include/linux/init_task.h:18: In file included from include/net/net_namespace.h:39: >> include/linux/skbuff.h:3737:50: error: use of undeclared identifier 'NETIF_F_FRAGLIST' ((skb_has_frag_list(skb) && !(features & NETIF_F_FRAGLIST)) || ^ >> include/linux/skbuff.h:3738:46: error: use of undeclared identifier 'NETIF_F_SG' (skb_shinfo(skb)->nr_frags && !(features & NETIF_F_SG))); ^ kernel/sched/rt.c:669:6: warning: no previous prototype for function 'sched_rt_bandwidth_account' [-Wmissing-prototypes] bool sched_rt_bandwidth_account(struct rt_rq *rt_rq) ^ kernel/sched/rt.c:669:1: note: declare 'static' if the function is not intended to be used outside of this translation unit bool sched_rt_bandwidth_account(struct rt_rq *rt_rq) ^ static 1 warning and 2 errors generated. -- In file included from kernel/sched/topology.c:5: In file included from kernel/sched/sched.h:50: In file included from include/linux/init_task.h:18: In file included from include/net/net_namespace.h:39: >> include/linux/skbuff.h:3737:50: error: use of undeclared identifier 'NETIF_F_FRAGLIST' ((skb_has_frag_list(skb) && !(features & NETIF_F_FRAGLIST)) || ^ >> include/linux/skbuff.h:3738:46: error: use of undeclared identifier 'NETIF_F_SG' (skb_shinfo(skb)->nr_frags && !(features & NETIF_F_SG))); ^ kernel/sched/topology.c:691:6: warning: variable 'numa_distance' set but not used [-Wunused-but-set-variable] int numa_distance = 0; ^ 1 warning and 2 errors generated. -- In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:22: In file included from include/linux/ip.h:16: >> include/linux/skbuff.h:3737:50: error: use of undeclared identifier 'NETIF_F_FRAGLIST' ((skb_has_frag_list(skb) && !(features & NETIF_F_FRAGLIST)) || ^ >> include/linux/skbuff.h:3738:46: error: use of undeclared identifier 'NETIF_F_SG' (skb_shinfo(skb)->nr_frags && !(features & NETIF_F_SG))); ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5605:30: error: used type 'netdev_features_t' where arithmetic or pointer type is required netdev_features_t feature = (netdev_features_t)gso_type << NETIF_F_GSO_SHIFT; ^ ~~~~~~~~ >> include/linux/netdevice.h:5608:35: error: use of undeclared identifier 'NETIF_F_TSO' BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT)); ^ >> include/linux/netdevice.h:5609:35: error: use of undeclared identifier 'NETIF_F_GSO_ROBUST' BUILD_BUG_ON(SKB_GSO_DODGY != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT)); ^ >> include/linux/netdevice.h:5610:35: error: use of undeclared identifier 'NETIF_F_TSO_ECN'; did you mean 'NETIF_F_TSO_BIT'? BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT)); ^~~~~~~~~~~~~~~ NETIF_F_TSO_BIT include/linux/build_bug.h:50:19: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:58: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:322:22: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:310:23: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:302:9: note: expanded from macro '__compiletime_assert' if (!(condition)) \ ^ include/linux/netdev_features.h:32:2: note: 'NETIF_F_TSO_BIT' declared here NETIF_F_TSO_BIT /* ... TCPv4 segmentation */ ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5611:39: error: use of undeclared identifier 'NETIF_F_TSO_MANGLEID'; did you mean 'NETIF_F_TSO_MANGLEID_BIT'? BUILD_BUG_ON(SKB_GSO_TCP_FIXEDID != (NETIF_F_TSO_MANGLEID >> NETIF_F_GSO_SHIFT)); ^~~~~~~~~~~~~~~~~~~~ NETIF_F_TSO_MANGLEID_BIT include/linux/build_bug.h:50:19: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:58: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:322:22: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:310:23: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:302:9: note: expanded from macro '__compiletime_assert' if (!(condition)) \ ^ include/linux/netdev_features.h:36:2: note: 'NETIF_F_TSO_MANGLEID_BIT' declared here NETIF_F_TSO_MANGLEID_BIT, /* ... IPV4 ID mangling allowed */ ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5612:35: error: use of undeclared identifier 'NETIF_F_TSO6' BUILD_BUG_ON(SKB_GSO_TCPV6 != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT)); ^ >> include/linux/netdevice.h:5613:35: error: use of undeclared identifier 'NETIF_F_FSO' BUILD_BUG_ON(SKB_GSO_FCOE != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT)); ^ >> include/linux/netdevice.h:5614:35: error: use of undeclared identifier 'NETIF_F_GSO_GRE'; did you mean 'NETIF_F_GSO_BIT'? BUILD_BUG_ON(SKB_GSO_GRE != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT)); ^~~~~~~~~~~~~~~ NETIF_F_GSO_BIT include/linux/build_bug.h:50:19: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:58: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:322:22: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:310:23: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:302:9: note: expanded from macro '__compiletime_assert' if (!(condition)) \ ^ include/linux/netdev_features.h:24:2: note: 'NETIF_F_GSO_BIT' declared here NETIF_F_GSO_BIT, /* Enable software GSO. */ ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5615:36: error: use of undeclared identifier 'NETIF_F_GSO_GRE_CSUM' BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO_SHIFT)); ^ >> include/linux/netdevice.h:5616:35: error: use of undeclared identifier 'NETIF_F_GSO_IPXIP4'; did you mean 'NETIF_F_GSO_IPXIP4_BIT'? BUILD_BUG_ON(SKB_GSO_IPXIP4 != (NETIF_F_GSO_IPXIP4 >> NETIF_F_GSO_SHIFT)); ^~~~~~~~~~~~~~~~~~ NETIF_F_GSO_IPXIP4_BIT include/linux/build_bug.h:50:19: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:58: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:322:22: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:310:23: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:302:9: note: expanded from macro '__compiletime_assert' if (!(condition)) \ ^ include/linux/netdev_features.h:41:2: note: 'NETIF_F_GSO_IPXIP4_BIT' declared here NETIF_F_GSO_IPXIP4_BIT, /* ... IP4 or IP6 over IP4 with TSO */ ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5617:35: error: use of undeclared identifier 'NETIF_F_GSO_IPXIP6'; did you mean 'NETIF_F_GSO_IPXIP6_BIT'? BUILD_BUG_ON(SKB_GSO_IPXIP6 != (NETIF_F_GSO_IPXIP6 >> NETIF_F_GSO_SHIFT)); ^~~~~~~~~~~~~~~~~~ NETIF_F_GSO_IPXIP6_BIT include/linux/build_bug.h:50:19: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:58: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:322:22: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:310:23: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:302:9: note: expanded from macro '__compiletime_assert' if (!(condition)) \ ^ include/linux/netdev_features.h:42:2: note: 'NETIF_F_GSO_IPXIP6_BIT' declared here NETIF_F_GSO_IPXIP6_BIT, /* ... IP4 or IP6 over IP6 with TSO */ ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5618:38: error: use of undeclared identifier 'NETIF_F_GSO_UDP_TUNNEL'; did you mean 'NETIF_F_GSO_UDP_TUNNEL_BIT'? BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT)); ^~~~~~~~~~~~~~~~~~~~~~ NETIF_F_GSO_UDP_TUNNEL_BIT include/linux/build_bug.h:50:19: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:58: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:322:22: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:310:23: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:302:9: note: expanded from macro '__compiletime_assert' if (!(condition)) \ ^ include/linux/netdev_features.h:43:2: note: 'NETIF_F_GSO_UDP_TUNNEL_BIT' declared here NETIF_F_GSO_UDP_TUNNEL_BIT, /* ... UDP TUNNEL with TSO */ ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5619:43: error: use of undeclared identifier 'NETIF_F_GSO_UDP_TUNNEL_CSUM' BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO_SHIFT)); ^ >> include/linux/netdevice.h:5620:35: error: use of undeclared identifier 'NETIF_F_GSO_PARTIAL'; did you mean 'NETIF_F_GSO_PARTIAL_BIT'? BUILD_BUG_ON(SKB_GSO_PARTIAL != (NETIF_F_GSO_PARTIAL >> NETIF_F_GSO_SHIFT)); ^~~~~~~~~~~~~~~~~~~ NETIF_F_GSO_PARTIAL_BIT include/linux/build_bug.h:50:19: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:58: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:322:22: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:310:23: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:302:9: note: expanded from macro '__compiletime_assert' if (!(condition)) \ ^ include/linux/netdev_features.h:45:2: note: 'NETIF_F_GSO_PARTIAL_BIT' declared here NETIF_F_GSO_PARTIAL_BIT, /* ... Only segment inner-most L4 ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5621:42: error: use of undeclared identifier 'NETIF_F_GSO_TUNNEL_REMCSUM'; did you mean 'NETIF_F_GSO_TUNNEL_REMCSUM_BIT'? BUILD_BUG_ON(SKB_GSO_TUNNEL_REMCSUM != (NETIF_F_GSO_TUNNEL_REMCSUM >> NETIF_F_GSO_SHIFT)); ^~~~~~~~~~~~~~~~~~~~~~~~~~ NETIF_F_GSO_TUNNEL_REMCSUM_BIT include/linux/build_bug.h:50:19: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:58: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:322:22: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:310:23: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:302:9: note: expanded from macro '__compiletime_assert' if (!(condition)) \ ^ include/linux/netdev_features.h:49:2: note: 'NETIF_F_GSO_TUNNEL_REMCSUM_BIT' declared here NETIF_F_GSO_TUNNEL_REMCSUM_BIT, /* ... TUNNEL with TSO & REMCSUM */ ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5622:35: error: use of undeclared identifier 'NETIF_F_GSO_SCTP'; did you mean 'NETIF_F_GSO_BIT'? BUILD_BUG_ON(SKB_GSO_SCTP != (NETIF_F_GSO_SCTP >> NETIF_F_GSO_SHIFT)); ^~~~~~~~~~~~~~~~ NETIF_F_GSO_BIT include/linux/build_bug.h:50:19: note: expanded from macro 'BUILD_BUG_ON' BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) ^ include/linux/build_bug.h:39:58: note: expanded from macro 'BUILD_BUG_ON_MSG' #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) ^ include/linux/compiler_types.h:322:22: note: expanded from macro 'compiletime_assert' _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) ^ include/linux/compiler_types.h:310:23: note: expanded from macro '_compiletime_assert' __compiletime_assert(condition, msg, prefix, suffix) ^ include/linux/compiler_types.h:302:9: note: expanded from macro '__compiletime_assert' if (!(condition)) \ ^ include/linux/netdev_features.h:24:2: note: 'NETIF_F_GSO_BIT' declared here NETIF_F_GSO_BIT, /* Enable software GSO. */ ^ In file included from net/core/sock.c:91: In file included from include/linux/errqueue.h:6: In file included from include/net/ip.h:29: In file included from include/net/inet_sock.h:19: >> include/linux/netdevice.h:5623:31: error: use of undeclared identifier 'NETIF_F_GSO_ESP' BUILD_BUG_ON(SKB_GSO_ESP != (NETIF_F_GSO_ESP >> NETIF_F_GSO_SHIFT)); ^ fatal error: too many errors emitted, stopping now [-ferror-limit=] 20 errors generated. .. vim +/NETIF_F_FRAGLIST +3737 include/linux/skbuff.h 690e36e726d00d David S. Miller 2014-08-23 3722 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3723 /** 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3724 * skb_needs_linearize - check if we need to linearize a given skb 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3725 * depending on the given device features. 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3726 * @skb: socket buffer to check 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3727 * @features: net device features 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3728 * 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3729 * Returns true if either: 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3730 * 1. skb has frag_list and the device doesn't support FRAGLIST, or 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3731 * 2. skb is fragmented and the device does not support SG. 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3732 */ 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3733 static inline bool skb_needs_linearize(struct sk_buff *skb, 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3734 netdev_features_t features) 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3735 { 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3736 return skb_is_nonlinear(skb) && 4262e5ccbbb517 Daniel Borkmann 2013-12-06 @3737 ((skb_has_frag_list(skb) && !(features & NETIF_F_FRAGLIST)) || 4262e5ccbbb517 Daniel Borkmann 2013-12-06 @3738 (skb_shinfo(skb)->nr_frags && !(features & NETIF_F_SG))); 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3739 } 4262e5ccbbb517 Daniel Borkmann 2013-12-06 3740 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org --2oS5YaxWCcQjTEyO Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICJm4h2EAAy5jb25maWcAjDzLdtu4kvv7FTrpTd9FJ5bjuHNmjhcgCVJokQQbIGXJGx7F lrs914+M7PR0/n6qAD4KIKhOFklUVXjXGwX+9K+fFuzb28vT/u3hdv/4+H3xx+H5cNy/He4W 9w+Ph/9eJHJRynrBE1G/B+L84fnb3x/+/nzZXl4sPr1ffnp/9svx9tfF+nB8Pjwu4pfn+4c/ vkEHDy/P//rpX7EsU5G1cdxuuNJClm3Nt/XVu9vH/fMfi78Ox1egWywv3p+9P1v8/MfD2399 +AB/Pz0cjy/HD4+Pfz21X48v/3O4fVvcHu5vz5b3+8tP+18PX25vl2e3X+4/3n788uX8/NfP +8v98vz87rC///e7ftRsHPbqjExF6DbOWZldfR+A+HOgXV6cwZ8exzQ2yPNNMdIDLEycJ9MR AWY6SMb2OaFzO4Dpxaxsc1GuyfRGYKtrVovYwa1gOkwXbSZrOYtoZVNXTT3iaylz3eqmqqSq W8VzFWwrShiWT1ClbCslU5HzNi1bVtektVC/t9dSkQVEjciTWhS8rVkETTQMSWayUpzBJpWp hL+ARGNT4J6fFpnhxsfF6+Ht29eRn0Qp6paXm5Yp2ExRiPrq4/kwQ1lUOK+aaxzkp0UHv+ZK SbV4eF08v7xhj32DhlWiXcEUuOob9eckY5b3B/XunbOcVrO8JsAV2/B2zVXJ8za7EdXYC8VE gDkPo/KbgoUx25u5FnIOcRFG3Og6oXtC5ks3xsebWZ8iwLmfwm9vTreWgWNx1uI3wYUE2iQ8 ZU1eGwYhZ9ODV1LXJSv41bufn1+eD6Oq0NesoqPond6IKg6MUEkttm3xe8Mb7nAXq+NVa8CB VrGSWrcFL6TaobSweEUbN5rnIgpuEWtA8wZ6NKfKFIxpKGDCwKp5LzcggovXb19ev7++HZ5G ucl4yZWIjYSC+EZErilKr+R1GMPTlMe1wKHTtC2spHp0FS8TURo1EO6kEJkCJQYiRXhUJYAC fXQNqkhDD646SWTBROnCtChCRO1KcIUbs5sZndUKThA2C4S7lipMhZNQGzPLtpAJd0dKpYp5 0ikuQS2JrpjSvFv7cIi054RHTZZq97APz3eLl3vv2EbrJOO1lg2MadkskWREwwOUxPD+91Dj DctFwmre5kzXbbyL8wADGDW9GfnJQ5v++IaXtT6JbCMlWRIzqk5DZAWcGEt+a4J0hdRtU+GU PXVmpTCuGjNdpY3R8IzOSRojJfXDE3ggIUEBE7tuZclBEsi8wOitbtC+FIZ3h+MFYAUTlokI aQzbSiS5oy8sNG3yPKQuZIl+UlsrFq8tfw0NfZxlxqDuMGOEdIfIVsjh3caY3jsOnGzJYPOq 1DsDDqD2N8prhhWvWVkPCnckMRsOP0O7jVQThpv03gFAcq/ZTrdUffSoflgf15SVEpsRnaYu PtcF3QR3muN+VorzoqphX8vwhvcEG5k3Zc3ULmRALA3h065RLKHNBOyoyZ402YEVo16gjleg j2KpeL/VwPcf6v3rfxZvcKKLPSzs9W3/9rrY396+fHt+e3j+Y9z/jQAPEAWFxWYSHscZYXDR gXUFOkFBph2h+jPqJdzRQBfpBM1TzMFmAmkdJEJpRmdYh09Ci6CG/YFtIaIGqxFa5sYM0O7M Dqu4WeiA6oAzagE3PTUHCD9avgW1QY5cOxSmIw+EazZNOxUZQE1ATcJDcNQffDon2NI8H3Uc wZQcWEzzLI5yQbU14lJWQnxxdXkxBbY5Z+nV8nLcVovT9VQ/OSSRBG8twGhmLjKO8HhmF9Wa kKKIqFi7B+Y685Eoz8luirX9zxRiGJOCbeCgr57GoAE7BY22Eml9tfyVwpGjCral+PORTURZ Q4DHUu738dGjEWXCt546bkrdBVdWF6CN7ZWBvv3zcPft8XBc3B/2b9+Oh1erIzrvE8LfojI7 GJSZQGtH43cxJASFTcHaiEEwHTtO0WgXInRfYHZNWTAYMY/aNG/0ahJewiqX55+9HoZxfGyc KdlUxB+pWMatPuXEvwP3O868n73n78DW8A/VW1G+7sYI2WqDsLs+dpQyodogJk7BN2Jlci2S 2gkCQH2SBvMjVSLRjkNgwSqZCcE6fArq5IaH4l9gSs2pO4csjsN0GH+jwY5uRMwnYKBGbR2Y G6i5dH5B1rXw2xRCx6fWY/zoQKdaxuuBhtUkpMbID/xzMCsjrEG2Jb+NeSqd/YU4ECChvAGE CB4tbloZtkglr+dQcN7xupLA1uiVQUwSCiGtWLOmlmZtxGrsNLBUwsHMQEBDWc3HtBuSelA8 ZyREQh6HczXRg6LRF/5mBfRjgwiMqkeWTSapgxHjpToA4mY4AEATGwYvHYFAyEW48y6R0U9e SvSfXI0NqkSC/1SIG44+smFCqQpQTo4j7pNp+E9gTLARUlUrVoIiU6Wzx3GdgymPuXHWrAny w5VYV2uYAXgSOIUR63sABbinAvmKDJDxGgPtqYdsj3cCTmGSCY3sbCA0+PqOKXHUXFCeeJ72 juXI5u56Aq0iBlEwRjdkXk1NjZb5CQJDNqOShn7MwoisZHmahP0/XE8a0pMmskypHKw8hc5E KOEkZNsoz/dlyUbASrpNDmkB6DpiSgl6Zmuk3RV6CmmdoxqhEbiZsCHIpI5bM1CYDUWZxeyL lztSJqwJ7oUxnGhRx2nCYsq4P9J+mLggGkVpTlI3RtH2sGFY6I4nSdBOWZaHWbV+nqCKl2cX vVPSXRlUh+P9y/Fp/3x7WPC/Ds/gjDPwO2J0xyEUHR1rt8dhInZ6Bglb0W4Kk9kJOjI/OOIQ 0RR2uN6TcIbVeRNNbRCJ0ouKgb+j1kG0zlkU0vHQqTuIDGcFsT0cqQI3pwtqg70BEZp99Ndb BVpBEtXjYjEBByGFIzRNmoI7aXypQLbMbAD6sxVTtWCuXqp5YYwv3nKIVMR9uo9Eynh5EI4k jQY15tBJTbh3AT3x5UVEkwRbczPl/Ka2TNeqiY2aTngsEyqz9n6kNSaivnp3eLy/vPjl78+X v1xeDGli9KnBnPaeKFlyzeK1DT4muKIg8mzksUDnV5UYddgM2NX551MEbEuuN1yCns/6jmb6 ccigOwjHOrohNalZm1DzbDtgu96CtWlC4p4hRcdyESnMKSauPzEoHmQR1FvbAA5YAOSqrTJg B7JjZkRwPK3naJMKEM8RTw5D0R5lNBF0pTCnuWroxZlDZxg5SGbnIyKuSpvxBYupRURtqCEp waWvhLxanp1fOAjdaMx6z7UzoY/ZMZa3qwYMeh4REszfG0KfjVtNtbIbAzUmf090awo2njOV 72JMWXMi6VVmA8MctFmurz55sZZmJbcMjKfAYyvlRkVXx5fbw+vry3Hx9v2rTZeQALLnfTpJ nHjKWd0obv1tF7U9Z5XJWgyKAKFFZbLmAVWQyTxJhXbjJF6DoyBmUnDYn2U58MtUKLmKFHxb w3khc0xcMkSHhkU4K8YWXRQ066nLAk41BdcZs9XCjURXO2BKcCzA3cwa58YRNoJhJm0Kabfb PAA1JigA15UoTerfXdlqgyKbR3DaoJtjR6Nveen8aKuNswEA+bQ8z0KGy1J7rGBgK3pvPoCm lBplvot+/FGtiffvTNw+QxeIMI63vfaypGowGw/Mn9edy9nv3sY58mEzTyQtfdI+7zJ6kLEq 7TSC0y/Wn8Pwaib8LdBzC1/GguGSIWd8UNbUs0RuMGxZgh0EpgCm7dJNl5QkX87jah27/YEX uY1XmWeA8R5n40LAVImiKYykpqwQ+Y7kDpHAHDkEVoWmhQXs47nRLi1g3A43xXZO73SZZAzt eM5jms6A0UGhmm1wAo8eAfIe9u46/GqXuYlhDx+D98gaNR3xZsXkll5oripu2Ux5MA4hIZpX VZO9TgpBpwsWHeQpdPVkLJ9G3w9sX8QzdDXCSLxy/bScIDvvkpxOhyEQq+90Qf0hAyomNxRF jHGndM/OVFm0nWGg3CkDQMWVxEAJQ/VIyTVIv4n+8fZ4Yldc9WxNGnH+n16eH95ejvYuZPAz ZyjoJJaXE6eT6wos8OWFP4f+JrU7SBHkF7vaKse/ODVG4vP66okctIiBmUFeZ00fyMspsyhC 8RriPhnnwF1SIhSIS5tF6DlNNjeumC1G0rWIZ1JejZuSdBwZY/LBTwHOY1OXaUT3HOjhjSj3 FRV4Q+8IsHVeLdI4SnPTMKnONapUW5k27nye8wzYsrPdeHfe8Kuzv+8O+7sz8oduWIXzxWbx bpIj9fD0VM1uYgoQ/HOpMTJXTTXDKUWtaEYbfqH/Jmpxw2fh3Q4PO3k2Q4Z7jjbYyHhPvHQW wPxzgJBbg4PZNqWxEsnkEGzYOcN1unDLbhDWFDO1SL3BysnBoruKDvua72a8g6FRrbeGT/D2 94dJZ4XVpcOsrHvUOiPxDk+F8wPkpolcSCG2NPhe3bTLszO6NQA5/3QWnDigPp7NoqCfs8Aq VjcQxpy52nml8KqXjrrmWx6qaTBwDN98ucWAwiKrRmWYMdhN+sO8XrBGiulVmzTUM6xWOy3Q OoCmAaf47O+lK3UQWGJeolMgY4hgmA4zupg2C7lrfb8QvmYl9HvudNvdr/eMBoGtpKWTK1lX eZO5/hRaIfQCC4o+89NoYVynMzxb4SzJJ9nKMt8Fz9yn9KsV+u0uEgyicN5E73dQUjsHDC5S 2IOknqaaTaCeiw2v8F6PJmtORY4ThmFJ0vY2xlHgqwqPAJMYNqbFwxjMhTXnL/93OC7AWO// ODwdnt/MSCyuxOLlK9Yg0zjVBunEJemi9u5mzEm8dSi9FpXJlwaraGzCgA8RlWMjST4hxIAQ AuWcU1bvIF1oNAYhhVEvBhcudSjaa7bmJtgLjuT1NndxBqg4J1mR69/B+F2j+UhTEQs+lvUQ 1QWBRTbaX8dC95kKPA2Cm/zqGdZIsQZvUK4bP+1RiGxVdzWP2KSiuSgD6ZKOdsbol3BNUnEk GgNaswNZ8C7U9lXFqp0oFYNKqySUarXrqJxiKNNTd8ZuJ4pvWrnhSomEDzmjuV5BX3Ylg17f LJ50HLEafJVQ1ZFFN3VNqzoMcAOTkNQdsetkIa41qJolXheJDXkpyAR2igMLaX/eYzwWm3Oa RQvnFqvrtopB4URzbTx4UFF7o7AsA5fH5Laf3HWuwBVnuQcd0j9d+buHjhsNMXibaFCXBj0q 0lHd2V1El6ypMsUSf5WncF6+xw4qIcwEra0mDNFvgNWds/we+Wfke3JkaQWvVzJ41WRYLAvI m+JJg/WyeMlwjT6mb7soMfyvHjcVf4GzHzdK1Dt/8aM+YBUXc/C2dKPlARGutzabXNWheoV+ s+H/qaYiU6GzICvgo7C2ryt9+fni1zOX0A8O/Pi/Y9RiKJ8ENl6kx8P/fjs8335fvN7uH50y vl7m3HSDkcJMbswjjdYt56Bov+RrQKKQ+skRg+jLKbE1uVyfzZhMG6GyxsTfTApl0gDvOk0F xz/Oxzi0TS2C1bV02XNVAQ7Nj8zTn18IL8uEw1DJyN/eEZRd1fmGz5AM66I8ce/zxOLu+PCX c3k6Bi2Vp3QN78UmOdgxj5vy7rQ54uaiuIrzBKyvzXcpUXqxUHVhs6LgJVw92Vm//rk/Hu6m PprbHSr6J6d2M8D+wy6Iu8eDKwx+zXUPMzuZg9c5Vw41UhW8bGa7qLmcZfaBqM8yh+OzDtnn pOdqVu3iSE2SOcrZFv/sFdty7G+vPWDxcxWLxeHt9v2/yTMrzcBnILahuyTEtBx19mf6sWM8 PO+P3xf86dvjvj/scRmY0P2nxNj2I6kisheZ/m+TDWwuL2w4B2dWO9ObTMExFGt6Q9FDMJ8Y r6avuCyGFpdQeIu5Saf0ccBOilIQWBQ0F4oQZoozJrX2hlj7Jg6hw/WqTeZjFZLb4yb1x+iv AxKh6h1Wmppa2S6b4pL62+0sNtpVjHp3AxIfBzr3Kgjcpvi8TtqrEO+pxtCywsa1SJ1qGrxX aeBkb7xHQ/bgxtwCtJ++8XPQRmxmbopYQdSymbBbvG7Pq5l9kIWO3Wb7aUmYFS9XV2zZlsKH nX+69KF1xcB8XHkPH/fH2z8f3g63GDn/cnf4CiyN8jxRnDZ54hX1mGSLC+sdQidb3zMEam9y hb/2r5h/awpQyiyisZ59j2oScJiUTf1Xlx3eZCJ6fGD3ZFX7o9lHJkPs2ZRGuLEGMkbXfZqI NKXcIH5t5Bb1rvHG2Ovc1G4CvFFlgOPM0AI2DlMPgdqEyc5YaGAcg5hbXNcNJjfSUNlg2pQ2 vWm4Grj3N5vu9Misf9u7mqYIBXVUzjI9rUYZ3w0ayhVE2x4SFTxGFCJrJFX+PZdoYAJj3ezz t0ACELRxjTmjrmJ0SgBeaBeSzCC7q4eC+QrYztw+GLbFPO31StTcfZIwVF3oIZVnHn/ZFkG6 UtryIH88XWB2o3sD7B8g+PEg9ZgnwvKJjjE76+jQOQV17tniE+bZhqvrNoK12uJgD2dSxgSt zXQ8oh/gc1JX57KSnQHEbOi8mYprWx1iWoQ6CYzf1+Wpbovc9O54pCHVEsLSEsiODJUyxO8r 3uVsTD4viMZ3ISGSjvWsKNkHGN1Ntj+ZTgN1nIc5S4+ia2fvNGdwiWycC69xnRDoosU9gepK phwNazEn3wibzc+BU7yuJ2U/VG8TTKggml55wA//mwpuEvDHCUC6nYtx5jYe09wAnEltz/fV 78e1QEzHk6ZIx2fcePoE8xQab5VMbx7d/Ks4x9RMH8b5wi5RmBrf77Tgwgf3+r00V3pgPLHo LMCts3SBoayQAB5LbP38rKlwM0iYDDo4KszfMq2t2zlZR9Lf+/IYC0aJ/MqkwbwwGnisRUcF ENg+vhX47tO+DA8cBA6NOCCR16VPMhgfM0J/exRaglOa6TsrOIegVXRbjdWegX5JqeZcJ5Qk 0FWHNuR4/+VP03J99xjccSe6gM81RF13H88jYUtUQtuCPDFs6iCjI/Skdhqv69Z2bihMNFE1 QzBTG2CciBpclbr/WoS6JrexJ1B+c8t7weYh1LiiCrgUQtvuetL1HAZ3FTwgx8McVRs+YSKl 56FrHVrYD457rHaV7yAQ13seM/nAizXbcw+NR2mfexDjqvWuOh9UiikhD0ucKb/wQ82BAC9V SymSNl8mw3NBGyTFcvPLl/3r4W7xH1va//X4cv/w2Bf09I4rkHXHfWojDVn/URvWvUTpa89P jORsHH5zCAMsUQZr1/8hnBv4HfgLn8dQ0TUPQDS+biAFHJYJtcj6unVfbfoA+7UA4DDmJPg7 ZFMiIlR2EnKBZ33jfloq7r/65LDgOOvAFLq1zKSRCRGbSakREgy+f4Dm/PziR6g+Xf4A1cfP oQdrLo2TIyAoYMLV1bvXP/dA8G4yAMqHwihh9usDPuHM0zyfzDzCm+1k5kM7HRkK9TU+1dTo 2AwPLFtRGPF3lmmCXSwhgkV+eP3y8Pzh6eUOxOjL4Z3HtPbpu38RHOXONWP/YDHS2eTuguCc y8LxkWPNM7xROoFq6+XZFH0jS/dqDBHXUSilYZvYymW/IwsdeiM4jaXjFY0dEGqVdK/nvbc0 QYI27YoSphWQ++PbA+qbRf39Ky3kNw95bEyabPBCxLsDlBBDDjThyzOx/QcKqdMwRd9DITI2 UjgTqJkSJxsXLA43LXQi9cmmeVKEmyJi/pmXzk7PCJwTRffEibCame3s8GsGGj3cFCvGTjXF z1ddfnba9s5cV/XjdttfG3ic4UjexEAj2xW/mwiHZpgRXBWe2LYrmePn1ZxXyvZLVXL8vgDh RehYSFuVloA73bko44GO6PUu4uGMb08Rpb+7+P5rS87QgxQMH3mx2RLnswLug3KmyyVJKZad EOLTC2NKJxHGWBNTS0xKqYJ8Z8tYfNvYBik0U6OuNfh5M0izwzO4wds0nyZLQu9C5jF+Y3Ud bjqBD05ViTMCLyBnVYUmgiWJMSveLenoePdvU9uIp/gP5o7+n7MvW24cVxJ9v1+huA8zZyKm 54ikRFFzox8okpLY5lYEtbheGGqXustx7HKF7Tqn6+9vJsAFS4LyzEN3WZlJrAkgkchFDcAl 0QoDt1MNhct9Hg26OIslf10ffrxffn+68piWM27d/a48RG3SYps3KIuSnNShWVSnFbnVCzyG LJDebUu0e+iMuTqWszWFtyW/Pr+8/pzl47OdacNGmj33yMFmOg+LQ0hhKOLkDMetfKsbUcfO +k430TYodOUmRnfZHdTAGtjiIZqONp2dhXJH1T1SGF/fgHfNsqLH6FDqjYduAYxJqXpa6zjq BCIsFuVhy+AKXTViO0UnigXVho4Mfc0adRPhW3CknwZcYVMnuLPQzklEwD25vgYbbZJE/A2g 1e5taDnLV3Hb6L63wlWqVJ+MUf0qKZ7H5zRGGYX3U8RHUISGi+tfF/P14Hc0rdUidVkiYJhc OUmWC19/2xVRPBPgWKmvSyYkypJQmMPLdW5rGE8kpE0GSE+JzxUa5w47yufNQXqj/Oxt4VCV zZA+M9P5vb8D90986CHaP22NTYZxT+pa1WxrgQQFCN998GVJ0hnFvZO4qSodnYC5C5k4HRXF 2njL5y7EhGoRkSgn83cpRSvUQ02IbDEgIipwlYfCA7A9tfpjpORjGsbcSo1PL1oXbCeVMNh6 rrqUd907ZGLtIYAlUZ00Yifmm358eb/Mwgc0lp7lqj9SPzdhrgvT3Wli+7bH2w+UvjlFYtpS AIxHGoa7HFONsjGEDVyOlMdXdrcR3rS9DoA3vbi+/+vl9R9oimScYbCD3SUKY+HvNk6Bqwbm BmFKUqzhLzh95QjMWwEsSyVgAodhSZQRXqbY7MFPwoVXQTcltRuct4q7MPxCdWSnUZGhYbZT 4tlwIMozlkKFBccWBaNn7St22KBJRRrRJv+cRmzhFtcwXgjpraW0eK91Aa7zGiSt+AuV1EDk iruEsufsi4B+RXI5ccWjNCkxpySgYIVxgxFMOor1lQiTg7FFiUoB3V9fuTmOLBim+H62gY0q TYYNQSu1yrog1VoMKFFWRxM2lL/xQATy7qaUBZEBE2UhY2msFV0VpPMmjGtapZVkDMshsACB cfPDWV2YUE5zKIok0+eGf0FeEgtY8uVdqi/xtDo2qVrrIbaVvi0PtO+fwI3NopgOp1ZhOg5Q mK6HDGtMqr/Hcf6ir4CiP5b3UY4duiUDTQ5soYoerBaPY6NvOSpFHZ5sm9JQG0wpnL2l4i2F VcKfu4GhqV2tp4kOG1lR30tSPf7X//vw4/fHh/8rf5fHS6bEOKyOvjK+8LtbQ3gtpu9GnEhE 0MK9BY4r2mcae+rDZFsGgXvQ6pPryzM/9aG2wwj4sFXJLc3TytdAaRaq0++LnYviDN+EYhHK guEQJlux95DWV0KrIbSI4dLYog9+c18lGpKsC1az3idj41LqPWxQn6rtZ/gZn1pyI8PPkp3f ZqeuCT9N3D4PIw1eV5ntk7QMc6o8lDY6s4/xolXZ1jNQo+UgilF5WFOvirieqqbqdtqtsp76 r+EOwx8y4QjIK/rKBKSDpYUOktWjHW5TpzFIwONXnZ1z9PJ6RWEILvvv11cjPYbcsq5saA4K WFNNMmSwEdPJbhRKhFnoWjpBENbVRMk8Hq9yNmh4ERh/giArd1PokinBIAsMPlcU/GpBjcmW h0pl9ywrd9p3YjFMDuRZXzAGatR68uk6c93N2+zh5fn3x2/XL7PnF1QfvtFzeUYLttrUwPel vF9e/7y+S6Kx8mkT1rukEZ7h7JBTgyZR9ez+bGlIRxezyCJrGKT7bLrKPfZtmgTvhsKpZZIs S+Jb7YbptW0IBq0+5pPExVYrepLWyt0jEcrgaAN7o0NA9OE2ovXomZb8SXI07Pxgl2CjzRmb 7hHQwPmOdg9Vv6/1HPx8eX/4erVxcM5zYqAKRz3bCCKMAUs3QuBFQNdpkjLvLP8naGRHQAIf RxG5+40EyfF2S3CRTZaSRMVkAUIUsuPxpVikvZmk0oV1ncAqGJO0PE7MZIWZ20y3O0uKXbO/ 0SresY81Kld9YEkKm5RgUHIhCm2lp5tXbK0h6QlqOM4+Vn3/bDNVmKkBmKDd3zNg1hudqe4a XJof7c2nQ9lQekqCdNwGJ2iSMMtvtLBO0KnsY3WyqKluDKFQMXywuF5fMrmWcV+UdZ4ESbfJ TrcMz8mPzsPB0wKA9Z5iU+KmonJg5CAA4qgoyTiAC/A2at0nVwBBeBLmiY7bPfNWRzZ7f718 e/v+8vqO1lPvLw8vT7Onl8uX2e+Xp8u3B1QWvv34jnjJBY0XhwZyZSuueFrbBAru4NYGCopw 3+kVyO8BdfN727fIdYaIx/v71r8uKz5v/NOaUgIK1Kmu5fsdgrJIh5w4SCt0S7sjCmR5pHai rvyNWQPCjIbEex3C9mY7cot2DMmTWC+h+KRD4JbGekmDDyTbK2OpNWDktkD6Jp/4JhffiDQK Cotevn9/enzgC2b29fr0nX/bof974iY3XjvEDoNrRoqCh9cRLsQJuLzlbdsYQ9AB2H6/Ue9k AtYVNALrBN2DtIqhv4BKK1MzgPBOQNvTcEVKkRF1Ndxy5Zkf8E1DGVoKiuFLBdrLzrwLZqXF LkvMyrqPoJnW2noJtsnMz+vwZP2ujzigNwUmglQOC5Tom7VQoJD70luhTPBVx3j/9KdYT2al kfmoDVvhQl9hno4HfQtHqfCO/RQ9mq/wmY4YGI1GJIfUX6gzJGG3tU25KlPhFeU21Z7mTIkC OyZyulgbpO5vNM0kN8h0jWVMWG2OFrXsfGP9TDcO+c/eKFgURq3SYpC4doopxctmEn27vn9g 0wRCnhxj2+7qcIPO4J0rUv/MeaMgXQm3bZONzocdDhAYNfLQJCSqMbYnBVmEyuVAwgVzt/Vo 06GRCN9xKVWDTFJXZN2pDeyT8P5uSLXCciOSKLpLgeV71lCikkRwzMLC8i10r04qMvaLRBWL caab3tKoOhEuoySS2QoUukiqpYZaaCSa3OZVBYJ43YnGlyOxMAAwi6I0frOtiK6gFolcQsIe kJ52Do0Ia5ivnqrZ1n0opXGl2Vo2trvLobC/PPxDs1PoCyasZeXitQKkZvHr2zBN+KuNN7u2 3PwWyWodgeiet8QDJn+LwOcseTisdFa3AOsXFj9DTm+2wIbFejXeEDUqlg91rNzA4Gdrew1B nN02uaET2IaNbEbRYNC3VHl462HcJToi9UNIAqtcDn4FkLwqQ72gTe36Ae1egdoialAbY68z 1m66y4FdirKstHQtHR63oG4rp593Orq8roivoy1lmsbLhH3eUULkjNB2d6zpaZJoco1GOQHl crszUTy+Uvbq8oUNfrjyVISZpJdHr4WwqrJEBadVHKvvrQhAB4KQauHZXUr1hdVm/FXtS8WM yM/KUxVKV4cOYIax6xHFPjKpAcjfxGkMyoRc20ti96XSNRllEY1lkrzcpJki/MvYPsSLpXxN E2HQ7IAGHYf3cY3NvElLazZkClyjsixO1RRrLxIUjVXMpoiNp+ORj5IkQWZf0qte7HpagruR 7SMqu0BcYGwDVmIqdunNFfaXkPuqKGf4AO3/PNLHuESXUTpNiSBW3B5GeBGR4LzLekzVZd+u JSJ8wKH3rbJKiiM7pY2aP/zYWU7ZRpy/rFosUPIq0+x/ENLuWKlCCzlN456pD+OtaBMqnBVw 5mGS8IZ7fkioT7UcaAN/tSxX3gA5rDnQTkS8OZGe4bXfjtDaEze9OtlGpOa4llNF1lueY1ax o0fz7PosnrIxBkmlKHjPFZV+kdsd1GReMYlitP+SulJjPlB2r8VM2nzSkiGzpk5C7qXENLOE doteeELoVw0wZ+/Xt3dNTuMtvWt2CaU24QJrXVawCRapdg8zytQQsrXnWN0+zOswpgdGPiXg h3r7RMAmUt4HELSjtDaI+M1Ze2v185SVzfBmCYBZfP3n48N1Fuvh8ZD4GKn3Fg47R2QgVMSx jPgAGM9CLpz+hMWp4htMtGuYdvUSh3fXJKbEAbzLSA+s8NM4hTmJmjkUr1Rsi3Es6CLDklVK UPxNIx3icjETkZ0A2yfm6C8yIjDc04/r+8vL+9fZF9F5I2YhXnB5Zg65D/so3TQHttEGpgeL WMkiejO9zUq0wF03afKGtiWQaeqGdkXuaZjG/hrBIawtA4dfR7k7987GGFShMzehW3JkjvAf XUFeH9XhRUCL7dVKCZu9R6oNGhwh4oNPUZmznDLaQxWB8BmU9ElWbpCuE1vYKWv6TrPFDIbS 3VHbKkfLsoi8c6BRcK26y5/SOskUK6sTyj5qNDUOUhNCR9sdSj+OpDDNOIA7G3SebOOW0VHj vpBkmPyDR1OA84YyXBqoowQDbHVp9dqyODCy0Dr5dIBu8DyaaA2d7GI6naD0BfxIsuyQhSCe pnToCYVaxB7Eq2JtDsJwma7oBnabyWRX6zg0o5gN6JPYn8YJDiOOoASdDoXvutyCgmfi5u4o Yz6B7V2aSStC/DY2zg6cFtWBFDAEmueKU8yo15X+e1wKKhiDD+owTQ8UhelWPX7S7VRGSkRD SbYTKsU4XdK1Lkqq/aAf0mBoDdw09zYV00CGrqOa8C69VtD5rSoWggBqsV9q0620/CRr0lGr 0MFQZKKuEpj9r3PN6kAgnXGe16RgLgXmTFEvbMM0Q29WsuFJs2/KMuvlbeNJ2CZ7iNBBKQvl mvA30fwuF6MSz7qKbIJwFNax0QweiuTxoWvHrPxuRGU9iNAz+ySrSN0DcFCTV/JFvoeA1Hgo 9PCPRRxmtP4MuIjXtE3rnMcFxwCOg2f49vH1+V+X1yu3EZDfcLcnHr9E8fjtQdwTLYaCpAB1 6OAaDpVIEdnHr3iEOtFhqlAJPcRVoOj6qBkKbvQE7M46vWPDaRLyFAtH1XO4P+J4pA0ZS84M lzHrVLkoD5JnnTAdiodS90E7eLx2FBwnAtJ2FDyEh3TM3jMplaG0osZ8c1weE5+R6OMhw7SY XOGiOKLA2aL4AorfbepGBozBzQd9Tp91uBzFqoOdHAOkBuHt66k/mfVg3PhjLqlPuUsiBjvj HLdVNzhEbpMiSkyDTDUukLkYh+jMQhhSVmfYOYqhs1dZt5lNhHXasKJPe44705vGPmUwFfCj zSp6f+5CT5+rxfncJnQNKPwBLrWkKdxjKgpGDojc6eE4KWFDj0SCBnVnGPdSDoehmbGfb+/X Z3y+eH99eeKBryX/xxQzPP9xgW246iyQ9KFlUZ4Kw56ozMgm/q9q0Sup6Er6HSuWVATwA11g pD2l3y513/s4T1XfsjhPRZZ4aq9AHF5MQS7ao2MuhmrAwCLmBpeyiKUt3C5wq5Yz6IwIdcfb dsnplbNTgvdhSCj1P+DVHNgIADENhYKthaGjfLECbiyOdUgvh11Z7rJkGDnjUIR+z/6W/PV+ /fb2iMEZBg4bpvI/ZmywTRtPaRiuI1wyqCkEVMLUZBgIqzG8Y87VSpavtuGdObU8RxiIqz1y jPsnF9pFwmDqd0Pg3uaw4U7ddTzEgdEPUqTHTFbDgVY0tZwfCvFRWDEM/kR92ygae/7ugIxe 4YVF3d4xfl/Y8Gh+Oez9Oy36AO9WlLpDHh4JHoNwhIELQPLp/L/HABv/g4lUioSDFd06DfUa n8curbI2DCIfCsNULyLEyf3g/9xc/3y9zP7oKxeXWTnJpIXAEBF0jdCukK3180ZajPCDD/9g OjeG8/l+eX1Tw+s0GG9zxcMAKasUEbCcfO8sohbRKmWkkiMJ2anEcLZpDmJZY3lfkOia+mwl wYO2YplZoUQDJzHPBir69UyhhJ0ABvIQAcV+cdRqlCJ41HEew5F0vjTpMXAAxg2QedKcBz49 B/hzlgv/oVkIpA2ax4oUBbPs8tOYsE12B2zK1BkXnXjWZpBHGKlLY58rXt6vs/evl/fZ47fZ 28vzdfZweYPqD5t09vvTy8M/8Ivvr9c/rq+v1y//NWPX6wwLBLwo9L8kMbyRHYS2jXINw99t fbJIEFvSQLDexq1WDGPbmBZDWN7SpWBzy7LSZr+L0KHznIiBhYlp+SuFMV5wnvy9LvO/b58u b19nD18fv5tqSr4Ytqla329JnESauIzwHWar7sDqcoIdBd9+Sh69zcbfIqRrcdee0hg2K0fl BQ3rTmIXKhbrTx0C5urDxqEoBNJ646EzOdy1Y7X3Ec99GYYmlKe0UddrmKutgXlQAeGGiRfg YaVNTJeIsHT5/l1Kj4PhlwTVhQfR0Oa0RJHj3D8AGdskeljklnAunOWipTuPLM/BSFAkDaex EjRsuSSTd/Le5/HKP+OgaJyURnsET1X7fn2yorPFYr47WyrF7Gc4MdKY3xpTPvDs+vTHLw8g LV+41yQUZWr9lVZgoLVtFjLKkpwzc7SvXO/OXfoakwN8EWT+Yq6t/woOcdg0UpWcscZdaozH sr6HymRroqVcZxPrzIppQJuywcSlqF+UAxh1WLj0si4YjjPGgx42b1cc7UJx9Pj2j1/Kb79E OKo2LRIftDLaedJrDXeKK+ASn//qLExo8+tinMbbMyQOkLCI1UoRoqnF+RZcJIXIdKWMYwfG EBmYIeJUp6QHukzaia+2kliYswMd9kqiKhtj++9R7hl35J3t6iD2ohPvp32tY+I6jUBcLKII RvhPGFPTt2UYPSBSB6+HwrGF76e5ZuVkIQH2ph5HdOqNmqmVauHwsIuzzfuRVXFcz/5N/OvO qiifPYvoQuR5yMnUPn2CY79se1XQUMXtgv+PPs5qogIJzPXNCx4dAAQ8u1Dak7NT1d8l/ie0 GNrtyOPYkWpq/as7LQUo4lDN0jKLBhwJhJaFSQknrS1E2Y1uBdfNCc3YqODZ5BGcHb7FPKck 8x5qKVgrHmZVfZEZAaMCWoBa8smuR4bnIFitfaOgFnbFhQktUNKWw9EVlfKjU2tKsavEVajT w6jZx1hIR94BqJqmtov+awDa4pBl+EN5/OxwW+rGEMXaid1TZ6XFGKwniOsN+Zrat2QjyVo9 UBxkJlCElf/V8SnceGKN7z7YajQaieIjmfqzCfkVGN9AxgrPIOuKO4sIfqckX5aQqGxScOJN rBtXvYWb4VwsjnkiaWX6mwdAtfOIg4bITRp8G27gdFG9Mzmc4lqO0fwQBYw7YJD6QqWZQgx9 fHuQVLv9sk8KBrtWm6XMy45zVzk7w3jpLs9tXJWUzB0f8vye66xH+86IrT2XLeaO8orQ5Lit MKpvSRFlJUM7DUxCya1UpAbskj3sG9Ge3rK4wjcq0wIf0uwUGBfU8oJfxWwdzN1QfoZLWeau 53NPh7hSYO5+1BrAgLRsIjZ7Z7Way13pMbzO9ZySdfd55HtL6QIVM8cPJCNb2JQbGCI4Uyuv SwkrVa2Ig+c0S4tzy+JtIpm5YqzYtm7YWdmc8VjYp3fJPb7FUtuHq2+yAgIcAHWChOs6y7kp hCQVXgjeCAUmxwBbuJT34YiVjH87oEjaLWnEBDgPz36wWsqd6jBrLzrTEfQHgvN5MUkB99Y2 WO+rhFFz1hEliTOfLxQJR+1+p6D76/I2S7+9vb/+QJ39W5+SdPRRfkKR6Ass1cfv+Oe4UBu8 xMoV/C8KoxY9f9wadadovR7idbmS9a/RXnqsGphIfbqvjlVYpEpohA7EH7vIXUrZk8SdDS0s uzuAIbtyxT8mdJWtIsI05lmGKe0F/0CP049A9degz5VhaGGjBeAcW9g1bfb+8/t19jcY4n/8 5+z98v36n7Mo/gXmXcpn2p8hTDpron0tYI151jDJEWygU/0NxkQD1Grtv4mkU5H3aNhrNTi/ mGGgWW1UsnK3U4xQOZQ/3/AH2v5I5CPS9Fz3ps0Xf8DE+TFGeBtNT5x46Om/VcrEvJcWeJZu 4B+jMvFJSMu+PcG+hBsqI1+5BU1ddfVKugi9+9oYnjK0stKfr9TIcRzEFbrGCxZHCck9pC8X nOKwZfuIkpJQ5BGj3UtD8tbP39GBDcsaBFdbr4UJkMozkjGdQron1zm1qiUxTppFFOpwFkYQ QrrYliIlpSpahBOJWxDLExATHUNcxa0duphp/FEVg/LP/vX4/hXov/3CttvZt8s73Ahnj/1L jsTdvPh9NN6WFNkJEWlOvyzwT3cJ3J+ptiGS8bdXsbygFQ968x5+vL2/PM9ijOAsNU3p+iaP 1QDP4laSlr+8fHv6qZcrf13h591re0RdzjjB0O2fqpHPH5enp98vD/+Y/X32dP3z8kBd17UE JLhhqbb4ecwjN4e02VMe842fVFMKlGQL2UPmBmix9BXYKK7LUG5NeK+AouzANKfoDTe5mb5N Ucq8PpZaWSvq+SYC0YNr5ahvAIkZo9QViNCKaS4KvegINz288nTVSSK72I56qHD+T5Jk5njr xexv28fX6wn++w9KkNumdYImq+SanyxkGEr0OWlKtu+MffR4NZ3lusHE6bfvP96tcgI3kZS2 V/wpzCmfVdh2i8/aqsWtwIio/nfKc7jA5CFmV+GY5/FN7QmtMYaV+Ka1BU3UWCIu89KLlIxB E8QDJWFqZCyqE9jSz786c3cxTXP/68oP9Pp+K+9pY0yBTo4ifpMGlEzoxdAbGmGtGrhNbErN EtBsrCRU4k8YA+m2M4BAKlVNeUfM5p7OE9XjQYRJ4d+qImrCWMRh1WjXcAINEoFhOWRQR/eV JYSm1Jp0m2xE7mOiBB5ukifVvVFVkoGwBjL5ZF34SpVkak7LoabyEO3v5Dj7I26LoeOxdLqR x5z/PdFCuMenoS1LGhIIv1BsgrUDmyhfrlcLvX3RfViFZrtwPPAaYy3uyM7nc6i4CQsEGktP dWXggKnSRyrND2JYcBjOi9rGBQG3NZHmQvxuuV9JlERyhHcZlVZNIqmqJNQ+LE5hsSNxdxik Qh5CCVfB7ZpZGL0jE5PbnkK4VFGX965HOLliE1KqGsFtEFR54JNqEJksjNkqWEiHtIpcBavV BG49hVMvvgQeLTlpPNdn5aoPAEnQNt7qVg8PZVul5yit6co2B9eZO94E0rV0M9qnFaamSKMi WM6XFqL7IGry0FlISiwTv3Nk4UnFNw2retUnORodCb2ECEJhQTtR1IJXd6OwOFzPvYWtIEwx WtWUe6BMtQ/ziu1TTTCTCJKkoYQthWQXoq+KWDi25iTnyJvP6Td5mW57+C1t2OFGlbuyjOVE FkqX0hhfhsi53KO5Gfx/4Z/Pth6nWQosR99qNDrYnm6ToZblJhXz2f3Kp9xrlG4fCjnJizK+ d83WddyVBZvJLosqpqQRfANsT8Fc1XSbJBrXk5R5eHacYH6rf3nElsAktvrynDkOtScrREm2 xfS9abWwzXDOdq7vBbdbbRzh9AznZ/+QtQ27PQ5w3TtbzmOl4ruVQ9t4y1RVUnC/kFvLM4Zb QLM8z33buNYhqzZJXd9XabulbcuU1qU7MnO9TMP/rvFp0zYJ/O9TSnkBK2Ro8eR5yzOOL82p w9lCM2ncBGjE/BE2PeWB59xe+ShJoBVTyWgrC5WlHW8VePSy5H+njcsPP3qUWMQ31lv7ONC5 8/nZvGMbNLfWj6CynKUCaRFIMLUDs1XO4C5P5ppQiVgns9BlNI6rRmglifLtRDMOxYL20FCp eLogDw/q28TnQHv1pwauYv5yvrIcWZ+TxnddiwT0mWv/6A/rcp93IpKFxdJPbGk/6z6j2XpK c3x3iU3JR806TxcGs3EgLQRxlCJuCki+0SBb+Vmyh4gloFG6cffKo9M7jgFxdYinHDIdjDbd 6JC0Xl0gyenvUMteq7C/vH4RJvN/L2f6MwLv36gQNg1DNAr+s02D+UJSJwgg/F9/zBSIqAnc aOXQMpggqcL6jjSHEOgs3Qj9hfaZFvJTw3YvbvCltWDAoWJS7x+MA1eYGF0pMxiSsCKjC3ca /149Y7aW7wF6czQavDZbSQ62HXkX5kkX6lyDtAVbLgPl4b/HZBrbdcpFil0GxSOlGxQaqq+X 18sDxnI07CCaRknacqR1MJjpbR20VXNP35LF+7SB77E86w76JnZ52zor1dfHy5OpIu+u2qYb SIcI3OVcn74OLGU8pky7yU9ooySZwvGXy3mIrkep9lgoEW3RhuyOxilZE2VEzkWBjbpWe2RR twfuWLGgsL0T0gQJTxQYq3nFldrDAsPg0P4dMiF3uuycNC3D3vDQtfWnGyXVqt+1jMLQG4G3 1HTBdHX2fWXoO23BJ5OkZeTdam7jBsHZ1uLSZo+uDHLjL1erm2SwwKp9avF1V9j1THmqyxTc WdW2QGCUV+5KuXF1rirffkECgPBVyR/5iZePrqww3+Az2Hzi2EAqVAdNEeQJs2Su7wiirGIr xyJ8dzSESbJOwofkJkHbRJSGoW9rePac+dxYqwJOMYn1EVSgceVmqSWuW983TLNAPuN246NY 3klAbttQZgnRrJxNro1jEywtGpmOQud7FYs6+pTaKQSib9hkr6OoOE9UwSLHTxle3zpZ04K2 YzrPdrPiHm8T8Xt+SXO4GschaZLc0XSOfcb09A5/4wxpq0YIRr814Q5ZxOhEh7+FQ8bkm7tx OMhEm/AQY/KQXx1nCXc4k1nODA5uLWSSQYQPJLeIQGqbQm8ZcEh1qxBOlRbbLDnfIuXRFKhL x7D3wEXH8ZYmk1Q1dWQi+EPM2+R6vhCt4mOyOdwcrvI0uXMC79EGJ6pQpfc5amo9Uk6HKoQt VBzKOROLdh/LoU93ZRZvU8wBIZsFFO2O5cr7NdppAwklhh+jMWLG8AFCz8nkScDtvg6UpAIV YSzAopGkrxHWCiskybyawy0nbVXRb8SdjTSxqaZVnuLDU5xZigxZlYA4eoePaUi7yel1UFRw NMO2cJOwK5AHJDfJxmZtuvB3SqLjfsBPcDsr4jInQDw3Dtxk0O9dNpka8Jtw4VE625HimIZU wcKwhsLocZmkb/JzWxe7iMLxpUYhuFxBIpo7Cpyc74uSURicFXoUziCwJTUljOUnuJ3LH2Gm dYtAagRR6Oup1AjF+LvN6YMXuG/H8xa2ffY/yTIG/qtI65skizpn5g5yTrPsHpaYCJupWFRn 9/jCqxifCk6pD7DNjhEMyC3JvHwKcwo3IgxY1GMZbdgQBpe5OtmlJZl6BND8So8eT5LNCoCH bJIyDO4yqqUHAEV6Z+Et8OPp/fH70/UvaC82kbsBEoIwfhbWG6ESgEIzzLZGpnoQ5Ytd96da gIDntPlLh8+aaOHN1UzBHaqKwvVyQS1FleIv8uO0wNOAVvJ1NDDoE4Xn2TmqslhxT50aPbX8 LsATagUsdXDrk8H6BkoLn/58eX18//r8pnAMT/2+SbWJRmAVbdWJFkAlhoVW8FDZoGnBIDkW Btin5+U+Vk57ERoHbS8JX1veqyhPjQ/4YhBRbn7HmDydd+/fnl/e3p9+zq7Pv1+/fLl+mf29 o/oFrmvo9vsfBkvyw8E6qWGzpoPxc+T5nNK3JL7GxP18Cj/xqtlT3JUFtWVydB3lrNloyxU3 JGrpxOERGJi6GnFsglEYedge/YVeQ7MMNuvbpUgmn2pJ6S6Nyox8+UJ8kidHV+2SKn71EGFs CWf1byL40k+d03Z7uEAZe6xCYonRjMg0tyT14TjYZSrbSxinKCu4sVjRv31erAL6ysj3Cust n2MbfzlRdt6sfNfOs/nRB5Fi4vOzJU0R4DqJyzJzJTIO03dOq86HI09kviPAwJ5jZaGqsDdf 0/YoOOEFZglHiAR1mtqnlHmRu7Cobzh+LyLzW8LOI0WaN8lEBVVt34eYJW0SR4FQt6UfXUY8 rVHj+EPhp23lnuwDw+6LTweQh+1rSeiDNlVun+xJjZ1M0G6tJGj4azg2KxSnnMwcCRjh6KYz 0zmzN+icVeuJpVJHoRmSBYM7vX6DGyVQ/B0OZDicLl8u37k0pyvuxX5YolHiQZXj+E5eub6z tK0P3cGZN6jclM328PlzW7JUO8ibsGQtiNXqF01acF8+ve5jiq7Zulku72D5/lXIKl3vpONX 7dko7SgF83uLJk6QooPOxQfK45Cj8ERS+8VBncud2gCBwUBUwG6NihPO2aqKcISjKGSei4ix RQuUJfahPE+Z6AjjzwKMiPDT34VOEl7SfR0jGS4brKZ4BwAUHVZbCTuJLlda3F4EGZUhLBnc N1DXl1/eulRnnVsIZeHNPbq48ozWVAxow05PpanX3sKiGuY+Y/vVeuLjPIzD1lvZdLRIcxbe Z3Aj0cL+KWRTEp2Et77ICBLfJhlI+HbPrApVQdV+YrS7EqLTZhMW2pxuDg1qNTJJD4XgCK6h RaSqvRE8+Y7AuaYX9awkSbWe6qpQYE51Eyng3ImnaLjD292hqBLbi4YUz6I9TjWoOFctKkqn qrPagfOoGDn+u7V/rT1wSJgsX83bLDMicWRVECyctm7ssThwlCaHiIuT+FdkL2SgmQj6MSF4 CrRV8BToO4w5Yh/9ijslWZm6ew1hsvkawktxiinvdwgGudNdTDS3SY0lZBTQOvM5bZrKKerU 9hiHgVHSyKbW7rEt+2SvHyRZl5S1EQm3xju02tZ73cMng7fUU93+dLA80QIORGB/YW0Ti5wg Zf7c1RuFkjFLS1qqEwQTKNgKJ5oLck56tG9BVpm6R7ZhPFG4/WWCY5EZabmb4602ch3Wn8BO Ctx8OZ0tdxXO2yiNu86c757TVJolMFHMHJhJD3VGk+lx5SWaM/rW64whJHJruSB+23FNUrAQ /tlWO7tw8RmGcXqVI0VetbtJojA3xWAuA0nKO+rpH6dJlQWGT/uIP50cJVvzcM5MlXg+fP8b /DK1ZGl8CrLEd892AcemtOEn+X0R5rL7F6vyVN5jc3GAer4WpwQROYNNG75G1S5Z+550Mq3k AJjwQ829A4DZw9OjCFWha7yROspSDMx/16vvTRS3oCIx/c2JwnWapqERf6Kf8uX95VVuh8A2 FTQRI5KaDWzg3FgGQas9F6jwztwqzKwEsZwFWMN9grPnU9/S5NsFYwlX+/ss3fBg30XSnMr6 DmNA8icO1oQ5Bomcvb/ALGCI1SvcSr/wqK9wVeUdefsvWxfau2NubUkaN4Fbed4UQWT//Jif ZHW4OazDd0L7PnIpAMQrhEQAf42APq70iBiYUlzbCIW+WhkufPmzHoweQz5lhdkT5HB399g8 UPMBGFjlKqZjTQw7O8v52YRvwvumDtPMxER7dEc4psmJ6kZ2DxKv7kWq0YgMV8THYRZjTOk7 MnFG37C6PDeyQeLQrrAoygK/JnBJHNZb4F4TBTeVY1I38ktlj0qyuz2aB2GRJjLP04ZtDvXO LFPEVqCbkkYJjfgNXw3qrjJzXAG+TZOMMgAeaJJTamkRSAZ1yhI+Mya2SXddzcSkoMy4pA9U mWQ1TWKzdxraXoWMoQLcONlq2C/fLm+z74/fHt5fn6gXnb6QGlanLU7J0NZt9x5wk6oOwtVq vaav5iYhLfIQBdInqkFoUT+YBX6wvPXyw4T0hctsIe2mZRZIp4k36T5Y79r/6Jz4H+2y/9Gq P8o2lpcYk3D1UcLwg4SLj9F54QcZdvHRFi4+OCuLD47h4oNss/hoR6KPdiT5IDcsLEnVTcLN bUK2X7nz211GMv92jznZ7R0EyFaWaNwG2e1pQzKLp45OtqTfjnSy4DZPcTI6hp5G5n1gCfGe fmgWVu5HenrWyuqjtlsONWH9cv3yeGmu/5g68hI4yM1Enb0BiK0AQy5Ee6HQFG4itlhl6zkh SHGE9JaOtxuRMU8F8LiXPLuIyNG7dFyZolWDzfYfpfUnroEaY1ByobozPZC/7yOVybBIC3Ez ANsjZZ7D0X2kbbWkPDyvPJ5rtJsQHp35+fL9+/XLjKtrjdcp0as8rhqjCfa3BNFCQi0u4+MT 5p7/STWbjP3FCax2CByblpQJm+j6JvDZSrIPFNCk+Iwe7Ho1eRUFtpd/QXCmNUodkpbVhIeX 5dWdI/VnUg3baSztFCwtJxp9xuFtGa186Ce63Vr8z8UIx43nLryzZX1a+UkoAuCS+kuHRRcz jePUmpz5Ah9820VAXZsGkhRpHF/jow4DH2uI7coRTjcK1/FJyw0GT5uACjQiRjrae8DcBudY Ez1w7CktNqUcH1lAmeNHvKnj5X5qqAarLg69/vX98u0LNYRhXC2XQWBdEnw3mJvMj3DXum65 2Z+nj2EHVbPtjZjVXFt5VbQNlquzMeZNlUZuYLEd6UZ4sdbfJ6VHZG1MxEa3jT80VhaRQRDU 6Wfavoyjs8pbLzytk1kVrIyRGg4nbelmboA2ALYKhDt34GtVcHDg65Vw8NpxTf4ERGCTfQXF p/ysCh4K9pT588XcmDcqjkG/LZijP+h2jVnRGNFz1o7JJIJzadlTEESeFwTWZVilrGS1Uey5 xpA9tGRDNFaEqYPtdLITo3mIrLwjPuPFHR9f339cnqa3xnC3q5Md5oy0Lm04KQ6VxiqmPQlZ W/+NnF/z5KB7Qq9zdn7512NngDKq5IcmAq2wiWhj5i7W1CSoJIHCpSNOO2OJb51TTn9qfXoe SdguJSea6JzcafZ0+afs4gwFdmYy+6SWdLcDnGmuDgMCuz6nbJZUioAoUyB4hrIuvSNdvEP5 oKql+Jbi5dAQMiKYLxW2GL/w5jaEY22gR19JVBpaHSPTLMmQZzLFKrC0bhU4NCJI5gvbvAWJ s5pino5JhltGeeI5eZkckE4CgiQduf5cESZkNBov67bNVkLW0PKdTFdGSVY24sdN4rzxPdvV USKr8eWkJvXjEtVwiv2kS7lL7llTWuyKlOomDEhlOha5tBmuIMJ09Nm92RoBn8jBXsWhIKWZ k5+GPB3GgbqSdHhegOJSg3majWI75CZEq6T7IcrfuEDR72SH/g4gxMx9Ry6x/yiMmmC9WFLy S08Sndy5I63uHo6rxJ/T8MAGlyIFK3DXhLONEiu07wyAybHNwyIk8Fqhm08474rooKGs4Zl0 un38aZKOB8WjjjmJwFnOzY5jiLLVfGHHEIPFMa4qE/UjRoV/NIhA8AYe8aiToSdJWYW1m/wF lQfQVxOBgi4PBGdUZz2JxzL5dE7SZI3nLyldx0gQLRzfzagW4IgttDAJJslq5a+VkFhKn9fU JWqggA3Sn5uDAvyzcJaSZK4gZDWUjHCXK7qolbckv1hiHdQXy2A9pwYEUTZFvkzjWxQgwwLN N96C1nf23LoLD7sEZ8ddk65kA13n+2tuJnWznHue2fG6gd1sSU0Y7vikC+nQt3i9Xi+lOLj7 U656dOaYFixVg/pzYGf1rOlgRJALEdKeiDjTpajZpM1hd6gPavQMDUmfswNZDD2jAj9JBAtH WrgKPKDguTN3HRtiaUP4ZCc4ymJdLNOQsyNTOHIAWgmxdhdzCtGszo4F4Tl0wiBAaR4qJIVj /Zg0alAoLKmKOIqS+weKfUP2Bq3cyrw68LvPskjODUHEvBX1LYvQ4JRAnDFLeTFkBydzK1VZ QucjHIvfaNFLejg6DBLw5lyRI7tpnLayhInqaSL4X5jWbaSFmrUSVmRs156KBwxokrwymxkz 3yXnEFNIuVNMHCdZBvtjTn2MQfDPU/OPOsr5cmu2hysv3e2Owiy91ZKZiC4WJHBdRLVly6J9 Tgdf6wgauCwfmrBJiMJ32dIJGNlJQLlzRvmGDxQgU4bkp6vJpbVP977jkdOCjhE4kxNfo0qX +vS3aDFVKYjkteO6BIvzdBq7hEDwQ4/YQQWCbEWHsgQ01KmU2IYKck0Oj0BNdZOLUUtyZSLK JV2sFArXJZu0cC0jsXB9alA5gtiueFBfx4JwyTFFjD/3p1rOSZw1XarvE+cmItbEGcU1litq EATGIzqLedbIvZkjvLWlU74/ybGcQo9lJ6HWlDysNpbmojyqvLnNd6HP4BfZkpIOFBVzvcBi njJUVa+Wmu2AcZhGaqTRgYNyf+o7dCEh2C5feXRhk+c1oAlWACjBOFke0GszD6bbGywtn03N Y5avyW6uqVWarz0SunQ9QqLkiAW9VXDU1IhVUbASVybjY0QtXFtMO0FTNJFQt6assXnJ9KRR Awt4amiRYrUididArII5MVKIWKvKwQFl9foeKD6fm/auDu+SwqVKKKOorYIbJwB/PFtLW0aV i9zAOh0NRhHb9X0LghqLTYKGHwnV4E0VtjXzyTfPUcyoWu/eLDbd5G203VaMKjiu2Nqdh5Qn 6/B9wapD3aYVq4huprW3dF2SRQHlzyclOKAI5j45yWldseXC8vw0ELHMDxwyUcW4TtzlnJoG flCTu4dAYOiUQxZqkRwkIi9wLJ6X0vm19Mjg+Nq5SSx9cSrOyYEFnDtfeRbvCoWIVOioJ1BA sCJiFgvqHoiaGj+gTuvKDSzwNcXtVZovPJf4oMr9lb9oagJzTkCEIBr1ablgvznzICRXO2uq OI78qbUDJ+VivnDJzwG39HzVCEcjOUTxek7dzRDhzsk9+BxXiWOxi+tpPmfQ3elprk6YJtgW eE3QyHkAuIplkpoRb+Qm0aYh/WhGfJ0TgjODWzd5xgJicqcAvPcXWd6CBkfkyonzBOTD6YMv gevcYlIgAgrXmRMHOSB81O8TLcpZtFjlE5g1zbscu/EmJUm4X6IesU8Xa1aBeFpw5yiPMkQY V0/DVkuy4TkIv9T5FjluEAe0KoytAmrRc8SKVgTBoAbTx0gRunNShEeMzeV2JPHcyeKbaEVs 0M0+j2jRv8krZz51beAEBPtwODE4AF/QJwFiptueV0uHqOqYhm2EWq68oso9No7rTJV7CrzV yiOUJIgIHEIdhYi1E1O1cZQ7pSHhFOS1gWOmxGAgyOCMawjZRaB8nm+MKhjWzN7iJKwQJXsq 0ehAw58hzdq5oSAhUKGDU5s7c4wLOWjNJ4OSDSsFg+3ZHjYHouZurubEQiE/lJy1OgAmsUQH Wln86VGsCZsUc8OR4Tw7oiRPaugjRpXHNpXbLarswvs2Z7/OdeJTnfJEbW1Tp2rKxJ4iTkSA rV2JaX+Tqj2llmx+1BdbVFLyMOgTLZY/wGQAqEZUQ1FQlOIxO8yyMrKYC/VfqQ0xR1zpGo3G OBqtGkxDRiutJvBaW2Vj6eO2Tj5J3GD0OclRHraFGOipzIzpHcGd19OQ6CFSwCRRFNYUQYfG kA5jB7qcn+/XJ/QvfX2+kMbwYr3xcYmykNRrgsQ7dO9oBHdDbHWHZgU52fhx6UJV3mJ+JlvT 2bZM0umNbiKMkFlmqSXSSLeVJEVWavH2h3wT1ODw9mxeXy5fHl6ep4aus4SZnDGMDFOwmySM nNahodbW8OY0178ub9CZt/fXH8/cSXui0U3asjKarO12ecK08vL89uPbn1PTaSMRj5nHNE5D qO3P18tki3koM2g0bzO9+IZoZ5Mjzcm8eduIw4Ds/GSreLM+/bg8wVzQrNGVYqWRTi2MdmFf y6ewifZxKe1zPUQLiDWAi/IU3pcHxYdiQIoAzyJTfVLgSUPJGwN5WfEcZXmC5c2J8rgPyVQJ +5oHA2irOunL6bak0+X94euXlz9n1ev1/fH5+vLjfbZ7gdH59iK/aQ8ljSXgFk50XCWAk17y 4bcRFWVZ3S6qCos0mi5MPgm7Qs3RstDz4o29chgfI1Nzzznlthn545kEq+M+tAjNiJbuQEWu Ek6zvE3jex+guVEXbM5b10FJ7xbZ57m/niY6xWGDafGmjOUmCxDhT0iajuJzmtZonikN/rie O73BdB1D9LPzjcZgoNs6R+3JbToW5usbxQFJuIwXU53rIo+Rnds2MLBz50ZbupCcU5XEJ7J8 EZpsunQeAGqSoirOi/k8uMWWPO7uNBEIa7B/TdPUxbLxnRu1sUNxvlFOHzd/uhy4yXpoKFg3 N9ZKw1aupbR+NYVnXx5teYMQVmrujYlO87NrXWqAXB2ySsf3o5Y0B5IF8vKM+TxspYojfrJV PJ6s7XsRUG133mxubTVId4MEJIQmubvBZ31g5WmyrIqc4Nbsd8EZrJ3r8fXn0EbSJV2YZjIU SSYpjimDv26tjJxFnuMlNzau6NMhrRMLm4TxMSwwmT3ixzMu2YDI7wULFcqNWQJelPJYES2R kS0DwqCobdpUEX1E9RUe6tJsRrpZzecdaOT7TR4yi6l2uAVRiO4pWos47rZrvARUISxyXLNO /pLpeNZO+nNkLbLeqDos1V6hsrX3OTTGEud0tVmJZlF3fO7RpX/Wa5EsHwE6WK22ajMAuO6B P8c9K9p/1poLE5hUZ+AHQlgu0vXcO6tlgLC1muOGrbYR7l+LlTlMyv0MPSOmCFZzL5jYEHdV HNl3pgr51GDUUfRpQ9dRu34WCYDlXhzyjOTj3oHsl98vb9cvo3AZXV6/SDIlUFSROYyMbdqq ZCzdKHme2EYlEQlxNF9zGJZQ/lger9BoIo/d9sePbw8YA6vPAWkYuubb2IiHjzCR+3JXhTH1 pI0UaLQoZ1AVQdKEQ6bEZkgZNm6wmpP1oLQFY0X7oCAB9G25nqv2Ihwer5crJz8daRbAos+V OzccBiQC06dzhN78rDPkUj7lAQksj7gD3hJed8AHlPJ5wK61sR1jIKh9ZymZypBPEnd9OOuf dDcZW5hAicTmgjGQ2HogLjBUxaTdT4d01FcRDs0K+qETkeguf7fx1pb3bE7Cs/uIOE+2WY4c 7yznapOAqhGfjNCy1XBU5foW+2qOPkM7am2ZaRTuEoRQG8m+wWDplvlGJLQJo5TLgb25Hg+1 VsgPE6q+nqSN9s2JTCplkMUYrVY5xVWSvN6S7tLYU0GaVYypozvCRagOjRs6jSvceTdn2zaS fmK+a2wid0lue5hGNHfNsbyXj3gbtw8eXyoLdY4tBpt09wQ7G3ACS9yskYB0Ah/R6qPXAA8s 8Y06gmA9p9+4B7xr39WELw713jxiA22QhHOOAVubw9brO8jqk8884REde4NvnzpWwkk+4Fql RXNObKcDXsdU7u19t6SjsoPoBt4D3Op/xcvL9SgncvXNIlBddwUU/XGsJdbRslkGdjxLIiN+ vYxOFyv/bGR55yh7fASOzpdzo7EcaAyBTHB3H8Aaco3KuNeofU8LN+flfD7ZE5EppI5ylffY Pd7SVFiDYXM9b3mGvTnCiVSwXWQJrWvocUeG9ugKzPKD3qkqzPKQfBWtmO/Ml8o5Lhx1SQ8Z gVppuxHl2TvCyTAAfVO1KBnDVyKshVnammyWhHbVZdND+Zn6TBZoSCsqCWzd6lJoTtli7lk5 oIuSoT0HYGGnzHFXHinAZrm3nFha1rgcXEoT0Uk0aVkAu24TCBFU1RQcLSHAePvzJW1B0iOd uV7kKZ/YtDlS27MBtpjPDZjnnCkYJSl1mCkJFEkwUfeEBMrbZh8K1pwWgSXtg8DnngvczR9b blBxGou/syDa2vbpUxRjyg9thoeIAiaQWgZ3+zAO0bj/YG0DhlhvQ9z2rCeWYiAiBxqZvEGO 6kfCqnUAmr74BsU2PSdw2JZZgx45P00CjIBy4EmsC3ZQwmGPNGimwK0UJqlAItvh9vRMtbQT 12g5ZyRDl/zAEvNTooqX3poOgSERFfAPJX1IJOLqTA3LcP+mShY8c6P+/mp9g8waDFohcWUT IA3j0CO+DYult1zeGktOFlhcn0cyi8AwEqQsgzvhkhpLtPt2V05I4WCD970z1Tc841cO+Q1i XBoTrFxLacFquSQxTeQtgzVZHKD8lU+hqIuGil1aIlUqVPZLiU62pM53hSjwF2uqgxzlk/yD qGDtWTuh30xomiU5F/3Vg2TOiduUTqTeqTRsQJ67OpHqmy1hhSforfEHqsASDViiqoJgSSsi VCL/1o6AVzGH9qTQiG6tbTNMDUmyDMj5Qwy5LPT7o4pZW9ZEtUlJSVuiiML1Yjm3fG6P0SER HWEn820lIPLmRsepSNFcojnldBX8Sa+u8v3k55xKzZKhIQ9s0x4VP6WRQHYPaMpDtGdRnaDW vdHzGEnfwL3V4pyjEpFhCGQS31F91BSca4kLLRN9ch2PCtcg0+RHl9yu4Gt/pd5MRyRz8yq8 2UmkYjdXF1vmwcq/JayYUTUoou46Pdlllu3gCjG3jKwQhzdlqaf4s9Ie62S7OdDG0Dptdbpd Jhfq22NuUQRJpNDZuU9H5VKoAteSkU+jWlEpyEca9PZxfDkpvYLrr/AkzvXoQ1Hczl3P9h2/ 55MT1d/3bzXZXzoeeWZyHIyMFadd/zUs3NlvjGl/b59soW4Cr2DELdS292XhJt1Q7ol1ZNzv a8w+SQnoWVort9dNteWwNi/jhFxImEkzAmQtxYlO67ZIBoSiM69RJ9djKL07EvjSpyP8t6Ot SFYW99NlsrC4L8lS0cC8IjF5hM8tsaXOc15NV5mKCD3i259K//LcrJAP5DGNEqZNVNikMNV5 2ZCpu+tW+EbITSNStavNUrrJ21mHJ73vmFtWLTdt4BaaWpLu4n0X7tt0zj0s0Z4Zu0O2jSVh b62HYJfY7HAsG61DdRLXYaNI1jjPFuULopo6CfPP5IIAdBclGbuuDtyurKvssCMGancI6dzv sA00QJ/WWuvqsyUdCJ8gUs8QDXnFtNpFuHP7PInAudaxRj9JC7a2Z7Ouhf2aFZnUqcXUGrEp tYagtvOmPLfxMVbGvSmVCIncxqqNkohHSSzp93ZO0+ElrZ0MBv7NlNS5PXYT18c2PDQlS7Ik GoyTefj/Xnn0/vP7VTFF71oV5vxF3WyYRgjskpW7tjl+gBbNxZow+xhxHWJE8tt0LK5vjl8f Bl8aSK0UHjCSrEzOmaAOWl/HMY0T3KKP+gzADwwGlfG56cISf7m+LLLHbz/+mr18RyWeZPgh yjkuMumYH2FqXi8JjvOcwDzLCRMEOoyPQ5K7ob8CJVR8eVrwy0GxS6hbFi9+eypgv5eKRmDI 7gtFMUl1TGK2hzFl89htbWwJGpldBzMZDuwMxmd/PD69X1+vX2aXN2j50/XhHf9+n/37liNm z/LH/27yOV6a7NzDxwpkYrd/STPgfLYIeA7nnhxLQfoi565ZFCrOgZ0Vg1EofmReYYFEK7eR EOp04T+aTmVjI53I7PLt4fHp6fL6Ux9p2OFQty+gs8uP95dfhoH+/efs30OACIBZhjLggvHw WHBNh4Dwx5fHF1heDy8Yw/s/Z99fXx6ub2+YBRGTCz4//qV5zIjSmmN4iEklY4ePw9XCM9YT gNeBHPqgAyehv3CW+twIuGxCJcA5qzzlfUWAI+Z5c0WF1cOXHhnNZURnnhsabc2OnjsP08j1 NjruEIdwMdYZECVuJRLLCPXWOvRYuSuWV2e9aC6ZbpptK3Cj99qHJkpkZovZQGhOHQtDX0uq MKa/kb8cN065NH2jQ/NYvW8C7BHb4sqfL8xNsUPgkUwvsoEqIGNGCfymCZy1XicAl77ePgD6 vskod2zuWCL3dIyXBT601KfUrMPgrrQXRBlBPYF13IZ67ZX6TK5i9NHR1mO1dBYGM3Hw0lxv x2o1n7tEXSc3mFMKnx69xui5xGcApy7SI9oxluuxOnsuX9wSoyErXxRO11mOD6Sad6Nbx2d3 GehJ1uRTkuTs67eJatyVPnIcHBhLnDP8yuiiAJPU3oJcHt6aGF5ELMmQAT1+7QVrY5MK74LA MVlizwK3UwsoozOMhDQ6j8+wzfzzio6as4evj9+NYTpUsb+Ye06o91EgAvEcoNRjljkeRH8X JA8vQAObG761ktXiHrZauntm7JDWEoRbaVzP3n98g/O0L3Z0J9VQ4oh+fHu4wsn67fry4232 9fr0XfpUH9aVNzfmNF+6Whi67jQmTWq7zjUgH1Zp3CVX7wUIe1OGZCRaA7U6d8zxfZdcH8bH koCCuPDL5fu75oZKYVWcKdrw73evl+9fHx/eqDTaaX5u0+pw9AzDlIEkVv10BfMATFwRVI9v Cczh29fL83X2+48//oCexsMHXcnbTRvlMQbEHKcRYEXZpNt7GSR5h6R1fgrrpAWhNla+iuA/ uB9mNV4AnzVEVFb38FVoINI83CWbLFU/YfeMLgsRZFmIoMsCiTZJd0WbFCCGF0qTN2WzH+HD gCMG/hEIckqAAqppsoQg0nqhCOcAjJNtUtdwJZKt+wG+T6LDRu0TKi6ydLdX+4NqRqDOKqFP lNvUpBnvf6M58Zus8PXy+uVfl9cr5SKOM0NkgpPxwLU2VFhTCx0Qx13o+EpPDseEqT0uFnKo UByVnWKjD5DqWFMSEWDQzRoXkTrezImFMbdWzBlaQxtpAPZki5SFBe5bkcmizSKLWTZOhS1y BZbgWYZImEQqrc9ZdNjqjT/ElJM7zssmb3fnZrGU44cBfIjWrpYThwFpTIqzJQxvVC+ZLb// b+uyaIDvtcLypAFEmdObGLJzXYYx2ycJdQHGub4Hlj5qpbI0rzJKrYs4BlM7V0JR5ahyTllF bvrkZigCVFwe/vH0+OfX99m/zWBWe+3LuF93xQMO1gYmiBaK6HEFIyZbbEHIXLiNHI+JI3Lm Bt5uyw1QhrZyTHP0lvNPR6KDiE6zdO2qpus92LNYZiC+iUt3QQd3QPRxt3PhrmrJu4sUvSbA 0qwwZ56/3u7kXERdP4GB77ayWIDw/Tnw5CQJCCvxec9dSrfQYbvTh3h8ahko7prYXdKmESNR daI6MOI7X5hnE8MjqFMI4RWbJQrzj2jrI/VIwsJ9qDoejTgzJZvZssHJivgekEFgSTWtUa0o G4KRxsxYIw2rYdMulT3YrBEVc2uqOZ3QRqFZW76vguVyengo83CpddxsbrIAzeturPsIo77K Krplm9h3LNaDUu11dI6KgtyabmxAg7y8CzFalsSa+ziXtLFZuSuVLQZ+Y8DzwxnOrII+kCQa fkTfIoqyQ+Pq9sZdNwxJdyyBlYdCcQXgG+8+jc1ddp8qXhfwc8w81NRJsWsoCxYgwye6YSwO ey0fCBTTZas1msG+Xx8eL0+8OYabJH4YLtBveSycw6LowE1cdHB9kNbNAGq3W71XfJuhuyJw 6iMYB7MDrZflyAOIxZRowIcwye7SQm3rJmnKChumjROIvxs876lQdIiP9mjio3Yy2qfw614v qsvpYG1zVB52IfW2hcg8jMIs0yviCnUNVrmO4+qDFcFwNCmm9NvMl5Z09JzuvgKx0T6uwFi7 sqhtIeKQJMmZNlwqOiMvCQKVwKGidifJSr0vyee75N5SxLZxZYs3wen5Jq1jDbitcw2SlXVa HpgK3ZdZk9xJMP5bMLBEdkyPYRanekt3jR94thmFThBr5u4+UQfgEMGOk0Z60acw06ymFfQx TU6s1MIAyS27r3nMOb3YFKO1WL5Jm0Rn6d/CTU2dYohrTmmxDwu1N3dJweBK1pg1Z5EtxCLH JsZGmCVFeaSeITgSxozvU88UtI1/syDgRyVlUxng6o6F4PqQb7KkCmPXxu1ItVsv5lP4E1wC Mn29KMse5j4HttS4Iofpr81BzMP7LUiMlkNBGDvsuAWE+lka1SXGebK1Aq85daLtPvkha1KC hYsm1QF1ulNBZS2WldKMKiwwcBksRMpTjlMkBQxG0agNqZImzO4L7aipMExKFJNAVOT8pOCj okFvW0eAIomlbT1FEjPb1zZDC04DGyPOKR39s6O45yFC1YmXwHZGquo0D7URqvGeGid6Y+sy ikIbK8AJpm6IHJazgxrulYOTPNVsfGSsdkLyxy9r83mUGR42Va+kSULqbtPhYHGBmCMrQjji UFSZvtUrkbX5HonmuiFLpYvZADJOAHFlb4mlyvKwbn4r73mNcocl+NSBCce2bZeDE4ApSao4 cA8brHa4Nfv6wBqRPXiklqGETHZAKbKtGOlRj3h3+zmpS7X2UyiOcPWwSlOLSRpizyksav0T LBlHxvLN5/sYRElzAxQRGNv9gU4ky0XDrLKVmoPw1Gdd6NXjhDw8JM8mZXY0b9insb6/KOdX RwP3evLyoJctjALciK4QEJ1s3blEShnllVI0+sHOs6OnaLGh5T5KVSWvdLUYbTlUYBc0XYHB ztiqRwFCD1mVtooNvfi+KLQrKILh5giHdMjafRQrGH10w6KAgyJK2iI59baSxmVHfVjBUZct ZaTS+uiKqGlOGbU3ItUWqkqLtOEba6raZvJS7ouQB39AEyBaxubj3VAmfB0GNvIyPkRNBs1Q hwaRccp4tOfkDEu6CDNcCMYcMD4JmE0So/MYM8eN1w6w4RaxCCz9qyujpcDZnE1f3t5n0WhG ZESV5JPpr87zOZ8zZZLPyFliJpUR4PB4s6OjEgwUVZT2IcrULghsp7kjC9+ntlzTA4lmRkoQ HJMN7XI6kGBgZSvFVMZrxCfd6NiY4Xxwnfm+MocVc+A6/rlDKGUiyvPdiWK3wEdQrrHARPIS 1zERpWUWezge3hPDMJKJMI+27vZkWRV5rpodWcFjPEdaH6qQdfEaP9AsZp8iTqSK2yZehNmx 0kQF40FzkPZW3yWeljfgLHAcarYHBMw7JUMgTR2Evr9cr0w26jqv1oVAbriZa5IjL6uLFwh/ 783dFreLLvZs9HR5e6Ne3PgGFNEKe8SBGFs05C0Rsac414egyU0dVwGyyH/P+AA1JVyIktmX 63c4BN9mL99mLGLp7Pcf77NNdocHR8vi2fPlZ2+ad3l6e5n9fp19u16/XL/8Pyj0qpS0vz59 n/3x8jp7fnm9zh6//fGid6+npIYnfb78+fjtT+VBW16CcRSQyao4Ei9ximyOtuOVZkYpYMd+ ydLwFk8F9mtAIAsQriL2q6M0DJD70nYs4peHONKrMoxk+VqICzZpf8w72hwokZSjOIvGdaRt XRxcssEcu3q6vMMkPc92Tz+us+zy8/pqjDWXTTBUir0h/H9d1E5TuOD8nofACV+uihUsZ+S0 bMsio/RYXFQ4RZ7aB4RM9EGcuzNGSaP807sELomlbN8woPApx5BVThH1uMwnaY8mKrLVgQxt D7E2+gMmZ7nlm04bTZ1WK/UVZ1gq2E1TQ80njbGVbDnKFx13KTD2Rw6ldOEmkXh+VdvfocIU zvmNDVnfeY783C/hOkU03apo75F5xyWS0x4u2PskbMjS0fQfVfNJlnApj6JBbbH8tiWjhCq4 zQMSneRVsrM0fdvEcCySNsIS1REOpdpSQlqFn6zrrqexyxR9G+NdYjEzJ6hExDaiN4Hjyp6L KmrpnW1sFdYg6U/XnVb/n7FraY7c1tV/xZVVsjj3dKvfiyz06m7FoiSL7Idno5rjdCauTOwp j6cq+feXICk1H4DaixnbwCeKIkEQJEHgRLXAAcv8bAFgQDdx1TVZjNbN8HFeyfFvvQd/jo6n gqgVS4Vc98/w64s2DraWboJqvlpF1HxmgbTfOFrE+XC7g6v4yGJqmDVlNJvQ9qJB1aJYrhdY zCoL9JDGB0oYHg5xCWviG0qmSZv1eYF2DY/dJJYeq2viLEOzLzhKLG/b+FS0UidwTpX2yJIa v35loQRlrA7qI8nb3/SFM0RznQjJrBu1vYmyWFVUOa7H4LGUeO4Mm0LSaiA+91TwfSInxhst xw9Omni7awWuHA5NtlpvJ07iZLtaLa61lV1krbDdTQp0xstZsYzcCU+SoqW3sM8OApPPI8+p DYcy39UCjmXcqpb+ErCfK9LHVbqcBVbdY5BixZ7ks37T1HlIzSHEYaH6GjgVBgcn2KEYKqOo HdsW3TbmIt3H7S4cNAWXP4477OBKfZ33caKNqzQ/Fknr5nZSla9PcdsWtddAsELy+mPPc6FX TtviLA6tZ4gVHE4dtie3nEeJO3sFfVKtc/Zkbn8AwyeJFtNz4nF4kcIvs8XEMyl7zty7maEa oajuO9m0easqTa9e93HNvfPYq8dHm+oYGU1RMSL+pOpLEfr1gug3f/77/fnp81dtoeOy3+yd C569mdvzkD6u6kZxz2leOE52JpChfAr4ZG3VlViI+oGULeL9sQaUXe5AVPZ7lzz2+4nUiIBN GjcipBYqSFXgfZODgK1UlPnbp/lqNQmftfabiba267WLpaXk6V9Nw1dzhneE+KGEw4BfBPg6 o/ciQ6C359e/TPZLp9xfIoRr1t5ddWBdcthuwXE4smozTF51xesSX6M3l7fnb39e3mRTXfc9 /dWj2aS6scfmL4u7XRvS+g0aX41Zmy3Ucrg5x9HKs+7ZMXwF0GbB7hHkISXCKQE7yVIoiXi1 nKijaBX5ZRoyXLu8JQ86bQ610FebkX0LuspEZ6Q4emdA9tr2wNjjsF9mjwG0a525oUikFdfU vBDecm8L+1YuqRcnn5rDdOg/XSf52adVfonbLg9Jzb4OzCIJzAMgPyQ8BLaVnEV9IgO3UzNa fN42QB+OaVApvVHnd47+dYtvDu4+//7l8n737e0Cd3heIa/A0+vLH89ffrx9Ro9l4JCQ6GPZ xm6VJMF86r8+GZrK1SVhy2uhDD79UKVgr24DW/rKgVeQsm7BVOUohXGF9Vslnq61O+zWyBJg FdFT+g4JwOCwr31r92wGkWPQoQFT7n0R+0Q5XiBnqUdVXiV+axryaBv1mDQLGkedwZKPZcmu 8WsBNP2d92FhinmjjU55ksaeDMFx+jCHOorntuRb1sRjg94GVW+Qk1bHT4VQPjnudCFZfRrc M37UwJgdaxcCyZe1vX4bSOYE89e15c0AkSMORAIL+ZyyiJ3rCVJc2sdG1IEqkKz/8uy/UOLt 40Uopzc+LBLP5Ce6NVckudwXW+ZXRLNqqTThN3RgODDexO2ZCPU+4My5zg1UVh/x8XqFKLvv Bsa7SIMgpC1wJAI0Oxgio8SA6dPW3IBt4SeVe2JAFU1b0xXvc2vRAJXb61bT0ACV+m2PKRTg nhKe4ZLCOH5CpYQxPFe0n/fyNgDpZtdB/iwSQl6vMs8TUaShpif6uT38KDBvLGAfD8nMDYIH 1APfo8GVFUtWZClV0MQdk+CkDf603oJJVcGPEGQrjodgdO/5g1+ClNRoTeWZAekhDvivDX/O KyIMlZKeE75JxnIGObwxxzdwRjH+gYai/DHULR/HwXSgdpQ/pwVR857KCWc3gQIkLWwrVLA3 sz/BYr3a5eHdA8jaihzGqhL6+y9UFeLmENQ8boscmxoVU4WKt+TgSoyCguAODBr2QXF12NTg IeVHQChe3Wp1IsWuezgkuOq1Qa17DmEjIAzqwg50YlM93yXFQkgqQcLcbwxJXPjlls3Cy/9k JCA/1tL6K3BZvFZpMdIgAFjORgB9THoRC3TbQ4GGhEouMZ1Gcz5ZL4J+wi+lKdY1nLrbMkkW rSdR0AilmC022CJYS6O5KOY/hUQVttkV97tApDEElfTqJMp0sZmez4hEL/4JProW0SQ80LwO QOU78L+vzy9//Tz9RdmG7S65M2mVf7z8Dme8oUvi3c9Xz89frEuaqs1gK495n8LKs58Oqae3 OZFREvgQYZ7mQia8dTIiRzq5h3EOHIGZiKA0omhmYStuv37+/qeKIyJe357+9NTa0NDi7fnL F8eItJ3iQj3ce8vRuRAcmFyM832N2cEOTC5k7slXMYEtVxzIPpemT+Kc/Tp81JPdQaQNdsLo QGK56jwW4jEYOz2ATNHjfqtxn3T7XHXI87f3z//7evl+96575Srm1eVdRxozS6G7n6Hz3j+/ yZXSL8E0NXRSG1e8yKub7a+j7ZEf1vg5tHFYlYvAiRcvDm7tYWcZbntDZC2iQ4VwNrrhYB9y IBal7B+0AoX8vyqSuMJkKZeKuZMaFvxRedrabqKKFTj1AvVaM4Up812cPuqc7XbVFDNIeeGy 1VkyzT7DNgdSbUhTXBZWZYEgFfl8uZ6uQ05vWFmkfSpqWWOU2F+0/unt/Wny07VKAOFwrkAs DoFPpviQvOrI1BaTDtElZCEvUq7/+OyEIAGgXJ5vh/b06bBWspt5YFASqKrVHoMDnMGdHKoS HKr0T1mJ24IS4yRZfMrRmwFXSF5/2uAPn9dUVg4DGXON7TEZh5AHNyErNIj5FbBc2UGpDR1S WW+8AMpXFpVtwUZ4CRWuLDKdgoG0fJHOVhH26oKX02iCOSG4iCjC3m14Y+8+S8AibI0m3a4X rqHtsPC8lQ5ktpxhdVK820+v0Xez+VRQaQJ6OXqYRfgibxgbJlr3LVAQjTsAcbmC2aB3+nvE ls2kyLojW3W5HA9O3pgrfbGeovRJtAjLydlsEq2Q8o+SvkbKkfQZIv0tpFZAm5wvMJN94GZy QK57PQfhoVwFg/Ygarc7gDlWEzX6iSjqNoRIdGBBiJyPDuS2msEzUdjqZLpEemazmkyxgdGe 57LrR9+qFMV8TBtoLYaqEjmsoimecqR/OG1WG0/I4OaQNCdM7rWhl8HivjmdZHwWOcH0nZqs 0EYAud2gfqjXdlrqmIuuS+xoTVJW81DoZSdGa6SLJH0xRfsIOIuxJoTZZb3otjErykdCiJfr mxK6XBPpaq6QVYTmS7YRc3cFbrPWtx9GhSjj0RwNGTkAVE7jsK25uJ+uRLwOW5vN12K9RKdO yZmN1RMATh6cns7ZMpojai55mK8niES2zSLFRyXI49g4HxIyhIpTJeUc051wR4YYqUE+HSXs ry//gRXcDRUbc7aJiEA4126ir8IMmGKntxhHUVsOzr9MWvdxi2+RD71CRvh3EN1Rmcuj0+44 P282Myq5W9+t7Xx6A4K4iIfFiDV1W2CoLGRWvYUgAuMP7YKFyBo6QMjfJlPUcuWCoWn2BoXf p/oOnkS8WUI5DfLxIusQ6iBrqAN9oDNARLSajk0JSG6rgbNaRuM2Q7DuxFqRcH8e9IfIptPN ORiwsF/HLy/fX9/G5ycrRJ3hZCxG0n1cqeHiUwdsZ3EY6RICnufVzol0CbQhv+Q+rqq85C7X 3C02FDi0aeE+x07yHA+6cwFwfJzAySFPIMtAgR9nwYvAU40w6lWo9ng6PY+wyfGVncYrp9UE 6ZdUsB3cvqL56ly9kOwlHkvOAOqmi6ky7mdk8SzddjnJZE3XjDEFyZQCT2h0duZkbaqk2ZrG RPk6X9VNLjvg6gKOO+mn9eEO3ZFKyUSTLm4SshCNmU7ovhAFox9XSoLuK3Hf7fkYN33wuIan QurtQYg6tmPWxu6VYY3Kk2oD73qfoV4JfKtkw7JyjNugQ+R7+Dvvkpg7lzoNHVd3adzS3WB5 J46APgW8of2VvLtKCI7rrxShBLCDyDVSq7g5ctRgK71WHnRi+vX58vJu6USVWqMT585/pevH fVWdSof1qw5JhhxuQW4RVSj4s1rtfOpMFg9DOOiHnXfIv+VEeMyv0YdtHQdcaq/RsHlebqHm 3JlBgLPP44YHL1MbjupwL+SpJ9TmZ67vCBqvJe+jh5Y8nAOffPDCL93LyftsDmp+7CDIQJCv BF0c87QoOie8j/wjctzwmrhV17qauEJPoxXdnImDtcmdzMuam9S1GHg//eR9UpeUXe0GTrE5 +IdZiOBs36q7V+eBcyAOXI5b9L5d0T50yWOj3ATiSn6FdYEBpvw+c4lLLZyga5oim6HCwx0c swZTZ0fl7V7UorTj05srrA4GSvZp4NLqkeBq9rW/NU0NfxOWxBxI9OOSPT+9vX5//eP9bv/v t8vbf453X35cvr8jURZ1uN1/3b/1eZ/dDoZ+EEVJRMjTgASyzfi9P8RyH6+Uqvn58tIfBweV hejD5gV23SyySoTTPnb7WkDGMaRnAOyCurJghfh1MY1sjDoYkrK4UyamOsO7thIA4H58fhTp 3rp5pWuS3kNcZLeCW8x1QL3nkZu2U1dCnVfIf+DSP4Ra9r55V/kHcDazjSuhKqnz//yLMMG4 dZn8pGQWQO4TzRFiMHI07LPNN19PfayU4qGBnFZr5FBMmUfcx3ImaI6MHdzK5NvCJUDclu5c QkxUl+6Y7kORx4YdbIWOyFz/zK7NHxM3eJUhdTnHlmJSreeZNVT1376f5kDVh8NqJio+QRrF X6PJfD0CY/HZRk48KCt4Guo1w4TsfEHNjHeqSzTzh/3ZhsP5scsq/D6TgRQ8xpJCuSBlHJl6 Bo0lNutpFJAr9dTSiY5+LS2z4606ZLgOR7B4sXNXcYZ7ZPfrCbppZQDryM7UbhE7O5i9od/r n3BEi7V+2ACK2uXn2Ny796un+bI92vogclwhS5tm52UA6MfBemll+RoW170ZI8dMd7LjCcs/ uoTVTnxYdmZAx0yLPH5Qz1+HchHXzCtzV+zi5FHkLjJO83afbe3K5JBX0tzZ9cjM8SeF7HP8 lByEqDFfAwiZ25VxI2rL4V0RrSvBaANpIYV4UKXjhFAWeaWSYODtkKWZXFJYZqh8PqiAIraJ 40ZoaAL7CsXjLClqRyVZZKo2FoIzFryPs3q9JnbwFGCkWJCP2HbvG6hZLqfRohGud+bALnNi M6QHyMmREck34GCh7trtfVHixuL28Fsh+ME0OVL3HiAgfoXjKrRrsq6p5Swlui0esbfRwSWu HdkLERgV90600MYXVIj60cQZXTEdyE8WlTkrFnBxu1cP2gMJlVW1CAxXhcrnhTeR3/AOiMul rfxtOtlY5wOGdV/Cb7P5KmA5g3sgdRws/RNcB3fm5itA7A9VBpckbfNKs1W842NeBYyjHBs+ Tf4/mUyi7ug6mmpmHd8LuWq1ukvT073IUlhMNycYbz67OUBAu6JJfUbr3ucwjQMxLSWlylPM AUuDxEF+Kszh3SzsnoNKXCJNrPyhz+WJFMSkCeWrEaB5Unaup4sul2s43AdAsscGjwlrOiKj BvBgH96Lmu+LJO4SYcoOWXst0tfNJkPH1Yuai1LWpN4c2MQlUrUBUWIVt9eXsYoPPfJ1EJDV b2QgQnXg9Y660DsEq6WqLrahUzdyMm77Aq/CGaXm3lZRSUAlitgNM83K81gSDjmwYiFa39PL iGN6UKIbkjEkFjDQKUet/NDm7Lfsu6ZoMLe1dN9Ko2V4g22VKk7Ng4YZGA3c6nMNoJ4lEsKH DlbFHZFRUfEgVTmE4xy8RPHNSjkHxVWNd8CAqkvZNHIsrfCTbH5ot9JWuX48NpfAiiQt7bjC hiIXRbk0xC29qfeMDNoeEIaK5A7RB6NfX5/+sr2s4Yiyvfxxebu8PF3ufr98f/7iXjEtUuLu ELyFN+upZyqYldQHX+QWt+cZrqRKdi+XOMSRk/XVI65lLmozV0kMsTL2xZK6J2CheMrwMxYH Q0QisDHFAo9w5WEWU6zzgTWfEyKQsOka3Tu0MGmW5qvJkmiKlEdyLu1ScpHXA9WRd5mfqZTx HpTHN2G7nBXVTZS+5n6zjSPWcDTRC3DFqVxO3NhKQC75dBKtIYV3mRW4D6/1CvrI1AJ5dz0w SH2WU9JNKWfScgvyDzu1j9VNaaIkkI24uIf4Rbh3lUKkLFpNp112JHrfYKjLZYbfLSnHAxvQ 7WJBNJ9Bkbcte0D6uKuIXCg9ZN8SCsTwKz9RWMAff57jp4jAbqWkJpAk5fYA2RdysC/T44xY hPlQ3C/KQy02ROs5sCXhI+OhVh9BrTbr9Bh95BuWEZG7rM0hXNC+4HibcXFIbhVhYT7ydUnN BXXZ8Qye9Pj0BI8W7LxmxPju2cRZSM+mpU+xnTt42n395cvl5fnpjr+maCDZopJqSZq36e6g fAqInDc+LFrgTuc+jmhPH0aIiw8jHB5s2Hk6IQTKRa2JO9c9SkhTNujLPmA81qbWMkXtRaRa Xm6bVyoRrLj8BcXZPWNrcxGtJoQedlHT2/aPWK6WhD52UaubagNQG9zn10GR7kQ+6gNvXE+p 2cRFLT9Qr/V0hTs1e6j1h1BEDCAXtfDTpVHGsCMWluSYQwdtMP/99fWLFMRvxp/Xyez7Ebil u9Sqk/F0Np11rCGW+ralUsgn0v2IgaF6lLYejOfDTctMbx7gqltHQrfgI7DoQzBIIj8O0zb1 tiDiUShdrFfDdbptdoR7Dvju4C+yXwNOjpZR35Pkb3V6zzFOA6HklHvXGHc9yt04CbrMG1P8 TNvqKan34syTHIPSMaq6Y3ogFiKfHqsHYnLbn+SSoYIPJnQpf/3x9nQJ/QRluflRdMU6Wsyc z03KbKAOrzGG6sjt1d7GHIEYD+ExRO8fPIY5Ka8sGrAVgrUTKfg0pDg34P5FA5Tb8HIEUJ/K EW6bjbWDlJn5WCtI/qKQa3kaoYP40XztRDwCqJqUrUZbAFK4QeYTIdIRlHEMHyunvOdt2mUJ BEFXg4gYKiZF9linnPnYJ8mB0OZjnV6pZhNSuuLmdo1vqnAAaTfEEh+bccuOK6Y2Nb1AHleI YLA9XuA7RJpLbx+pGpjtY2pt3DvTj4gyLJm7thlrXHA4HBFY0Ncj7L1mdinDP2UAMHEgvKKN I6BcXuCfORQhCPnKTRPI5iRWkKbbz/ictJc2sZRz1uJJzgc2kfDV8Bu8crpmcpGinFhSMSqY HDL34ruysUilLE1Hh/5gw99EyLrUhPD1EIqv0khAYH6Q7eXcWw45Npg3QQ0HMXFRJrVzkQDa h0kaLiFyClQv9BGG36TWDn7veg4vsH396jJut6BFpHXS1wB9m/KljZsUYkjQfupNltIV1qpD Pk4EbgIXX5Y9jBQAdgy4z5MAGJbk4+oTyNcX0vo4YEk09O3zy9+v75dvb69PyAWEHLK0BdfM B2qXUjfNe6E6NgepjsiYXkJtDKMShdRL1/fb39+/IFVtZOs5tQSC8q1EJEgzK/tSvaKohtyp tIIkBwg+13KR7KvvVNPqSMj1DOfiQUdIOb37mf/7/f3y9139cpf++fztl7vvENrlD7mUycId DbBbGtZltZTuKgyg2S+C5LIK2w/Rt6nSuDoSSxMDgPVNHvNDS0SlMyHZYJgV1ZaIPKZAjACZ FsPqqz9Eb2wT32Giu8KRk1S2+GrOwvCqJk5ADaiJ4psFjX5GWFtbqW+mSiERF14GPt+2QYcm b6+ff396/ZtqCXhOqipyk1nxsTgKfaJ1rHydH+nc/Hf7drl8f/r89XL38PpWPASVMIXcguoY L//HzmNfobb40DoGT+q9P7kG+OcfqkSzQnhgu9EVRNXk6CuRwlXp+QvEqbkrn98vukrJj+ev EKdmGLNYBLVC5GoY9L4MpT9xm7d+vHTt2mxtoqCj3UxBpBqWijwmpj9gS3Fv43SL704AoIG4 MaeWiOluFL20Qm6wCYXmIBkLyul9qbFWUM3w8OPzVyna5NjRRgB4jlOrcz0ByEmtIyKXawBP cJNUccuSmKIVV04luO+/4nKWAYIGnNKKc1p1GTMHlza0edwxObaLNRhsuxZPWzsAbnSvUn1j +2B1OtznOtalgNDtaX1oglHk42ejeBvtbAmpdF+IwtZO+c9fn19CrdO7TyPcIYfsh6b6wdxV /qjgADVcMNJ/3u1eJfDl1baDDKvb1UeToaqrqyxnse3kbIOavAUnDMhoQQAg3QePjwQbAsDx Jiafjjkvjrlfc8SckUtskxmxUyH7DZJYjasVxEdwen8FQQWtO/jVXfenbEZfuaomfABQdNMQ i1gXPQyQbIs5S+VncKLrGzH/5/3p9aVPnRhEQNbgbsvjzXztnOUbDhmjzfAH58HZfIO5jxgY i8/T+WJlhT+8MmazhRUq5EpfrZabGVKlRlSL6QI/qTIQrQXlPKPc+elqtWK9Wc1i5CWcLRZu iBiX3+fyCD5IMqRmgLwKkXORXl+ZwY0K9PJVc7KWDv9f2ZM0t430+ldcOb1XlZmxZMdxDjlQ ZEtizM1cJNsXlsbWJKqJl/JS3+T79Q9Ad5O9oOl5FycCwN4bDaDRAPzwQ6UhMBwpDbGojYbD JGuKoI+AIgj6KhBe1FnKX9ASeiIYF+K1/S9IMBGCAdHrdLHhbRGITfPw2ABT4O9hFHLO35Up bN8GzlfCyyekK87nkPCXzdn82Fp2CJ64akb0hRD5IuKS0iCWgsGeuMsD1JjZOQisTRwepHC6 EYk1XSM1hPV3RGQ4NAdhUXpMA+4i8nM/IaaBplizdiwaAgeMd4gzPEjgeOLFMaILZVsmpLJD hgx5RKPYcpBgSlghfDY/x7iqYYJQKG9CBkNLDNiQwZoI8HIiiA0H3yBsKuKAMK/Q6zpkp0aC TYqOAQH7LBF4wVGkKldfHt2CPGS8cxyP86xfpmxE8ShBGyB8a4XaURMMOzdGXBVgaQNdfTn9 dL2+iWZhKj3VVB9vGm7gPD7GEqatuehcHKDRTVmfN+F68IlvV6TVOsUIomkSSO2BHA9Im1aE jMdIULShsAxKwsHa4GhepEUoGG5ZFis0AFUx+kMHlEx8Gex2Wmvg7powmgiS50XPp96SLlOj nm3bMBEXteuA74fCXzWzUGBKIiBzy2kgYJekCB+limAqsqVJgb/iiFfulHdYyGVYomE6A2Hr CJ2hr31o1RGBPHcmKPJ4XU3lwlBU4UhPI176dIIEPzUyePU5gZ6+9pM0g+L/Hk2VhJgDkrzn 06ioblbzDKVJzCgX1NQlbdCpWqFJt5simHDKUBThyFKEH9y7JmjQnYFFK5cH7bb4nsOhpnOd F2UUv/X1UfP25wspzKOeo0JwuQn/cGyHmXfz9ikayty1ytWnxodxVMiI0ZgK0M5WhWh53R/K Bago8CYnBckkCWXmU3RfpktSplyk4dI9DE4amOSRGwM5mJNVyHl5l+TzeyTInfAImOowuq7C aVLQlASEGiDTh+BUhSAa9vPzIqd8lZxUadJgbe40InKqgjyvTt4ncGu3KIhnyJyagRYaFHai c6qAXMrgxAwIUEBSR3QbNdVMisgD43ni5QS0yQbjA/0KhNOyKKFhAbEbqJRgQJtgA+IHz39p FyiPh8klgYE+MBji7GR2jIVO7aqB9PR90nR9evx5ejOThC35dXiqSZCefTntq3lAkwCiJDqX ezlMkZ/PzqZJovzs0ykmGksCz9spf5GSeIKJQfFpZ1oJLlApdQdaMJvPjt0lKRVgpbD2Ig+8 NPNJeRY80iEjxuJcBqZ86TiPOSUY2gfDUDIaLGOKDDXKiUkmoLpvIqAzJ47qr6XS2AhOAD9Q BvqqUjFX+2f0Ld3hE677x4fD6+Mzq7TUeR8HvN0Rl+TxGbBpz0youzhRyyDoRo02DUYPd8+P hzsjklWR1GVqRUlRoB4k9gRdVdxrH32RqYrSJWXpotgkqf1MfpHR1RE0X/CSWIFxjdjMRwk+ 0UwNe9iiNR41y6ooe68HpKTJiy7NTJN2ZLl/YJsAxNWrQu+bP30znASTApQGOjZQlHHZ8pqy pNH2GoE+E1OFacLp4tB1LlwlWmPEsgvcUckSipSi1ZTBiuhouly6zbWHDC2xTRJZufOG8yHc hIFkupco3rw3sJI949NXflQHHfi9Adksz+BomRhU7b/wXkFNscHETCv3mk2bCCjo70Qp5Obj oa0q6lzk/kqlxNrFpo78vNnr7dHr8+728PDdjx0FI2iEOWpzTCnRlhj1z04oOqLwjpZ7yY8U lEbXLq8puzoWOn2y8Wx8xI15a7gvlyCNx1YIQhUzYM0yLaaz45dBfagV3HhXsAIr6xSBBYX9 p6BUvM2hSW03NPxN11TunYvGZ2nuRFJCkNyBroZoDEAdy5gK7sBoODKmgJHJIKJaygY4Dy8c WsSMqXPQ4To7/evs+LS/7KKkN3IMUFl1V7V9XFiBIuQuVl6lRcCrVJk6p6kwRuSl4EIX5KUZ 7Ah/Sck7sTN/Uvw4z6VNBzi0r9tkgqnDz/2RFD/MO9gYdE/Rb0vYzDIrjxU8D+R2DPzRLxuM KNWwV9GAS+3oluKqnfdOWh0J6q8w4EHARNee9EteVgTcac9GYPu2SIxQJvjLT+deixRaDpXz JRDCpEcIpgK+ghHhFjXiGxF3ddoaLAShXtXfVGzKFH2x2QhyXu0IUQ6Q/YaPx4skl13ZBiK8 hppvUbDJbhFRFhkGCXXyKhkYjGmQ1jbKiY6GoKiBQcf4O22UGWGjls28tzNOK1CPr0lApe6T jDvJy1h9aQyVhvXlPObk9gE/XPyDHNc1TmrvgYqCiPK6CpFQJzFZ9UVWcrzFpDKTIC1aufjM SjXsnZkayGCTxhfqLUEoZ9ZAXHcFsMAC6GSgMc4kQ7TOtEmgnDi/+TDxy34jahnWVR/paTbM i+YHc29NEwiHl9+C6gvJHLzv3h0kTaX3ZJhIjmKAychiKE6f1L7SgDlR14eBZGrMY8bGKyOq tMRej2NzUxbCWws4Eaz8b/bc5K7IG8wR1xCV4Lq0I/RgFF+9ufhKREHZrNPSiMpkgfsoWzUh XCrZAv22aHCt2HnfBmAwCvBIgUpTm8JCTldF1Ha1sBrAhBeWIFYIIQxxAas1UfAT4q4mLQEw risZskhAwMAwvFkBU6+rL7ZRXfDjLvHODpTAthZGzJjLZQ4nwcwFGOEV6au4NdYIxtNcNqdy oVkwC4TSuwWIAWBEqZWxc+3VWsL8ZNG1s4ukGWF3+8MM1w/DNR5mBs+QYDtk87IhScQDDHTG IpKI0BIiLC56s18DzDij9XsQ2WrZg+Q30NH+SDYJyUueuATS9Bc0Q5tj9q3MUjv83A2QBZhM lyw9/qPbwdctfdHK5g84Sf8QV/gXZEq2dUtisGZUMfjOmb7NMsiFo3YIVBqXicDQuV9PTz6P XEaV/8uG6G/SEl8wNDAUH95e/zo3UhAWbUj4QsyJ00IJOztdpK0+roNfZjdX/RUxYUvPVKWG zg0tJU8NqrSbvezf7h6P/uIGmx6VmKNBgAsKaW9aBxG6yREcYBYlPXmC7cvpdYjFiQCBH87z svaKjtdpltSCO4HkxykI9nW8VvmPx+ZeiLowm+9kbmzzyj7DCTApF0sK7xCXYGDCiQjkl1h3 K2CsC3aF5CJfJnC4CCv+IPVoHTUUhrRoUzlIZqgl/MeTQ4AFbKI6tAGZ2TYULozLSxyEgsXx uxs4G2hSFyE6TWUmKIEfQ3jqD4eXx/PzT19+m30w0Xoz9rAZ7Q8HzOcTw7XRxny2AmZZuHPb i5EnsbJnOTj+6twh4i/ybaLAjatDxIWCckgmWsumanRITgOjeH42MYpn/NtLh4h33rCIvpxw Lqw2yafjwBL4YmZDtDGnXwLfnH8+tTFwcOECNI0h1gezebB+QM3cMaJMB4Eu6apmdlUaPOfB J3x7T91p14jwCtUU4cnTFOEFrCm+vNfHQLNngeGfeavtokzPe/Yc1MjOHjBMrwLiRFT44FiA YB27IyYxINh2NWf9G0jqMmpTttjrOs2yNPYxq0jwcJBzL+wRQHAKDYzsCPUDquhSznBh9Zht HWgQF5iXyqqta5dGHr8ks0xs8HPCvbkrUlz6nLpR9ttLU8C0LG/y/eT+9u358PrLz7uiLpGG avA3KN6XHd4jkRTLHfSiblI4bUDrAHrQPkxlTWlqIuHK7pM1qIuijsJh57RW3Se5aMiXpq1T NkKubxPTEEvO0OWpw9IQoJCNUDBn3AhZpBRSvyX6mL1asmFVB7oqao0Jp6icIKEmooDBQGUw LqtrmUAhas3UDR7RBArE5izDSKRmS30qykNRBUJhL0E9QgVV3iMErMpRS64mos5h2a1FVvHv gnTfm1y2iYX3C1wkXcWOrqSIqkpgtlTUvgMZQ4Yv2jIvr3nPiYEGyoug6YHLJk2VlVHi+L66 JNdRHvHtjpbomZVykbGNCuKLpNwWfdbkbCkmQS+iOuPNSWRoITqUo0WGcxhj1qNAOMkAPWvQ m/6EsLC6gAlnjnll7ASwTzc4j3VTEjYippiJDssRlC0XY+LUqIMllE6IaaZW/7yVZ1xwOxQJ mzYLZ+TDz93DHcZn+Ih/7h7/8/Dx1+5+B792d0+Hh48vu7/28Mnh7iNmof+OPPTjy/0O6F/2 Pw8Pb/98fH28f/z1+HH39LR7vn98/vjn018fJNO92D8/7H8e/dg93+0f8NZtZL7qXSrQ/zo6 PBxeD7ufh//uEGtELopJ4aBMJRsKsZ5ieqYW1FPDbMZS3YjayklEQPT6uwgvGIMGGIyuiLVu WYRsXWTBgwUxTAVrsdSkSziWDUrzKAuMkUaHh3h4TuiefMOVAay0hYygZWR3wCxkdpI4CQOt MK6uXehVWbug6tKFYPazMzjG4nJj2IfwiCy1Z0r8/Ovp9fHo9vF5f/T4fPRj//Np/2ysBCJG m2hkZqexwHMfLqKEBfqkzUWcVmsz25WD8D+BRbdmgT5pXaw4GEvoZ07SDQ+2JAo1/qKqfOqL qvJLQMO6T+qlALPh/gfK3stS4zMgkjRk/haXarWczc/zLvMQRZfxQL/6SlrEnTUm/2FWQteu hZldT8Gd7D5qHaT5kMGvevvz5+H2t7/3v45uad1+f949/fjlLde6ibzCE3/NiNhvg4iTtdcG AFqZcjS0TpiKmtwfHzgMNmL+6dPsixXD2UViggzP0hy9vf7YP7webnev+7sj8UA9B35y9J/D 64+j6OXl8fZAqGT3urMCeKriY05w1JMf535j1yB7R/PjqsyuZyfHn5idvEoxC3sQAf9p8EV+ I+b+fIrLdMMM+zoCnrzRM72gwEX3j3emjV23b+FPW7xc+DDbNjdA2URPuhkLr8FZvWWKKZe8 P+iwIRbcua+wV23DrAPQUdxIDc7eWw9T4jZyRPGjbuCjzdWcqT3CzHxtFwgPrIYHH437nky7 lx+hqcIcpx6r5oBXclbdGjdO2lF5Q3D4vn959Sur45M5szQIPKSZYZA8FOYw49ji1RUdQO4I L7LoQswXTB8kZmLVKQLc/QwLjdvZcZIuuUZKTKihK/agNHa1t2j1EsE8Pbb92jlYklOv3Dzx GUWewrYGaT43LSKaR+fJ7OzYZw/raOazVADCum7ECbNwATn/dCbR4SYD1afZfCiEK4KrFr5h BgoQU1XlJ35ReM+5KFdMYdvqE5sn3ZzFnmYYk6jpZSwZ/eHphx1yVPNh/5gHGEbRYDa+aIaC w82Iim6RMqXWsb8UQLbdLlNm7WmEel4UxssF6C/5CDOdpP5RrBHvfagOJmCB/55yHiZFO5Xs CXOqAzYQKNogMJoSHnukZDgDQs2uuAQJswoAdtKLRIT6tHRcG/TRtI5uosRvgpIUgiJEqGmN EL5YCCJsJQpGApRwOtjCBUoaazi8bTsSzd8d9Cb3Rwdg768giyjY4FZETAvbbYnrP9wqRRDa QBodaJqN7k+20TXDkDQVvzQl43m8f3rev7zYVgO9xJaZkxtKS1I3nLVdIc9P/XM4u/EHDmDr mCn8pmn9WED17uHu8f6oeLv/c/98tNo/7J+1qcNjg0WT9nFV8660qmv1YuUkQTYxSrBxS5a4 aGpaiUTKqz7CA35L0UAi8DmRaa81VMEetXV35DSiV/KL284Br1XvKe41EE8O2EBFFoFgg0RB +mm5QG/0VnAnruuv6IiUeEZi7D/HrPHz8Ofz7vnX0fPj2+vhgRFQs3TBnpYE5842dRu/EUSi JDd/kY44/R52isbD2bVIbsoWIFFDHVw3pr4eNc/JEkbtlUNz5wzCB3GyxiTAX2ezKZqp+oOK 6Ng9Q1vlOhoQ8AiVnzLrbb1lFlvUXOe5wCshuk9qryvTTWNEVt0iUzRNt7DJrj4df+ljgZcg aYzu5tLX3GxCdRE355RkGvFYStAfHUk/67z3gaI+y4dZUA5/H5Gu8PamEtJ5kpxesWWOp6fc VfvnV4yFtnvdv1BGB8yQtnt9e94f3f7Y3/59ePg+7rC8TDooEMrHur9+uIWPX/7AL4Cs/3v/ 6/en/f0HnprGVplxjHcAPglZZrhLEPJIGez56qrQuCPy8M3XDx8crLhq68icLO97j4IyY389 Pf5yZl1VlEUS1dduc8LtBr6A+f6aNtjykYJ4H/4POzBWKslqsSnlZBIJ74z3L2ZV175IC+wI uX0uNbPNglxWGqBNw7SG9AtRxHBgmpei6Fsb1UBSrEyWgrFErCFYpKBNYe5YY0J01AFQtIoY rypresZtWkVNkkwUAWwhWsof2fioZVok8KfGZ46pKSSXdeK8Fa/TXPRFly/4vOLyEtp6LKCj JsSp+8REoxwwnRHo1Brn1VW8lpdotVg6FHhFg0nFZfbOKkvNTg9lAPMCCagoW3k7bnLKuI9j EDhMvhrPLHUk7n0TBTS37XpLk3AsLWhiaUS2VFZfgwMTBjioWFzzoeAtEl6GJ4Ko3kauOIGI BetYAThbUI/tX5/NlbrwrU2xYRBVRqJf44QXSZmbPR5QIPgO7vU2NBE+/AbPLJB0lIhtQkfB W7fyphxLtqBcySBYs9QgbvNws5SxJSCGM+QE5mq9ukGwOUUS4prCXTS9Jg9ExlUkacTqdwob 1bnbCoS1a9i0HgKD58QedBF/82D23I497hc3qXnRY2CymzxiEVc3AfqSheMY+1yD8flYxMbK bOEMawQyAg7WX+QVC1/kLHjZGHB6OrDBHI6Wk/9VVNfRteRHpvyE4buB/YDQSwQjCllYWlrv wyWIHo5ZTBHhiTWceaQeiShAQZHCJQJOgZXpNkM4RGC8BlQ5XDdcxEVJUvetdNo2juVtWrbZ wq4YdRvvnZyFgJZwfgaqCcwZ2awyOaUG58Fg/tYoJJfmyZKVC/sXw4SKTLky6zKzG3RPMuay vkQ53Cg3r1LgOuNvjF1Q4wVQWxtz18XNHE9c6wAnzUYv0E3SlP6yXYkWX5WWy8RcCeY39DbV ShawLNFK5D7BIOj5P7MzB4R+CzAQ8rXuMLrQyTJzZh0XFUZS6K07cABgd00rzEDdyfel/TLr mrXz2GMgImepPHYw5N6wjcwcyw2stNwOnIEORgEPq3LxLVqtWEnPE9RsZxEtwBP06fnw8Pr3 0Q6+vLvfv3z3/fdICJRJawxhTQLjSIV2013AXtGbcRkhok9N+598hg4CzCoDuS4bbuI/Byku O3yHcjrOhdSAvBJOx3FBnx7dvERkEa8OJddFhDHTQy9uLHzvvoAAMWpRou4n6hro+Mj1wZEd TGuHn/vfXg/3Sv5+IdJbCX/252FZQ030+urr/Pj03HSkq9MKE0hhu9h03gIjNDYypbu5txv5 JBBfAuRRC6sSS8dHsfYzNPn8k1y1ll0Rq+dzoFD2TkIacxXol9bWztnkIPx3V72zzM0atiK6 QPdP5He8HvNvR47GmYyBh1u9+pP9n2/fv6MfT/rw8vr8dr9/eLVD9UcrmbCn5sJVGy9h3cY3 xK+3+HfiQ3LSILocn+1PlOO6UZk8VR7Zq8S6hsTfnDVjYFaLJlKPaEF57a2FQDhjp8bGFwvM mdIEkPKMH0hGX2LjU6ZRqi3rdNn6XyXphny+eCdlIgHmR0ERoCMTVMAK+Oe1Ei2KjnOZmBon MrHIwbpnZiS2RpEQBCNJOXWCYBKGXeH/as3aK0v6U5ryIj3sTptYa+/Kz20ozGDwyFJBthNF Y21WWQZitSTirNUBpS27ih3zr8KwlnIbClNK6KpMm9J9XMpUiu+2J0jqEvhORJM1tSEk8fbK 7bEJGfT1NulMEVn+9g4GBaZyAs8lZR1yAbMxTLJu4b4kpZWkJhrkkQxYpD8bGjNRq2TMHZ6h XM0gvySKBh2l6Wk5I9DIsjZ5X63Itd0dv03uQ8jDwxaQBlS9YIDVCrRc0+k/XKvbsLRuO7K5 OL1XiInxkRHlyWuUpVJ4emNNkY3quqwnA5vJJStPMzz1uBnX0weaAOpwrliqJN3GoFBHpa0M OKVwNAarinxWNSJwthzlQzJ9ifWN+Ca22YJKsfIPDHzfgMEwinLkraBjOQ9dqYzpc2+J6TTH 4vnf+nmBHcJM4yJKzaEV16+z42OHAo4GvUe/zj998somTZxOA+J4zddjz6N45LT2FMGpV4+5 RJDoqHx8evl4lD3e/v32JIWZ9e7huymDR5QjEA4+S8m1wChwdeLrzEaSdtW1X4cOovmwQxbV QudMc0FTLtsgEqVqUEai3CSjGv4Njds0fEziVEWZUMwFOVDICBfYD5jSvGJpjAZbioBsjkFI zWGWV5hYtf14nESsql9j4Mw2ai7MHSj9ywfUMPiz+TFT0UAWHEeHZBjGoY/bSxDZQXBP2Ogt tD5lX8jyOoRSmlpz8jUXyNV3byhMm/LCqHHQSRHSnSRWXdOasDHugXadZ6pxmSeO4YUQ1TtS QS1EXvn5FbF/hgD1Py9Phwf0OYWu37+97v/Zw3/2r7e///77/467TT5TwXJXyLBGU4Nh+C83 bAQS+3UMdjjI8NGm1bXiSniHnE5E7YlzPPl2KzEgOpRb+4GYqmnbiNz7jFrosHl6KiQqD4Cm 9Obr7JMLJnfeRmHPXKwUJZQ5gEi+TJHQDZekO/UqSuu4y6K6v+xEp0ub+x2yGi/BUVuiJt9k QjBKpw7RRA4Ryl7GHdI0WsBhMGyL48E+jv9obzO2ytL6jL/oaBJZwTZKW+6Fpjbs/D9Wsz0I cOQ48tRoqjGbSwYAfHTTFei8BftYXmmExRZ5Strn2d9Scbnbve6OUGO5xVtGK00WDX3aMApw 5V9g2puDNdcQSstlZqAqlLVBpUR9AIR1jICX2u9/Jltslx/XQr1SGyK+wqrkVCproYy3Q3HX YxIBdwEhPPwFxqgyvrJwKFWSTWc4auYzq1Q1vwZIXDIBY+xuOOzlUomSNUmxtkF6DUdVJjWL VujYxwb7AGgRX7elsSvJHcgwFPrBdMpKNtx6v7oxjE/T2FUdVWueRpv1ls7AMMh+m7ZrtHR7 ehhDlqQ1CgVoDv035FHtlarQOUVzpLdcdeKQYEgVmmqkBFW58FTEJTqLXTtA2KBtWWaqaAcZ q6pcpBw9zBnmriHZztg+n9DuD3ttuTRHXOZWQ3rrVgAXibhq8SoFTY7uPHn0WgUPEDI3AU6L UZ6iS4Sx6PGdsr2kQg+V9RkVyNRSX4LEu5wiUfIJQ2IJTd6i3cIO8qBlU5RpI/wRwfic1gdj P9Vek0uIO+DUjDcFKKmwq82PHdSgzzZb9hnLAo4MzDVTl+RqhIZMR3YiuPJDwGe49EEgqPpA Dit/klAHw05L2WCmZRdQ2ELIhWmbK00E16VqOX6luaPa2C7cqcMoQVWP4cbqNBH+UraU9ea6 AFbhloPpHoA+Xa2sc05Or9xx0h7h4IhfcDeNxtbl0LrgKKOrSpwKbl21ERxfVVjCMWsJETOk Q7RW2r+JyNrIGmnaVHhnSTc9zrFqDCAykd4VzczVMBBwpgdzyN3wdtKU0LiAPuquMC1bZl5r KpQxV4brhIWU91cBpLw2d3GjIObAqZd+RRe1aAOo9RZ2moguaM34Hy7TZWmFEJZwlfI9S6Ff HIOTVPLX0q80loGOzffOujlpUkdbr2M6IoAlbUtUlSZLPq+bHkjklOFGdmvz3lIBN8sUnz8B h8kT9DxbMGNgB/dno38NpflrRqvyTI8IJZWfaZO2jIuvLpGElXlARjlRNJ6m/M/5GSvJ0pLT 6kNfYNh598DF1wPA0xYlnEl42NpROCjihFrRTNvFMkWTbq/s6672ny3ocj1kEczztAyIkWmp uMLx1bmVN9RACH6VDBRd+AZ5oAnGO5A9kPfRaM5hHduryJDGrQ9JlgvrOnnK6ps4F+omMZBZ sSu2MvUECPXTBPLGmbgAu1sGwlWnrbhKn7AXk+l+0O5fXlF3RYNTjAmUd9/3pmnpoiv4cEic zd26rqpynsgInCRa3L7vUA0ioV/TeOyFY+q6W/ICozK4tvAG5Jhyo5m9dbWG9PwRCgI6SbEw 4yQsiKILVYy+nrDJ3cWhQNxmugahbqPLNqdyat4cu0GeNg2Fuy7jLnclKcfEsEjl+PJxCx1f lf8DshdOQJFwAgA= --2oS5YaxWCcQjTEyO--