From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) (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 66EED2C85 for ; Sat, 6 Nov 2021 05:05:54 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10159"; a="212072482" X-IronPort-AV: E=Sophos;i="5.87,213,1631602800"; d="gz'50?scan'50,208,50";a="212072482" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga106.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 05 Nov 2021 22:05:53 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.87,213,1631602800"; d="gz'50?scan'50,208,50";a="600813864" Received: from lkp-server02.sh.intel.com (HELO c20d8bc80006) ([10.239.97.151]) by orsmga004.jf.intel.com with ESMTP; 05 Nov 2021 22:05:49 -0700 Received: from kbuild by c20d8bc80006 with local (Exim 4.92) (envelope-from ) id 1mjDtk-0008im-CW; Sat, 06 Nov 2021 05:05:48 +0000 Date: Sat, 6 Nov 2021 13:05:24 +0800 From: kernel test robot To: Valentin Schneider , linux-kernel@vger.kernel.org Cc: llvm@lists.linux.dev, kbuild-all@lists.01.org, Peter Zijlstra , Ingo Molnar , Frederic Weisbecker Subject: Re: [PATCH] sched: Tweak default dynamic preempt mode selection Message-ID: <202111061341.QdauxAuH-lkp@intel.com> References: <20211105104035.3112162-1-valentin.schneider@arm.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="wac7ysb48OaltWcw" Content-Disposition: inline In-Reply-To: <20211105104035.3112162-1-valentin.schneider@arm.com> User-Agent: Mutt/1.10.1 (2018-07-13) --wac7ysb48OaltWcw Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Valentin, Thank you for the patch! Yet something to improve: [auto build test ERROR on tip/master] [also build test ERROR on linus/master next-20211105] [cannot apply to linux/master v5.15] [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/Valentin-Schneider/sched-Tweak-default-dynamic-preempt-mode-selection/20211105-184135 base: https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git ea79c24a30aa27ccc4aac26be33f8b73f3f1f59c config: x86_64-buildonly-randconfig-r004-20211105 (attached as .config) compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project 847a6807332b13f43704327c2d30103ec0347c77) 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/4731291127aa2100c984229a91533b671044a74b git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Valentin-Schneider/sched-Tweak-default-dynamic-preempt-mode-selection/20211105-184135 git checkout 4731291127aa2100c984229a91533b671044a74b # 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 If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All errors (new ones prefixed by >>): kernel/sched/core.c:3439:6: error: no previous prototype for function 'sched_set_stop_task' [-Werror,-Wmissing-prototypes] void sched_set_stop_task(int cpu, struct task_struct *stop) ^ kernel/sched/core.c:3439: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 >> kernel/sched/core.c:6576:2: error: use of undeclared identifier '__SCT__preempt_schedule' static_call_update(preempt_schedule, __preempt_schedule_func); ^ include/linux/static_call.h:154:10: note: expanded from macro 'static_call_update' typeof(&STATIC_CALL_TRAMP(name)) __F = (func); \ ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STATIC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :252:1: note: expanded from here __SCT__preempt_schedule ^ >> kernel/sched/core.c:6576:39: error: use of undeclared identifier '__preempt_schedule_func'; did you mean 'preempt_schedule_irq'? static_call_update(preempt_schedule, __preempt_schedule_func); ^~~~~~~~~~~~~~~~~~~~~~~ preempt_schedule_irq include/linux/static_call.h:154:42: note: expanded from macro 'static_call_update' typeof(&STATIC_CALL_TRAMP(name)) __F = (func); \ ^ include/linux/sched.h:291:17: note: 'preempt_schedule_irq' declared here asmlinkage void preempt_schedule_irq(void); ^ >> kernel/sched/core.c:6576:2: error: use of undeclared identifier '__SCK__preempt_schedule' static_call_update(preempt_schedule, __preempt_schedule_func); ^ include/linux/static_call.h:155:24: note: expanded from macro 'static_call_update' __static_call_update(&STATIC_CALL_KEY(name), \ ^ include/linux/static_call_types.h:12:32: note: expanded from macro 'STATIC_CALL_KEY' #define STATIC_CALL_KEY(name) __PASTE(STATIC_CALL_KEY_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :253:1: note: expanded from here __SCK__preempt_schedule ^ >> kernel/sched/core.c:6576:2: error: use of undeclared identifier '__SCT__preempt_schedule' include/linux/static_call.h:156:9: note: expanded from macro 'static_call_update' STATIC_CALL_TRAMP_ADDR(name), __F); \ ^ include/linux/static_call.h:146:39: note: expanded from macro 'STATIC_CALL_TRAMP_ADDR' #define STATIC_CALL_TRAMP_ADDR(name) &STATIC_CALL_TRAMP(name) ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STATIC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :254:1: note: expanded from here __SCT__preempt_schedule ^ >> kernel/sched/core.c:6577:2: error: use of undeclared identifier '__SCT__preempt_schedule_notrace' static_call_update(preempt_schedule_notrace, __preempt_schedule_notrace_func); ^ include/linux/static_call.h:154:10: note: expanded from macro 'static_call_update' typeof(&STATIC_CALL_TRAMP(name)) __F = (func); \ ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STATIC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :255:1: note: expanded from here __SCT__preempt_schedule_notrace ^ >> kernel/sched/core.c:6577:47: error: use of undeclared identifier '__preempt_schedule_notrace_func' static_call_update(preempt_schedule_notrace, __preempt_schedule_notrace_func); ^ >> kernel/sched/core.c:6577:2: error: use of undeclared identifier '__SCK__preempt_schedule_notrace' static_call_update(preempt_schedule_notrace, __preempt_schedule_notrace_func); ^ include/linux/static_call.h:155:24: note: expanded from macro 'static_call_update' __static_call_update(&STATIC_CALL_KEY(name), \ ^ include/linux/static_call_types.h:12:32: note: expanded from macro 'STATIC_CALL_KEY' #define STATIC_CALL_KEY(name) __PASTE(STATIC_CALL_KEY_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :256:1: note: expanded from here __SCK__preempt_schedule_notrace ^ >> kernel/sched/core.c:6577:2: error: use of undeclared identifier '__SCT__preempt_schedule_notrace' include/linux/static_call.h:156:9: note: expanded from macro 'static_call_update' STATIC_CALL_TRAMP_ADDR(name), __F); \ ^ include/linux/static_call.h:146:39: note: expanded from macro 'STATIC_CALL_TRAMP_ADDR' #define STATIC_CALL_TRAMP_ADDR(name) &STATIC_CALL_TRAMP(name) ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STATIC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :257:1: note: expanded from here __SCT__preempt_schedule_notrace ^ kernel/sched/core.c:6584:3: error: use of undeclared identifier '__SCT__preempt_schedule' static_call_update(preempt_schedule, NULL); ^ include/linux/static_call.h:154:10: note: expanded from macro 'static_call_update' typeof(&STATIC_CALL_TRAMP(name)) __F = (func); \ ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STATIC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :11:1: note: expanded from here __SCT__preempt_schedule ^ kernel/sched/core.c:6584:3: error: use of undeclared identifier '__SCK__preempt_schedule' include/linux/static_call.h:155:24: note: expanded from macro 'static_call_update' __static_call_update(&STATIC_CALL_KEY(name), \ ^ include/linux/static_call_types.h:12:32: note: expanded from macro 'STATIC_CALL_KEY' #define STATIC_CALL_KEY(name) __PASTE(STATIC_CALL_KEY_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :12:1: note: expanded from here __SCK__preempt_schedule ^ kernel/sched/core.c:6584:3: error: use of undeclared identifier '__SCT__preempt_schedule' include/linux/static_call.h:156:9: note: expanded from macro 'static_call_update' STATIC_CALL_TRAMP_ADDR(name), __F); \ ^ include/linux/static_call.h:146:39: note: expanded from macro 'STATIC_CALL_TRAMP_ADDR' #define STATIC_CALL_TRAMP_ADDR(name) &STATIC_CALL_TRAMP(name) ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STATIC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :13:1: note: expanded from here __SCT__preempt_schedule ^ kernel/sched/core.c:6585:3: error: use of undeclared identifier '__SCT__preempt_schedule_notrace' static_call_update(preempt_schedule_notrace, NULL); ^ include/linux/static_call.h:154:10: note: expanded from macro 'static_call_update' typeof(&STATIC_CALL_TRAMP(name)) __F = (func); \ ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STATIC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' #define ___PASTE(a,b) a##b ^ :14:1: note: expanded from here __SCT__preempt_schedule_notrace ^ kernel/sched/core.c:6585:3: error: use of undeclared identifier '__SCK__preempt_schedule_notrace' include/linux/static_call.h:155:24: note: expanded from macro 'static_call_update' __static_call_update(&STATIC_CALL_KEY(name), \ ^ include/linux/static_call_types.h:12:32: note: expanded from macro 'STATIC_CALL_KEY' #define STATIC_CALL_KEY(name) __PASTE(STATIC_CALL_KEY_PREFIX, name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PASTE' vim +/__SCT__preempt_schedule +6576 kernel/sched/core.c e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6567 1011dcce99f802 Peter Zijlstra 2021-03-25 6568 void sched_dynamic_update(int mode) 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6569) { e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6570 /* e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6571 * Avoid {NONE,VOLUNTARY} -> FULL transitions from ever ending up in e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6572 * the ZERO state, which is invalid. e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6573 */ e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6574 static_call_update(cond_resched, __cond_resched); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6575 static_call_update(might_resched, __cond_resched); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 @6576 static_call_update(preempt_schedule, __preempt_schedule_func); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 @6577 static_call_update(preempt_schedule_notrace, __preempt_schedule_notrace_func); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6578 static_call_update(irqentry_exit_cond_resched, irqentry_exit_cond_resched); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6579 e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6580 switch (mode) { e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6581 case preempt_dynamic_none: 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6582) static_call_update(cond_resched, __cond_resched); 9432bbd969c667 Peter Zijlstra 2021-03-23 6583 static_call_update(might_resched, (void *)&__static_call_return0); 9432bbd969c667 Peter Zijlstra 2021-03-23 6584 static_call_update(preempt_schedule, NULL); 9432bbd969c667 Peter Zijlstra 2021-03-23 6585 static_call_update(preempt_schedule_notrace, NULL); 9432bbd969c667 Peter Zijlstra 2021-03-23 6586 static_call_update(irqentry_exit_cond_resched, NULL); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6587 pr_info("Dynamic Preempt: none\n"); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6588 break; e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6589 e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6590 case preempt_dynamic_voluntary: 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6591) static_call_update(cond_resched, __cond_resched); 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6592) static_call_update(might_resched, __cond_resched); 9432bbd969c667 Peter Zijlstra 2021-03-23 6593 static_call_update(preempt_schedule, NULL); 9432bbd969c667 Peter Zijlstra 2021-03-23 6594 static_call_update(preempt_schedule_notrace, NULL); 9432bbd969c667 Peter Zijlstra 2021-03-23 6595 static_call_update(irqentry_exit_cond_resched, NULL); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6596 pr_info("Dynamic Preempt: voluntary\n"); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6597 break; e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6598 e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6599 case preempt_dynamic_full: 9432bbd969c667 Peter Zijlstra 2021-03-23 6600 static_call_update(cond_resched, (void *)&__static_call_return0); 9432bbd969c667 Peter Zijlstra 2021-03-23 6601 static_call_update(might_resched, (void *)&__static_call_return0); 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6602) static_call_update(preempt_schedule, __preempt_schedule_func); 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6603) static_call_update(preempt_schedule_notrace, __preempt_schedule_notrace_func); 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6604) static_call_update(irqentry_exit_cond_resched, irqentry_exit_cond_resched); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6605 pr_info("Dynamic Preempt: full\n"); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6606 break; e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6607 } e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6608 e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6609 preempt_dynamic_mode = mode; e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6610 } e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6611 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org --wac7ysb48OaltWcw Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICJrnhWEAAy5jb25maWcAjDxbe9u2ku/9FfrSl56HNpbtuOnu5weIBCVUJMEAoCz5hZ9i K633+JL1pZv8+50BeBmAoE76kJqYATAA5o6Bfv7p5xl7e3162L/e3ezv77/P/jo8Hp73r4fb 2Ze7+8N/z1I5K6WZ8VSY3wA5v3t8+/b+28eL5uJ89uG3+YffTmbrw/Pj4X6WPD1+ufvrDTrf PT3+9PNPiSwzsWySpNlwpYUsG8O35vLdzf3+8a/ZP4fnF8Cbzc9/O4Exfvnr7vW/3r+Hfx/u np+fnt/f3//z0Hx9fvqfw83r7OL0948XH08vzm5uz28//H5zenby+WL+x8n5+cez/dnt/vaP w3w/v93/610363KY9vKEkCJ0k+SsXF5+7xvxs8edn5/Afx2MaeyQ55tiwIe2OHKejmeENjtA OvTPCZ4/AJCXsLLJRbkm5A2NjTbMiMSDrYAcpotmKY2cBDSyNlVtBriRMteNrqtKKtMonqto X1HCtHwEKmVTKZmJnDdZ2TBjaG9ZaqPqxEilh1ahPjVXUpFlLWqRp0YUvDFsAQNpIITQt1Kc wdaVmYR/AEVjV+Cpn2dLy5/3s5fD69vXgctEKUzDy03DFGyxKIS5PDsdiCoqpNZwTSa54kpJ QnouE5Z3J/PunUdpo1luSOOKbXiz5qrkebO8FtUwCoUsAHIaB+XXBYtDttdTPeQU4DwOuNYG +e7nWQsj9M7uXmaPT6+4iyO4pfoYAtJ+DL69ptCwr4yQBEs4NiAuJDJkyjNW58aePTmbrnkl tSlZwS/f/fL49HgA3dCPq69YfAv0Tm9ElURhV8wkq+ZTzWseISZRUuum4IVUO5QJlqzoQmvN c7GI9LMHxhSMzGrQsUAAcGHecTsIzuzl7fPL95fXw8PA7UteciUSK1cgigsioxSkV/IqDuFZ xhMjcOosawonXwFexctUlFZ444MUYqlAIYG0EPZTKYBAt1yBWtEwQrxrsqIygy2pLJgo/TYt ihhSsxJc4ZbtJuhiRoltA9sIEm2oiFMsJE9tLP1NIVPuz5RJlfC0VUSC2gtdMaV5uyv9+dKR U76ol5n2mejweDt7+hIc6GCDZLLWsoY5HZulksxouYOiWIb/Huu8YblImeFNzrRpkl2SR1jD qt3NwGkB2I7HN7w0+iiwWSjJ0oRRnRpDK+DEWPpnHcUrpG7qCkkOdFglNZxhUtWWXKWtEQiM yFEcKz/m7gH8jJgIgSFdN7LkICOELjBtq2u0F4Xl6v54obECgmUqkogMu14itZvd93GtWZ3n U128GcRyhTzZLiXKPKPV9DaqyoLt49DU/EnZxHLRFStNryAHFLtX8BnbKMQaeKWnt+0c1ZQI q8tKiU0/l8yy6JL8SfuDVZwXlYFdKnmz4LAiAfxNDp7AKVFd+0bmdWmY2kXJa7Eip9L1T3dg OKinpZMVaINEKt7tFnDde7N/+ffsFQ5ltofVvLzuX19m+5ubp7fH17vHvwJeQzZlSSKBMKdP eno2ApwwH4wCEqUd9YuV3wE3fgQ6RcuQcDBKgBo/p0qL6KH8wNqGQZBwoWVuNSkdzm6TSuqZ jkgfbHQDMLoN8NnwLYhZ7GS0Q6bdgyYQfW3HaHVLCDKKJd2cZEbwqfN8kHgCKTkcuebLZJEL q7v6/fEX5TuKC1GekrnF2v1x+RC22OOhiCuwNCD5A2YucVCQvpXIzOX8d9qOu16wLYWfDlws SgPRAst4OMYZlQKLJcqUb6f8khqceeeeO/5Hrd4JgL75+3D7dn94nn057F/fng8vtrndogjU U0Rt7AHBRF2wZsEgCEs8MzuoqwUaRJi9LgtWNSZfNFle69UoLIHlzE8/BiP084TQZKlkXREL V7Elb6xMcaJpwKFLlsFns4b/ebowX7fjxRxDC3A7OAyUMaGaKCTJwLKyMr0SqSGLBBXhow8C 6NorkeqolLdwlU547S08A5m65iq2ggq8V+oMIOfifC0k3FRQ+huR8AiNgB8qo2ARXGWRfmgl jpBeCB01y+D8g7cGOtDzxJHpdATdqtXSxwUXMY6Mqy/JlsChJOtKApehETfOUHjGg9VGWnLp BGBY4bhTDoYHXFWeRlcJ8TnbRWhAtoOttu6gIhxkv1kBAzuvkMRGKu3C1WH09EjEB8Aw2hsg NFK1iDIYdyqsA1AY0g2yJKVp3N8xNkkaWcFBiWuOLrrlF6kKUB4+uwVoGv6IjAbqWqpqxUpQ NIpof3R3DPGMnS4U6fwixAGDlfDKxhDWvoRObKKrNVAJxhHJpCROWrpgngK8J4F8SKZecoMh WzNy4R07jZozWGJKIwHnODtPk4o1WgSaoyGaj+dZ5/906KPFdf0YxEfo9xIKasO3wSfIEBm+ kt5CxLJkeUaY2hJLG2x0QRv0yqnlTv0Lki8RsqmVb1/SjQAy270iuwCDLJhSgu74GlF2hR63 NGwBvg8sB1kR1FsEw24HyjDG26F2sd5xFstuWPOFdm0gCKgtk+AU1klBImmITL2wFLryNOWx 8R2DAgVNH+tZA95mc6vD85en54f9481hxv85PIL7x8C0J+gAQhAyuHL+EL0D8IPDdKNsCjdG Z4HJVuu8XriYmqYZi4qBa2AjvUGb5iyWYsEBQjTYVQX2vg1P4rkgREOriO5fo0CEZPEDiJgC AQ80tuV6VWcZeFPW1aDpCTIUrBV9u4opI1gscgSONbxoIGRmmEcWmUi6JAzx7TA9O4oN2qPx U6jduBfnCxoubm2K3/umFsYleVHvpTyRKRUWl2xurF42l+8O918uzn/99vHi14vz3g6hIwlW r3PPyGEblqydqz6CFQURLyseBXqEqkSv2yUaLk8/HkNgW5IV9hE6juoGmhjHQ4Ph5hej3JJm TUqTux3AY2DS2OuGxvoPHu+7ydmuMydNlibjQUCDiYXCtE+KrkLQHXUIshROs43AgFNg0qZa AteQ3bYzgnfnvDIXnypO1mXjow5kFQ0MpTDttKrpDYaHZ1k/iuboEQuuSpeUAyOlxYKaLYtS gt9cgW6fn5yeB66+xpTlVD8bS9gdY3mzqsGG5guCgslXixiKQKOpgvWDitomX8l5ZWBWOVP5 LsGsIjVHbUqhqVY7DRKbB0nXaukCrRy0IFijfmVtbKNZyZ1s4CHxxKkNq6+r56ebw8vL0/Ps 9ftXF62TgKwTK7oGXFfGmakVdz4yVR0I3J6yKproQmBR2QQo7bOUeZoJvZrwXg3YdlHGHDAc z7EmOFMqD+ngWwMHitzT+hgTQ6DU5E1eae0vkhVD1yEo6V0CnTXFQoxbQmODQ/VH3mb4IX7L 67GTLwvgogyc716YiUDtQAjA6QB/dFnzNqPQHT9TDNNAEwtcbVDG8wWcP+j8xMtpu+xwVWP6 EXglN74nVW28e4g/ge6VBM/D0RDzOxJVjgks1h+jp1tUOn5bUqCbEg8qwCzI2FH26oy6Ud35 qhKsDOwCbHObzLigKPl8GmZ04o8HLtM2WS0D84bJ6I3fAoZAFHVheTQD8c13lxfnFMFyCsQB hSYnItjZqRWwxosiEH9TbEei10k6zAFc5ph53Ay8PG5c7ZY0a9U1J+BIMZov7QDXKya39JZl VXHjXOugjUPcgQZFGbJ3aUGkZQkeCoiMZ5RLq+Q1OktLTNwu0SLHgXg19GE+ArYOGdnmFkJa umRUrT35cs268PjWNRZTysze+Tao7QKOk5FGxSF8Ny6iXCi55qWLVvHCK+AbPxxtmzAXl/Ml S2LBfIvTH3/YGRngSDe8qNIrSQsNhhH/BJVx+dCaC+KQPzw93r0+PXu5auLOt3q1LoO4b4Sh WJUfgydYuOAn6gmO1dLyKpp6CvF6WnpndmI9dBPmFyPPlusKTHWoALo7sZb7vZtNxxVVjv9w Gu2Kj+shZQsWXsnEu03sm0LJHgCebA/NEqtHUPVlXmbBnivomwfaYA1AyDYfrDcxwTWpUMAW zXKBLlnAv0nFXLGJNiKh7igcARhAEN5E7SozCQAjYh3axa4XaHoxVkczSs61ss6FG4qNnbgB PIzrwXmOi2qNNF7r5gGGzV2ukYtcOdJwjjnKZt7ZbbxKrfnlybfbw/72hPxH96lCSpxIj/yL AB4cF6YLIYqQGsN5VVdjZkPVgm5B0a1mQHTdCcsYpfwvdBiFEdd8sr3d334fTybQcMcxfWEV cYc89xbJwlMA90KDR4vSyvzktgW7UDrwryDA8lvqws9TDo5eux+tJ4z7sea7eO576GT01vJD eBN5BLGMT98jYEZ3cla93EZhPBOxZMx1Mz85ofNBy+mHk+gQADo7mQTBOCfRGSBiOqGlNVse s4q2HWPCUPQwDHHAqlZLTFzsKL0OpEX8OjJRTK+atC5iNyR9SAQqB+L9k2/zVtJoBhxzJciw x/pDGLwsof+pJ6grkKO8XrZupZdodvJFEOK7ar28/4zW5gY2qY6zRasoAisTTUwHmFtZ5t5u hwh4ER6nqUgx9sLVxgwB8LHIdk2emtgdvzbgjhs8VAgrbPQ5lUm3yYIcVH6Fl3WefT4Sno74 i6VpE5gjlwFZVSj1mIRxcTXKf28gnF/z9H+H5xn4Afu/Dg+Hx1c7E0sqMXv6igWpNBh2iQLi ObaZg/YKjLgyRaNzzqtxix9RQysqgw53cHOK5oqtuS3QiTFuESBbRosigrtLFP7VJ+cxYR2X SAQfijqmMhW4EwQ2+uo4ysqYBr9Yrusw7VGI5cq0BWvYpaK5KNvS5iYdbdbp0ySN16/U4tq1 Ln2vz8fQVaKaKaG3GFmVmnAdlQibgiO0bYpvGrnhSomUxzJGiAP6rC3lCgAsGay5bVgwAy7D brTGRW2MjBdyWLgR5a7drTEqRdwAmTKYNGMltAQDsuhVgt1vd3fv47clIjLme1sEUUHM58+b QNwlgVc1KA1rJ4brxUGQHTHoYNTVUrGUj6b2oNNbNCUSjvwET1eGBw5/GwZaTwXtnQYX0g/u HJcs9IjGVTSNT3eh4GYl02CH4C8zNOEXOKZJrYTZhbmlQZpYxcVUe1PayNsnDgGTh10ZUhGG X47NBqpcGxxXJjYqoB/8YohVw2O3f2ekPqXCfKaswDf0nVfH0BPQBFRIijWIk92t39wnJbpi q1n2fPjft8PjzffZy83+3sWsXhESaO9PU+VMkd79wOL2/hCOhcm0ybFch97A/UfD46rr3l66 htkvwLezw+vNb/8icTewsgvJPJsArUXhPiJn3d41YK7Cj8XKBbXBE3M7uu4e98/fZ/zh7X4f 2Embx6KhsJ8kPjuNUNT6QGek7N01hd82i1JfnDunrQAT5lE8osoTjPXGs5yYOa1hnOtRDVq3 JaCRNtsPc0IVJtVXbN6UImw7/XARtoKjWOve1ejuz/bPN3/fvR5u0Jn59fbwFWjH8x/5G875 Da5trbvst3XqyaWw2sYuKQobFDjc7u4hqjn/BEe7ydnCD/6JX4fvSGxKGSPmzMQzwa6QtPcw 6tIeFZayJGg0xkGfLYEDm9YssMA+UGYC1ooOXOSWaR1eo7hWvDmIAWQVb2+HQRcxC6oxXJIc AmjMDpA7Rowdu2mC0TKIXm1waZ+JtFm0oNgd0EqaE3WDCvUpy9lSj28wh2J/i7kCLysAojSj +RLLWtaR+mtwO61yaivTIzEayJVBn76t/RkjaN4lSCaAbWaoGB2ho9y9zXEXwM3VShje1kfS sfC2TfeXXrYu2/WI4pXSXSmH8+kCI5T2TU543GA4QKzL1J1ny5S+KnR4riYierb4Wmiy4+qq WcBaXVlXACvEFgRhAGtLToBky8eAvWpVwhLhVLyikrAAw2clRwFTKQYPtqbOXft1JXKjQSLz 23ZLhNsijL9jRzqoi+NQWsXiM44TBFdy2t6uhEO1uqPlG4zyAoy2n8vJT8BSWU/c7LZWRVRJ 4x5odC+5IriYWB3wY2sGdw0RjoDaa3MSRB7pgrufA6sEwNGFLtXQBDKZLO2iu9zI8FnjBAKI L73/wfa2iH5E9ZVA3JZ17J1myF+oqMBXtMps7VVXRcGYerOjBXgT9e+h/RhXvocyKZHn6zTa XITNnRoubYYTuAJrAiJsOYkXmcpJA8Cbjac9B9azQCAGHQ0VnUrLzKpgsxutI+2S4DzBsh+S 2pVpjWE72mAs1EM5jWwf30IkAlrPvq2KHAROjTBAkVdliNLbCDuDzeGK6+gSvKqbAMHSEDVe fq+hkCcyLqnCmRqEokSGasEWHQv0QjId17fPqcZWHzZYuML43pcYMNArX9SBRUGdo8WyTTWd jdzhFs6S0NfuPeqFcFe1Rx8RIt/1Bzc4yH3r0c79oTZrt34UWO4FJBMosUK6kWvhsontm051 RWqRjoDC7o7Vo91joGFxEGjmEM+0qWTfn+gdWPCLYl4q2mBanxh2bcs0I/difQFWEimU7Tit c8anIaOn2M6+Tz1XGvTNVImzbx5cghuVmq1KjMu8vTMLg7keAVPppRRpk8/T8IFG5wYCf1s7 0gdSidz8+nn/crid/duVi359fvpyd+9dSCNSyxmRaS20e43epa+7Oscjw3v7uLSnUy9F6ZWw /mCc1w0FRqzAumaqS2ztry6QsOGCzbEpbEZXIxnq8bDBvUYFLmTeFW8LrEsExCttBud5Cm5J UUn3Ew0s+lpxIHlEWrsMqv8IxGNq0o6hd2QpLej0NP5uIMD6cPEDWGcff2SsD/NYMoPgAK+t Lt+9/L2fvwugKBEKA4jwMWIIn3x3HyL67+cn0SafULSIKMpX+DZGo0PVP4ZpRGGFPr5eGwnj lS6s9v3L57vH9w9PtyA2nw/BurV7hBdeFCzaJ2L9p3uistDL0Rs7AsvFYtyOt61LzJkeATVm fjIGX8NJeJKCgKtFzDq5Lqj9aJaftvajEZjGUr+K5eEcTkt3ZiD2HrLaP7/eod6Yme9f2ydz 7QC25NtFpekGX7REc88F+AgDKhEunUodA/BMeM1D4jIgxTvCkaLH5RWfMCE5akP/nT62wGZ7 teV+wkAOjwFJUgz6Cemqs1LwBX3rRoDr3cKmrYcXsC1gkcWzvf58P/WbiwXzNKlXzonH5s5N VxDvoDqF9Xu/etDCbeLDwY/Bon2vgF35VGcK9HsHt3hGoh1VBflZB2tzHOnOb6dBqbrS4JZM AO1sE7DeI7K/d5FaNHuNOaBMQ8LO6ireddTem/USKQKblLOqQu3F0tTqPKvBYs5h9zCmWfAM /4dZD/9XHQiuuzO/UjA4XfNw/WsZl3873Ly97j/fH+xPIc1smdkrYeGFKLPCoGs08uZjoNaF 8n17IBWzMv07eYyt2ofAMW3lhtWJEpWhQtECJh5C4jRt7qcXk6nV2aUXh4en5++zYrjUGF+i H6u0Gsq0ClbWLAaJIfMt2JSCx0Cb9vq/v/QfUiUhzlSIk+FPYiypsWqJ71+vB8zSVki1WG12 3rPwHiT2VqfKIWirjNOoWMV6HpuhRcM6SJMH17SWoZLQlhCjsUTdg+oheO7T0Tj+kZbE5peb wNXHKhorZ40J3wLZBI2RGNRS0tY6VsXdcbI9LvfbH6m6PD/54yKu06YK6kft/byxZMxU4Ony y2ZVNe2VxLCxOWeuPi0mMfYBD6miYbFfdSFQ+/KSbDFeyoFJ0Je/k/VEczvXlZSeI3G9qON+ 3fVZJvMJkI0xZEz4+wskfJbS3cLQ+eDAuFJ+ata+IY4VolgY3j/gDQexY2n3rG2cCxxiYFug 7yytlzkagkj7hMnPnaH75T+o6lrsJSMtKbZl7hA0xw4JBD/4/S9vVptT8xQVTxQ3TlFZnZju X/czdoPFTLOCFk4PG8mKUEpbZTvVt4NP61tSNcvNyJtMD//c3Rxm6fPdP55z5TJtQntMjN+T 70CpWxd+tD+75Mk+NFulAyohxiYAZToob2rbjqSKehRbQaCZ/1zWh6ICcThxvdgjDy/EJxGB A+IvO+31u45VWSDkUy3UOtwVdARREjvdHhaJEsz/5+zJlhy3df0VP906qTpzxnu7H/Kg1WZa 24iSrZkXlTPtZLrSW3V3KsnfH4CkJJIC5XvvwywGIO4EARAAeVX75kBjqp0R0DNSLwAAj4gE pSEJM5FMxLAYLSpKVw8Kj7PQKlxdAw0upepWGv0GRtoMwL6/PH+8vTxiqo/7fh2aw1sGXtlG tPIrCBoMVsVMTu5paJCPObFovoBTznba0Ovw8LqGzoCBJWC2ODgn6ixE35XI3RCDMAq8lNiV 7w+/P5/ObxcxQMEL/If/+fr68vZhDY1wXK6QnU2NDihvwJ22kzSoD3uL2/WIqONAE22SIt/L rzB5D4+Ivozb3DEqN5Xs2vn+gpEYAj2sDMxZNSrrOm2vqdLLrF+C0fP968vD84fpTRNlYXdz a4x5B+89mhybI4LdKE6MJ+t7gGeVTw6z0Zq+fe9/PXx8/3F9p2DWPH5iVXCoosBZvrs0TWBp ktZizVpFsB0dmUa8goUsH61oYQl9+K4OmlneKwP9l7W0jh+ipCADeeBUr9JCF5E6COgOtTlJ cIRnoZfkZMhoUcqaYgZaMIYmiLRL3SEdP7w9/YWL/PEFVtfbsCDikzCfGupeBxKCS4hpkjRl DVQRr69Ec3EcvhIX67LDVKEaGoRYGbyp93Kg7Cx6RG+BSEhNuuZm97GjVbndjrq614k6whRI 4yzoIGXD0m89oViHJTviMKFtcDpuUxx3joyUiD7WCQZg+8DvK6Ybustob0h98nfL9FxaCsYT lqIm8mTD9es2BTstRqA01W1VXT26zWUor/WOqR7DjYI+3tuKxRJHxpU9IuMoC6QITHsPOvZR 7yB4L+Q5Y2N5ZarMnRhy0Sb0weRXi9YrfDeuYSTuwDhMBfxoE0fWUxnzwppi3TRtRNfwBVYw 4BhpQz8wW29UIKdrb4dHjtglc3syvRm7gTI3/SAHCzgM3YyLHG2YmxqZpfDN1KRshklIfjvj IfT28vHy/eXRHnoepMJLusqDPCHn9P9ViyaVh5SZt+du0qRhrjPGyGy4KbO1UAHC7NEp8BBU u9CshvZgjR9pjCbe9wXoXKqHd8EklKED8GaOFQRgAtciiWLHugzS9Q0squxYemQ4eJ7vk2jg wf9YCG5EI0sYMjIRk1vZZiJFgAnc8ozn8F8R/zsKx534oCvc3dZjobmC1zjSgXE69CCVTkXm KL38/nae/dYtYnmY64KSg2B0HnTLv29UxjUuib9Aqy1RyzWBKSYLpBCclfGAGUYGcbXfKBS1 g6tQ/wB+iuOEjwSL4Q7i9fz2bl4QVOjuciPuLrhdGqyd7QrWjkDSl2BA1QU/TVMJ+2HZshSk gMqj49c0uqqkA/uQBA+HgifjCjUaOD3ECu36RaCkAyZav+R12qeFswDhlSs8GvQ7qjEZXk/0 QWSjC6Bu8MWc1PBfEPTxAkUma6rezs/v0g97lpz/Gc2Sn9yBEDGeI2y7YxDkHVOZd1Hp2cvH Zfbx4/wxe3ievb88gUJwfofqa5/Nfn18+f4HlvP6dvnt8vZ2uf/PjF8uMywH8LKs/2iiXpXo wRf2r7Y86XyBIYwWhuOwtXAdc+OYhkfrLk9tSmMk8ryYXH7ybg7zFHiY0mC0S4A/fi7z9HP8 eH4Hwf/Hw6umQOjrPWb2JPwShVHgEtyQAA5YlUL8ySoKryFFGr3cNP106Cy306hbBD4GgKNt zbK8dvhEw08Us4/yNLKc3xEnXbeyu1ZkymwXzhG2CEkpZUy2NreThd1NYo0EfmO0abjs+snc PRBoV7sFck2WuHN8klfkhAhZDzSfiYq8NORVOF4roLN5Y2hdscRicV5qAXIL4Pkcg0E0gW9i +UvTxfn19eH59w6IV1mS6iwsrtYeyVEkaXBK8GaRmxOFlyAob1m7SIHV7Z5jeDoizE4lLz2s IebBZjkPQocTCBBkUSVonAQV32zI6G5RfzDa/VJ4P5awVymlXHyVeJWclMHIc2U8Zfrfy+Nv n9AGcX54vtwjM1ZCOWXbEBWlwWbjXuJ4PR8nnplESt9CwaFYru6Wm625XBC+3iXb9dyE8yLy SiEjmmBeLTfWmuTJaFUWh25M9KqqkJZU+xNtKQUfaQV8eP/jU/78KcCRcxnqRc/zYL8aqveF d2oGynf682I9hlY/r4epuj4L8nj1stCsFCEy/MjoN5xCiCGBMtvgV+msYG6bjkLX1gg091Je OxKW63TAnq7SLBs8tvbuCSm9U6v6Ig/R81+fQc45Pz5eHsWAzH6T/GSwPBJDFEYY9WSOh4ZQ m85GQj8xFV/l2SMhuwdcwpEZqyNRguQ0UeDFtL17aEeVOkLAepLUK49RcoWIJwEaCFbLxi37 ytL+t4R+GaRiEiap8ibz3JKTIIlB3GaxIwdZR3SMt4s5SH9XyPihjZNgQpCTM+8dWRbQ9pSe qGqa2yyM02s11pnDMtOToIlmM3c4MXZEaIG5MjOVSxaX6Ga8bWVH0PJ0pRNVignP0uDKok4j TkZn9gQir+N4N/WO01T7Ai+MrLu90S4oPW7GyvcolTlwP77ESR/ev5v8AIR85cI4biL+ha/V jDHADvMDxT8Yv8sz8Q7OFFLK5r1HoMl2XbTCV+rnObV2bWJ8duTKch8+8f1KMH/HYKPBVOe4 URDAOfU7nEza9Y9dPBDZclIHx+uQg5emDscWi9I3845QlXc4cRyKJiYFDNbsf+S/y1kRpLMn eRfvkGLkB5Qd8HpRljSIo+UUy0CxNdcFarqnRMvzpnvU9Kpw5KvHz5ZzG4fuT4aJvUPskzry R6Jjr1k7V4fIZ+m6ZMqpJEt2FhEZq2eGyA4AzcdJgNqCcm/pkF6z293cbo3LOoVaLE0fcAud oZFEd4TKzBwuWaF8gYF/cUxOM7ZiKbOusVoY9+BTqt6sMPOvKLflEaDN6iTBH4ann8KROcOD sNQTa3W0eEPMOZ4BrMCjWe9eR5PkeTHqWFj6IFA+vKOb4P3s18v385/vl5lIoRbzGagFDL1S 5CePl+8fl3t9BLqieUPpoR0WBe1RizEtk4i00RIs6zjhP6TvANHztrirgvCoia8GWF3aYDzY cFFqEJxG/mA9oXRyxkZM9YXD4HYmrWMaaVfoihKhVth/P9vH1Hw/CklF+n90xydqFQSx55dG jj4JDSxA5ZX7yLjK1sDoB8KBs9Rkz3VCe5UQJLGWHMeE48e6nmmMUH/oapdgHdsIN8tN04ZF bmYRGsB4T0i2XacBhkvShHWafsUbQKJjzE8xCt3gKgcvo/PXVixOLZ1KgG6aZmF4sAf8drXk 6zmtDQuhHRRVukcg7CQ5x/yx+HwdCxwZIPbRIWhhMVMs81C0LDHe6hAXeEEOYq1LFRAUeISU jntCrwj57W6+9BLK8M14srydzzU1V0KWmtbOo4zn+IgbYDYbAuEfFjc3c8PuqjCi8ts5rXMc 0mC72lDWs5AvtrulXuBR+RSgTd3lcYuxhIeaemgA5NQKZgQkkmLVOWfpraWV1fDUNiKbP7Jp 0xmrd1VRfigKpdyleBhHehAw40FbVtxg76g9wF930de25lSbg6U4bp/M37ApoLFe2S4XYiak PBcB508NV55uUQoMrFxH4NaA30zhnclxFT71mu3uZmM4NUrM7Spotu4Pb1dNs9YMRwrMwqrd 3R6KiGsRowoXRYv5fK2zK6v72hni34B2iRt/dIBWl7/P7zP2/P7x9ueTeP3i/cf5Dc7SD7xT wXJmjyiiwhn7/eEV/2te/P2fvx7vjYTxlc0fuz0rXOLQdltoJrEuyaaeGb0DwR+Dk/XwqqG0 ArWdjmlgpK/aR9npC0UfBYfcEERxSXtJgGkvAsqJsV/zliGmB8OiN7aD53uZ13pUWfg0ldG7 4lh4GaMdsYyTShpEA84649tI3UEkBknobSk9ForXkymGKT6wI+YQaP5SjtHDpCOsk8/sxSha qJomszH+C1bOH/+efZxfL/+eBeEnWN8/kRIcKWweSonUuEf/gZ58vKPbj+l8vicIA01hVgOB D9EZcdcCnuT7vfk4K0KFy4PwXOqu2EXPq27TvFvzIhx9cB7scjBtlIKbI4yYhPncYZySNGUx nt3BcGu1yPo4yU+u3M1y2g+jNoWHtgw9+nDuCEQYhLvMNkoDa+QB6CW1p2vW1ELvOUql3QJx PNTQXdaQ2uSzNX6OqSowsxLFl4Cmiyk2PhRp1cgOivMzHWswgeZX+tfDxw/APn/icTx7Pn+A Vj576HxztDUhajro/ESA0tzHIPNEeKAnLPiqW1j6j8i3KoZOIAVLaUFFlLGP8NEBNx6QwWK7 pJ5slG1A506q+Zwly7WRMBKB9rOsHQOlNrwS5O0gtiqAk9R12Y9IjM3XDXsIKwQv0566zAvx uoXSU4aN6BeD7qJgcc2tHBkSYkv4FtLT32mRMHxBk++jnxdDthGFkS832BUofjNaZSyKotli dbue/St+eLuc4M9P40MgZmV0YubgdbA2P5AHXI+HgdCy1/XgLOeGT8dkS7T59QI4u3PMySx8 O8eHBXt+/fPDeZ6xrKj13On4E8S3kOtihHgFKkYPqsRIFycxMm7vzvJukzj5gvedFczXe6c8 ooNdv3NNq4v8Hl84gaOEXNuS5Jf8q0VgoKMjWmSe7K+io+WyqI3V6I7P+hZkcD93eV5r7Xa2 CZqM+fg1r70O0oJQk+hPhg+IVUhBQ0Me6+FB7juM/T3JPl5S+3zAl7pF2wC3utvxgKkx836a G8aJHity8XuO94t7Ks5C2A4YkTFNV6UhJQcPtY1OHQvlUKJsquVqSYzBCV/xM/N89Th0PksS j7oeGXqJwc956RODKFC+kW1jwGFkqJ76dRiOEwvhBznw3w5RdqivLIbQv72yWrw0ChyK9NCM GsSBfenF9LE4rFq+mS8WUyOEm7omV1lTeNRGQDDwKAJTcIGTTuXjtgzolnxPYCBsyoAY+i8n pifs6eExZ97Wt7mo8GbV+K38jYsRzvso0Lumo1hRRdrjJBrq4GUnTBenzbyGvfMr8iFFjaQA VZ3rCSoVTrqEwlIH3WU95p9VXgcHHpSR63lzyQbpMPYyZWvLviZAGCRgQnDWtLolLKW6JFDx XMvH1UFEV3Kr4GWo9GqbfrEYQZY2ZDUfQQy3LQWj95xEbjajw+dwfrsX7r/scz6z1RvRBTPi 1bx/sSjEz5bt5uulDYS/racaBTiodsvgZmGZ5RAD5/udTz6DKdEBK/ioFtCqEPpkQkvvZBMq 2wVRBIDQam6XAZ1vZdFWO/MExsErOO1zojpfZ2uGn0/QCL8vi0QR1NYwI1s0B7ODtBnfbHaa H3YHT9YEcZTWi/ndgiCP0918oQuG1DLphUZK1pMCzI/z2/n7B8aY2Vb5Sg9iPxr5naW7vAjT T+xUa8eqI6Bgdq7+w4mkHsCY+SI0TAB1xprbXVtUXw29Xb1vgGByDpNQ2JrqKrezaSl3t7eH 8+PY7Vbxu+7NR3MtAmK33MxJoPbot+ZkS9BZ15E6arHdbOagTnsAyhwe7jp9jNIUJb3pRKPx Nhqtx+EbrTT0TQ0RNV5JY7KyrYUP/JrClpjiM42mSLrnIV3Dk3ridQWX779OKqK6HHdA5qRh RlYVLkaWVJJB9kYZJ5nuip4iTtp8jM9tFtaPh+N5Yo2E5cHqKlFZLXc7h4lCI8st9Yyeg2q7 ubm5Sgabtjgwh/iuE+Ijn9crZbSSZSzY5to8Cc8n1zz5QXqzvFmM+ET28vwJCQAiGIawtRI3 JqosL/XhDEvmC9rnt6NyuvEpgpFnlU0QwLjdLBaTkzrlnalIRs5gVjO8ZiWfsaLgDbFunaYw icbNn1gOR6NmH1pOmk66rhuX7RpQ43SjZgXkBa/C/mJeCHed5JPb71jtNo5HuxTFtf0E2mHF vkwORRBkDXU/3+MXW8Yx5s6Uom20G6MCcscVd3jXJXu3gFjqR2XokU/6KBoV2zVqhJL4fqm8 Pa4LF17g7PnWcLgaxaEwOlR0It+rQ3xR++fFYrMc3hIjKN2rCG+KkWRy5zYchI5rRCBVjkqy WqRrmQMMD1nZ2YWFLIvlaJQANpzKw0PpCouetklBDr1AsSxOokbhRysEY8kppa7DFyV1jiO4 G+HJlY8uqJNDeIz8+ups5KdJNgsLl77MMYVDm/vh09bSt3XcwUzebIWWXVARZfm33Hz5R7iE gejtHklxrVYb0XhFKcxoxDdFIR3PBgcI6eZEDLkiwAeh0HwQJrpJSUAx3DiMzNdPBQKvRFqV f3FQ9QUGL1hlZmXaHiDKFS9rDk+hulqlXyhIAGexYYNAIPxFGQIE7oSv14X600eylZhwKI+N sjxe4Lv2dwGXNL7D1TsrQFIAxniVUBXoVyTZ0Bx/NB7GBfdJpeimrtWKAmP9NXe79GTlWMLk Ww4xchSmrX+EPIaoEZ+S1pQ5fFg6NZ8V6UDUO7GwyvbyoVTxGBRZdxXAn4L0xoqSQETP6m4z yVdMLBAknvFUvIJblNJ1QEHkoIJOW/PKfknSwGHMrczrQbKKsUItbxCWAXHJsrTfKAMI8WIW QsXNAnDg3ATbWVwFDF8VEZcbGjCtm+6yPP3z8ePh9fHyNzQS2yUCmAgRFj/zSl/aPaDQJImy Pc2lVQ2C9AoB/E2te4VPqmC9mm/NDiGiCLzbzXox6pRC/G1wng7FMmTNE9XBSI9LTJMmKJJQ N65MDplZscoI40gLhhRcZTfpF4b3+PvL28PHj6d3Y22AFLLPfWacth24CCij9IA1LvStOvp6 e5MRZtwYFoBKazSDdgL8x8v7B53ZyKiULTarjTmWArhdEcBmZU+Xl4Y3G8rBSyF3C90Aq4Ag Ny3twTmwZnMIaVEB8Ww3p24YBIoHB7tdjKeOgwuQBWMN7Q+H2ExcFVHWQoE9spB5sB9qu0rO +GZzS/vRKfx2RcWIKuTttjFH6sg8e5QAVJTjNFDC/YIIjBAlB+k4P5xgazI3yq+YtUUFlP7r CRbN4z+zy9Ovl/v7y/3ss6L6BNozRpr+NOIz4nB09tmrbmlfWoFsGkbb1AXjDNLlbuUeTh+9 G9CjapLiLs8ovVigyyDllW/xYDyGbJEQEVPBZQIfcbbPhFfdpKOJTTtVJNuDVJDk9AGLFNF+ OaeOd4FLo+Nol03yeQw5Al3WdVkrSbi7vSylbRQS1+ALsA5vcEGRFytHcCKif/m2vtm5ds9d lCLjtzrrNr4IbLXdTNSXVjfbpXvtpsftupn6vKGtYYKFSMnT0ZccTQDcXn5OG4RAnlxnJRwo +vMmJhfM3M23jHAGTvqkT6zbkjH3NPNVsFw7rGoCf1D+XBN8NB1l4dPRhcuTA5HuQ0FoqrH7 WJB42mIq8HW2BY1keXIPDP+afalBL3DvL2HHa33LYc4gmbTI6gQt7UEmjpHJrJxIcZo4PlWO TdcClk7w9mZsEneLm6S4ndhLmKV0dIJFf4Os/gzKPVB8lhLP+f78+uGSdEKWA29ra110F/Ak W5qSTlAst4vNaLfIoDRHn8vcz6u4/vatzVG1NWqovJyDJp2atYgXpqUmI/qTf/yQMqrqjHYs 22euknOd4xWUWCFUUWeZwzwtZQm0KJDKkFPINEQWTIhr9IknltbaA5Xzvkv4ESQYSgFrtxqd vCLGz/biHxGg/GxNrYB3Oe60ro16s9IWRRBmHCEq54++jsOThqAMPcfA8WXKUEkEFO1MaGRI RNcVVYIJG1JeozE3Pb/jYh/8aCkHN+FB7c6vO6BH42vSlLerteNCQPhoH25ofyP5ceqFXru6 cVnZkaaR3t6gqDJHNmFET8mEGt6r3W1VRuxr+PbAnRZzSdV+ob1aBZpVvvHoI1dvzkdlnHw1 wSpO3jBBDuC2mWoGdXukoQc50zD8IuaEN8bOcgFNh3UopEjVOS7Sr2iBSaCBzzqRUXE7NSfS wD01EEgBR2s4RSMiru7qrIhcd2kdEY+BO041KGuKFm3q7hUwsirj/k/x39jdQuelG+KyfTSK edHwSXozb5PEcVGFBMVut160ZeUuA0dxcgiFRI3/C9yF9DSOpB6Cxi17S7RT9pboOztA35yd QvixO+dG3tdhIKe5E3N5KtsLW2SFWU80t2IjXjAqoF3M53TEvqAoXc+IIBaG23WH0mFb/sVd PwjzS1LdQCQo0Hcq2YXxUQfHzeAsuZzq9pfavRhBC9hODSkPFjvGt3N3t1FP4CynZVxJMPXt YarlIMIxx/MFAu3SMDokunG7Cdw3YgKL65LWQgQe/d2msNsJ7KT6IXZWM8FhhG6yXMwFo52m WizcPZDFzGFd2UnFaDJQJtwbh1JFTIK8CBIWx3jn69gBDUbzmZxgrMII6AR3RY8n7sE/cbF3 n6vfYAam5AbEp0W7/2J5NwsRKSWc31AO1EzclD8LTqspD/WfdukxlCw5khzhjytWQ/DRPjYo 4uQNOI5/Em2XzdweSiHxu+SL/tFU7ZOUGrKDHnUJP4zLFumDy5mVR2wAPz5g5K72NgvGMx50 p7iiMB8RKYjU2NLoXvCuPGoO/svYlXS5jSPpv+LT3HoeCW7goQ8USUms5GaCkph10cupclX5 tbdnu2a6//0gAC5YApQOTmfG9wHEvgYiICBvhWAd/8W6MbM5QuNRuybeMPc2VCHN5prWpP0p /KX+/Prdvi0Ye55wMONqXXJx6O5HlN7FZd2sCikc8cj99xfhoqw/v9bVQRjWbsvx1g0vYG5R 3AuyMWvAkuO7n195OsGK7Ae+Rf9dGLbl+3bx2R//rT6rtlOzJkbeCG21zQXyZkwh8N8UVdzZ uL0FzFFBf7KFRZZ6MbHlTd6TgHlUV2m3UKne7kC1Gp0xNvmRwzrCQjlkr+OQVfg+fiHl53IY Xq9ViT0iXUj1K1+3zo43DEi8F0fKqC7A1d+L7u5nSdjQTSNqN2xNVda2XSvCI3nPyyIDF0D4 6L7WSNley2H/O2X9cgaFNJlQE+SblZEdLsPJxuSbzjmBZpHkJR7hL3DnMeCBQHqsyhppWnV5 q2QyrFB82h4qVsq6sdCxOrkrAdZ20X4DAkqyT3GpyK1pBzs0cH5vjXwDH1p+vP149+3jl99+ fv+E+k+ZIxl4j3Q9zF7TepwvLh6yBpolSeq4brOJ+HoEiRA/o7CIjvMOO8In40ujp4n4xshO IX0yQlzv2OY9+d00frZO4mezHD/76WebDX32y8mzxOxJYvgcL8iebLDhsykMn6yV8MkyDJ9s NuGzGcmfzUj5ZGsIs2eJh8dEdk6I9zjLQIsf51jQHo8gnJY4jE5btMfVBrTgqbQlEX7NZdLo 4zYlaLg7eIMWPNGFRE6fqoXEYfBIp01GXItdc8ekNrvg/f3j2/jhX3tTXgmmoQzDropPSUcE 1sIRlNUyeyWRszCpg8gBUBeQKuta2CFovt1ngbAkBlbtZmuVkU9Uxl23j7gEqob34ghJA+65 ZjpxFd2vviFdjFPr0iabksDblN+kyc7Pb9++ffj9ndBjQApeJrIpevz2UsLO2wqZRveZusCL W9Yr915Cpr+lUjOF3r4LgqlKoWKVrtAkZaiBP1lUBxqzZLKCNH1OXUoKkjDhxz0z6LBgJ55T OhQEBGhe2BrofLLoZrCq20n0daIRPvAIWPijvKPWAJbWcT8KQ0ZG+RZjQMJgcvRZZ+uT+2i+ Wf3HjMI7zt32eUx84xmXlo6RJlZNMvT0aoEC3lytIE6XBAK9Ve2hawujz92YH+chVY2r7eZs 1SUT0g///vb25Xe0RxZ9FFHM2KjS1T1sACCT0a+E2mgwWdU3yx1PBTdK4lkRHmmUTMbHx77K CfU9pFjD1LzIVK6WjYKQQ9exsAtIK56h+rVrMyNhh4Kn1m9uV0MOZxQRsQrAecEmUKkh5cbr PkgdS7q5MgrXJfLc5aMxojsRsJpQU2tBL3AWRx6NjcwKcYrVgwQwNU2Jv28mK7ZbQ4PIbABc mKaaQUGkwlaXoY9aulR5dZfDYaS7I3I9HfA7jQ125rmp+Sxhzxz40fcMVXdwLCod45jBqlKC jrWUrPgiD4j5flFxioqVI5w973YI8S4x9c1OKccJ32r6TR4EFFUOlBmpWKfavZPTxJD5obB7 ur0WspMlLRvxyQSp9jkUggr4+vH7z7/fPj1YqpxOQ3kCB5LOOuWz5aW3sryjvIN+eIlT+N0U yfD/8X8fZ+2e7fh/Zc0aKMLgU6dNLhtWMBKmWKnrFErw4K7Fhxrav2E6Qxtjvma35OxUqTWL 5FUtA/bp7X91a1U8plkp6VwOjiRIApNqOXZIyLoX7QUVDMWkhAEI13Cmc1qN4wcPo9fsrmuQ Yx+lcujj9AeeM3UBPgrqnIc5CBwFFHkTDiTU01qEAvg4QEsvdCF+oiqP6e1l3WUJt/dDydQ3 VYqQ7zhyEuvPrFUYFNFNPXUnkZkOrhFel5d1N8o/HpLFY4j1Jd1D+gD3Oo7Hmipvmc8fEhdP 64+/vKMXrPJYTnDtaklil76vNZ91qtzp+7YvMklUWopYTczSzZgTuGc2ZHCteILHRXwd7MXa BHbIQCvsle+sR5qGEfZYYaHkN+L5yludRQ5tO/ZwudoZNLnv4GuD9YKwA2YKd8kVR9VATdZm sxitqyXSw3uoJ6yi1gTxlW6AZcxaAWdTT+CqUqZoJ0q+hPATL0QinRFil5dAiLoaWXLO9w68 PoPARirWQ2xquSwQj46mHjbwLYy6pwlJ7Ejne10kRlHiezGOQRz5doOEZ3t+TGobEalMKfq5 MQ5ibN5fCLxmQz+asMwLyHEponKIfgSJMBL12ZoCRO4vRxRdrqiMVO0wKhBPSP2z5hCECdZj TtnlVELxkjTE3q2tvK4ujhU72+1xGCMPa1nDyIeJyJYLrW++GO0LB8a3ASesYGC8DLA0rtkv 0jSN0LZ8q+ocey55vmnumMSffM2qPdGRwlm72zgPkiZbpCVgxLTT7FzgUI2X02W46GYNDBDr aCup4DkP0eBFErqUmFQKfsm2URrfI1jZ6owITwJA2NtKnZE6A6O1qjL8JHEETkmIdZWNMSaT aVtugwL/UeDQHThETUlqjJg4Azvuw3QOtqxdGefRR3xcZCxIUHEOuqoIMIFnpxYMNvAdVI2l 94WOpeOhz0rxvYecY9b40VkuOfbyxZc3JWtytOTYwUfPCjcCPPNEg45T71DVXbyDjP69v7rM e0hOzn9kFR+ojNetTmLPLjvJFbaToeDseilYjPk2AY8jWDUWZV3zYb5BELEI4Q0qt7EqegEL Ulh5gXXlyfGCYanQxOc7L4dmq8Kh5IitVDdKFCQRs1PX5H6Q0GBOuh01y8+Ny06XpJzqyKdO s0orh3gMt9Y0M/iqNcNSwAHsjGuBz9U59gOkEqtDk5VIVXF5X05YNUUeOgzBYxiz35lh4Zge CfpLHu6lnffSwScE/WpdtWV2wg0wzQyxnojsnEggcQK63poJGlZZNdixVtM5Lgs/K4cvB/cG dWAQH50FBeS43dY4DgUHjYOuWnUGMgbA+h/MGKAAQQod5LEXI/UkED91ADHFgRT/RsB3JcSF BGgTA0c9sUOlQOfsVZdgBHgu4jhEJ2cBRXvlLxgp2qlklh40xSbvg/3FVlNPQ3mCadlO+pjH EboSHHtGAupQQVpjLtsj8Q9NLle1e2kYEj4uBnYC+Gg8IWNU3cQIGV77oNIA7UPN7oqHw9jI 0SQUjww9aVdgNL0U790NddmgXAjolk2BkR7ApWga0ogEaB0LKNyvYsnZK8c+p0kQo/0OoJDs Z7Udc3ncXDH8PmAl5iMfKpAcApAkaEFzKKHe3sw0WyXAAnd5fu+pw1fVlsUjjVJllOwbzXTT ysPFsB0hcYx9XkC7LfhQgkZPacd66LP7wGJ8lj+y/h687tYJuBnMj8ce9QS1LAR7lhIvO9hf r1rWX4Z71bMeyXE1BBHB1pwciD3iY0nmEPUcCmYbp2dRiFrLWSmsjilfBGKdhEQeXg1iqk+w S3yFEVDfMe1F8uYOnypD14zoCEO8BFsASiTCw/AZhOJpC8IwxGOjMcXmZDhsRAdHjqS7LbWv mjAgSJx9EydxOA4IMpV8zYC24PdRyH7xPZrtdWw29kWRx5hDx56FXkjQ+ZpjURC7nnXPpEte pJ7TeOrGIbuby6noSx9Pxa917D+Iv7+B/0uXkV3JGfj+9QAvJOCFrzlB21s0t6rCSjmMDF0z s8OAPlVa8fOIr3M5sLt24Xjwb7sKuTjExTnSC2YTVdj3i6bki0bs0HVhlHzfGGIrFw4Q3wHE cGeB5rdheZg0+3PuQkp327cgHQJslczGkcnxAIm7iePdg6Ai9wktqI/01qxgCcW6sQAS7DyI lwVFR/s2Ix6ylgY5tiDk8gCdNsY8QYbR8dzkmM/Wsel9D1k7CTm6ihTI3vDPCSFe2YDstm5O iHykBV2rDIw64kc5HIxpnCHA6BNsv3YdKQkQ+Y0GSRKccID6BQ6kPnogJiCyf34iOC577wpl r3lyQs0ntBFZWUgobvEcxSQ5H11IeT6imRJXnXsrCulw1Pfu6ybon5/3jdOtPQMMaD48vRxf PF89lxUr5UzzBTeLwG3qWIHXHmzVtpDKphxOZQueJ+arbzjry17vDfunZ5JvQyXc6NzHodLf hC6M2Urq/dSB382yv98q1GEYxj/CgaZwdPAoZnBXIl1K7UT9OEpnIlEmWDIRPx58c0vcdgG1 lfZFOhzBkgPWRNBUvAQLB4VXEwW7pDwbMMIMgy2JrSnNTuN+fvgEr1W/f8Yci8iWLhpNXmfq uMRXi2uermU+qs6IAOtfQDug6ZUPanGyLr8XI+9LHTsa1vF1gpFg0cE4Iwi9aTfdQFgDr8kW /W9J91DqDod5kFgJsmrC7H7TKKr8bH9UQmMOlnC7upo9Xq1ub7AaEHk9fP/69vtvXz8j+dzu YKWazG6zAAM+LXtIYWjbWRPqTI3Dx/ROosdKVO/e1x7HJ7Ur3z7/+PvLn+jHFk1HB0VeuwoL p/xrf35/202xsFXHE23pyBkUMGe3W9KCFnj3UY72aOZ3UyWS9f7vt0+8LvCmMcfi5CjTEhjw 2EvtYoscm63AAVvHWHUw/A6gzxF4A8tUuiLW/xK+eoWuLs5ecU0TYQVYh53bCFw6GUWDzlBT oYcfKuXUZLwbN60rCqfRUUlCLSoIqxZ//P3lN7AWsHjAssa05lhYXm+FjG9zHGbCAJZOw059 hjqdBAbc9vq+piTWVLl8x0CwdZAIlI2EJh6aIjCEy2dI3FUEEHhZRKmnLviF1H4DIGKbeuIp +iibTLdNLspitgaovcYCwHxetsnsSGa5YZZEFnWY1D62UF1R9anaKqQRGhN62ruhxCpXVuWY hoeoLqE/phqJWIQR0VM03+Ui2ZsRl+HaleIqANOgxCrTtliz1EeX2AKUViq1APDM6YVvewP8 fERQpte2Y/L5viNmuAyeJqMtzULdnoUK2A2kJzFJzdIDJyr1YHQzg0EiPu67KOcRLG866hhA npDF5LsSq1xdvL9kwwtq9nimgn9B+dROETBVsK27RNvJz2MBRsL0vEsSOMDSC2uTy3eTn7FE Chg3treR+ma0Qr9nhrNxDf4la3/lY3JXoBkHxmwzWcsJpX1D9cPyTeweTwUeO+yYyOFj8kOX u7GZkCSui8mN4DCSsBEc+sYbIcUa0grTMLCasNDW3E05TYmr+0stysQcTKVqpS4USpXW17k0 xQ7lBLhcOm4xlb8Kxwq9NbaC0JmHa9WXg9sFNlDacSpdk+VQjhc9M7Ze7CIxlU5WuXORIOJr zHes6uflCyQ9BcMY0sA3ZUKjUuuj87s1s7xYmbstogpCFSbx9IDjPkcWcBN5vvVhELrGK0F4 eaW8L1mzgdR6F8MUmqDsMEWe5zKjO6+KwIA13zzpxcZeWa5v3EE6gkWyIIj4hpLl7oWUfFdo BgYFZ4qrTs5x183F3RqyusnQs52exb6nq//KdwioPqKEEqPlKA8R9UQJuUMHYUk1z5f5gtiM gsauhqy8dbSlBJfqij0agqxmOMaHd8fDnPFWh15gNxGVEHvhDgE+cat9kgT7nLoJogA//pQF ueOLThCMt51iDINX4caKeH5WiwntFcwCaLaY15UnCc2yvDWR77BPucBoq5PgPCsYQWBacAcJ PWt+gHNZf9pdns4U3OjgQoiMRjc/bbEKSXkrq44Q4y2kDh+WEm8CwjuH21vUxhIc/OHITDq6 +s8tL8BMtbFVWt9e2cK582gfeDlnRQbKRO7xB0xo3jMYTR1uCAbxMLDfG2y183L1idnuxneJ YShPcJ6qeTtfRHJDjQHHaip5R+nqMTuVGAEelV6EE86WXRrx1GnL08qCc15xzLvykDxudL44 PPExb6sADTKXmxsID6Kow5aUwiqiIMVnEoXU8v/w5Y9Ckrv33bzMxwJ4emWb2g8v9+1o+OUA 4EEy1xOB3Q+tL6RQRN2QaghRb1gMxMdbwzFroyByGOQwaPgb7Y00v2+y5BWr+S43wssNdFlI 4uOvJzcaLEQSfOIzSNhds0qhCZmw8gMkivBSAs2YiOLKFDorTrAXHxtHqNLQGP/M7jbKpKGH DRqJxmGK1YeAYrSpAETTAK+qvb2UwYrwmdVgoVsjk0OdibE2jA5SGuwUN65VZ5JIjDWZ5ThF v+zR8YQGLoimxJG3ntLoUWsDEroWVSh8+6lepOtI7Bi5+0OFLs8VRp6lYYQ2oHn3isjNLaWC XfnIEntOiHp4/QkQPXFUOLcGDyzcIA19g5uwNnimAWMX78IO9+vhsl96qjbT2F3yM8uHsmz5 DDSbr7dD2LtcBeRbZVRbUKcEjnlP7qofBI99vHo4QkLHmDmM74mvG6xDOM2VOJohDx8nD8cR Rpo+8x5NDMBiDrMuCitqaBI/Gt+c7y0VyrbJt7H6xDcenqNJy0X0oetMFzVO7nUoj4cL/trI 5Pa3R3HCscABt1CgRib2C/dr43C5q1B5QXjxo8mdsyhxOKgxWAmmnK+kv2eRHwfoAgk7XtBR gr+L1kmRR9BRzD6OMDH9UMJA/WB/HhIkXkjO6FPf0ZEwU0sIzakjpFFCV8uVW8tnBsk6O1QH 7EJ1kId2Sq8BX0ya8Zy6GrCjqiGfHWQPuue94d6WK4SEq8TYuhAU9QaQx6j8l2uOylnXvuJA 1r52OHLOhh5FmhzuhgoUmxo1jJrXSj7I3s1s02CBRfldq7xE7UTMh6nKu3QuabuxOlZikym1 CkrE03JTgrNVoIN5jm4Y9TjycxIQYsjkfaf2Wr2cnUHeM/yMGQjOA2jx9axhl/bER3h8Gyk4 Iz7FS8zl9ANQof/gDluiT+xhqdBfalZSYKnZBWTIqpY3j6K7AarHvXi8VgpcOeAQJT6XthpO VNLp+9u3vz7+hno5yE7Ye8nrKQNn1FsdzQJYF4MXXfZPP1YaYTPdq/5y3TlALHRdE6kBxWWL 225F20MVC/nx+9vnD+/+5+8//gB3aWuAOebj4Z43BbzC3FLLZaKhvqoiteUfq6ERnlx5uWEn /TyCQn0iDB/h/45VXQ9lPlpA3vWvPLrMAqomO5WHutKDsFeGxwUAGhcAalxbTniqeKFXp/Ze trwRYBPl8sVOfdACWSyPfEFaFnfVHBeQeW2DnVmVCyat6up01tPb8CFl9sHNtCjATSUkdayE QzW7Hv9aHBVa6iFQctUwXPS09g0xss0lvBCPfJCt4KqDD/n4a3WID7EOq+KGCy8l4CtfshNP P+1S5dBM8KDZoLcfXqZ+bETT4lYTOHI+ZWZ2rwO2VOBI15etdD+rh2B+ITaqeCipmqUlcfaS Lc+PtXRKwFL6QThrO8G/OlRXM2MgcrxSW1DjcHQRb21ShapEfRbEBXVJvSihet/MBt7/Oj7i tvlZb9LSdp4tujc8RNlWl0b73AK+8pnk/aXEsJNRnLPYneesKFVDLKsIqZoZQIsd4bkMZUGD HV99opeSFGnlrMbJYcdoE+iDVyBGU22Iya5wnP3ZEiFZnIEszx1+UYFTYWsY6HZGG4e3CUUF A+8d3JAfmfExwOFoh+8vx+pQ8SHMkce27Ph4XOmd/OV16IzmHRRH57hz7bqi6xxDwHWkfGui RT8OVVG25vif6c5Y1BEyMBt9A/MkIuMTdNbcy6uum6+B+YWNHa4xyuM5lXwqcIH9xMc+/Lyf ozfXYzGo18Wx9L3OHdpGUC4uXXTR+By9TN7kay2wYfnlOBnFeykwFXQYaA7N/TSNYWRND4t9 KFeaisxlTla0QHGf44Kbkg8ebddgd1QAH3irmYzxS8qELuqpMLvXgrquI2HyH7qsYOfSYZhQ 9L+md1j5A5TxmcjDjn1FqSe+rhgBW52KGWv2eXWILgalkvnbb//69PHPv36++693vLEst3DW 7oRjfEEArnHk5kdRJONIHR49j4Rk9LSDNwE1jNDgdHToVAnKeOW76fe49zUg8AElJQSbkhc0 UA3dgHAsOhI2uux6OpEwIFmoi1ez9ZqU74KCOD2evFiX8/zwHvByVB8Bgvw80SBK9GLpYCtE ImUsXScFvTA1I4kL42UsSISrDijRqFMyUkAbE053kXTMiqMORD2X2xBhXwkDxJnFrS4LDFxP Vi2EZXx3n+GlkBVwdo+dtRgc1UqEkuvlLB3LhrwGxb9bN0EceLiNSo2TYlHXPY2iCY95OfHc z9Jy/WohpmVE5aPXiHhJjW1NN9KhiH0vQYtjyKe8bdXXKQ9GB2WfCw/RyuUZXP71y4+vn/gu 5eOPb5/e/jPvVuxBBfbH/FfWqVr+xaVpXh+I+f//z9m1NDeOI+m/opjTzKFjJepF70YfKBKS UOarCFCi6sJwu9RuR/tRYbtipv79IgGQAsAE5d1LlZX5EW8kEkAiM62znP0eTnF+VRzZ78Gy F5hiKRY63HYLDgLdlBGmmJdcKTti+1idxrFVwS/vvboDh/EW6IVEsbNCJ8Nv8I1UC9VYLFeY wLsg1N7oF8KJ05oH2oxHF2hwmtF9xoo6tx935sPgm3ux3x/0niCaZRc/L05UeUXyHccEkoBV 0fFS7HpPDWkBiVxipKg3Pj/O9493T7IMg20v4KOF6Ku9nUYUV7U1/Xpiazv+NdlSqv2ySHVF zMdrso4kvaW5W3MVldCTcryn4tfJTke7d7PLHRf1LqpsYBbFUZqeHKA8vHJSPJViP8tsoGjt XSFj7l3oF5poDbcmJGP+NiIpESLezoF8uyVO3XYk29AqcYjbyvlyl0I06JrZuIPYpaYJtaEi C3n/Z0NvT8SGHaOUF6VNg1CRrMjNTYfM/FSpaWtRKQSjtzOhnLht9CXaVNjSADx+pPk+yt3i 54yKGVEMBk4a+94DS67tiVCR8uKAOiIFZrGjejbYH2k6/CixBaIHbLeWSKFVnW1SUkZJMGDt bhbTAfEoFN6UIeNK7vsy0duYDq4AKSjp7uA/yeDJdnNWRA1hB0vhQLzYcodc5EIokdOgQHXK qRxUqI4FkJyjsXgFp6g4ubULVUY5vKUTY9qSiwa59Tgdl18THkHUUj9AyBBYg/HylBDpvYJR 7sx/wTgx7ox0g2h1oPwA1rzGpglBBdV1aPKewG1VRjLAeqshvWt6A11LBCcR5ktR88ToEssD caopilKmtUMU+3BnzoPxQMSk4Ozz7Ilj3cOEHsC/FCfIxAvi1DsxhVRiZDiZ+V5IBV9la1gp 25LN3TY+UpoV3DePGppnhZvRN1IVbtlN9ikRq6M7odQb1XZfb1C6OtvQv5yFM9W+A7pXuMgi 3gccsbUL625nT/F3GmpCODwjSomZZB+5yZMPvJpS6kFJ0QTdb42n83BcgSpHyuhVsLWaNCD3 lylJcczTIupuGa134W7y6gYoSyZsqxjMzRdCfglmr5x110PIN0q7+vn2551Q6dmv94/z8yR6 eHg7P0D87En2+v2n0GDR2rG62kbq3tUs9P8pMTctrRMRM0EMD8Oi2Me0hYsSoX6rCxxDoRT8 wQ0qEIXikhUOsE5L2m5q6zxTYfPc9zQF+GKvJNo4Yu0+TqwU3YSc524WD0JG17moek6O2J2y eh38+H5/fnq6ezm//nyXY/v1B9hLv7tTpXOeAbdKlOFnToDbisxoTiG8BQc56gXq4PRiWc0L j5m67AuOHY1rDhwXJ3XMU1Eiu+WjmhesFqtBnihvJL8HJlv11EVEvL5/wKZKR7efJO5GQHba at1Mp7JLnk16A6NFdZRVcklPNjvnvZiLgANAHdDZroLiXk6PhonvqS+GSQ8ZhM4cAA5iwzkO 8QYhBAQSScXgkkvbuNSqKDjI/pZzt+Ukn3MYuEzsfDClpIdtWYp+LjLtHDF6y94DYZ+AezKz YGI4jbRED4MX6uMozyl0z1evjccxGX6gKUdqzqQxLOCudAxyPCnnVlMHs+m+1KPdSh0CcsxW DbC8JQDMfBWMYrZiAotMXIw5S8GhYDAbDqCiG1ZO0YrP9dQFNo+DxQy/6LCARRaV+FmpBUui A81HRHJxpfOLT3R+17mFv3MLpHOtNFgazmYjDV+F0Wq1vFkPhR2kKt1qDKgyWg/YHpiCVV0G TOKnu/f34fGKFNTmI0m5pFWgxVR2BsfEGaBcut9XXlaErvrfE1ktXlTg9vv7+YdY4d8nry8T FjM6+ePnx2ST3sIi2LJk8nwnBIb69u7p/XXyx3nycj5/P3//H9EOZyul/fnpx+RPoWE8v76d J48vf77apde4Qfsqsvdm18TAEZC12dMEuYSVTuP0CUc82pqOUk3mVuw41DEKWijKksBzuWfC xN+Rf5nvUCxJqiluH+/CUM8OJuhLnZVsX3C8VlEa1UmE84qcqOMblHsbVVnkaw19qiWEdhT7 19IODZ4i6s0q8DyflzpfNNSyYCrQ57uHx5cHy7rKlHVJHKK+PSUTjh7UILFlQZIzzMLMTpnX ftGVyemboKacUks7xnM3V6BJ1XbkG+kvp5ME5dPdh5hEz5Pd08+zVq6Ge4v+0y6Omd2bkvUV GdeCgV12yPbZU7GNI86o6ahdGTFWxjLPR935scWVQapMw3yDOFy+egb4FKrUbUE/TqBRcFFZ M7YOnDzgsMI8Qr7QhjcRBu9yCG4Pc8UdXhwPMREVauEmdTqpY1a385l5e2Dw+gNupMT7+WKG co57ysmeRK5sUNyE7qgyRSFyX+ZOdZ16KbQN7JbXxGhpkIVoMUhWkp0n+S1PKMTb9ssQhTtQ hvokNyC0jL6iFaWVp8dIsiOuEPCjwO+KpxLhLECt323M0vQFZA4raZuCsmh5xOl1jVYVhEAZ 5RAtcIyPpnmbMl8Fb8FwpWXxlZbKYt7WwTzwNLe097iSQsHWntmqeLNlW0aVPkdAMxGoEI0d ZYKaeiSJPDpkHofOBqpMgzkaRc/AFJyuwmXoadWvcVRfmVlf6yiFIxK0M1kZl2GzxHnRFpdh wBBNmCRksPXu5RipquhIKyEYULdNJvaUbYrBVlIz0XN6S2xsSPUFAsxiNTgePeO0KF1HniYz y2lOroxTSCE2j94NXgMnp2L1xwUqZftNkXtaltWzKT50v/LAMwbqMlmHW/AmP17kpsJluDQn fb6sg/bJFLogkoyaD7A1KVi5JYySmtf+YwBGDoz41PSU7ApuRyuVZHdj1K0c8Wkdm3FGFE96 QXRUhkTeVrlllcsISUdmrbxIBlusNMJDLkhAm20hbBrjKsCgr08oE/8ddo6MTQc7aw4WQORA N5UbYtve9xfHqKqod4GDTeLwuEZGuYXt45Y2vPa8VlCKE5iSbI9ewEl87RNE5Jts38YZMXAE Jf4PlrPG2U/tGY3hj/lyOne+0ZzFarpwWo7mt63oGFIN6gonZWqHS/PMPhPsB33516/3x/u7 p0l690voyOioL/fWXWNelJLcxIT6j4RUqHP8PSyP9ocCUGan90SlpW5O3Qnw+JmP5/2n6ntw YSpK7986pe4ViWZ++bZYr6fDb40rGU/LOa0QCQ0IE6n8VNovfySh5XHpcccq2TUcLvjZ6rVf iAseBdknc8bmgcfPgMIwLoo+8zmFUxhpGed6rOpHFf/14/xbrByi/Hg6/+f89l/J2fg1Yf9+ /Lj/a3gRoxLP6kaM2TnMhOlyHpg3KP+f1N1iRU8f57eXu48zXOOcUf+4shhJ2UYpzwYmzcOi eFK0TrjAtIodKTdtPjpG54QdTr9tI1jUORfJwEW6cX/dUfo3Euqq5fz8+vaLfTze/434X+0+ qXOp14i1pM6M1TljZVW0m7SIrUOAjCna8F7HyOzq7UafOafbDNy2mzl0vC/yECJv5yHqNaiD VUvblcKFoY+1PB4aXZgSR52MI0ewVTEuSOCXMnI1M7tQW2nWgVmiXCDSQiMu0sLQSCR7U8Ey k8Nyvj9ChN58J3VM2bICgY1R+WFU4lcpillRglmtS6Z05DV1yiGJwZDoBIaTZHmU7bnrUHUu NqJlhR6+wZQBCQFnEt0ER+j+h50S5XMNKgsNzusWbk0EcTmoXrmc2rGzdI8RsRxlEfW2oCzk cvilpo8WDzAr00xZUrU7LzdBZdLsS2oYUV2T41mwYNMQOwRVZTANqCXl4pvKGZ5JEE6HWWgP q2yBxwhSrcvnSzOimyR2vlFsas7cruFxBM/qBxnzNF7ezMbGnt/FTD/Ol/8ZpFvwkZpcXHY+ u/NSHtj/8fT48vc/Z/+S60K120i+SOvny3dYkoYGI5N/Xixm/jWY2RtQ7DBLGlWYtJHOc90a qDCJvq/A/Zfb6DReh5vhIFZ+HLWNgb+dO78KfgQt7f2ZegT6dPf+1+ROrKP89U2s1LaI61uX vz0+PGBijwt5uXN8zXV7kTgm4GhdPtoyFaxoNjsJQRvB+73uqHJQMNFNd3///DG51/bO7z/O 5/u/DEORkkS3teHlRhP0ppJa1s8975TzvShYzhn+VHwILNFwfTasLNK0QEqiuHVS8spfmk2O xsWzMAmJeWqcMAy4pLGOPgf8En9L5OBEHp+A3ZLTJxolHSmwtqT0pM/K26LGNHUbxpvStMNx qgI2+46ZGDacuq+JENKtkLdglcLiyjRLk6yB2Q9QzRaXqJTsovgEj7u3+CWuRPmf7apSwBGk n03WS4/HasmmIcTOGwPMp6hk1czAfjynqGQ+810bSkAzxxxuqm+Xi6mh2yja2nYwooFTLOsl HlJdpzMfpF3mSTBIpYE7DySVios+o0ZfAwECtK3CWTjkKJ3T9LsiiPuYF6LDPakzuM7ax3Y6 mtg90frH28f99B92qv4xAtz8IHTmgcQUnMnji9j+gKWcoeLDF0JB2Kpx6ZZfcuDprTc3iRBl 9QKS6iBPPAYlAvNGKNVgy9N9pXxXmm4tNSPabJbfCLNd4PU8Unzz+GXrIU3o2TR3EL/xUodI GDySxEqgOG1Mcl6jTzNMoBlPzqCv1sGQDtGbbxzfPheW6/YPQ9yEaKrSUy5Sk1GH7x2oYst4 jnt01AjKUiEhkKwVww5L6fDG824EBNObO74MmBug40SypivUq5oJma/mWINL3gq/Prcw4VgO 2WLGQ7xDJac9JthS14/Sr/PgFvu6czY18m3nrw5pGiY2lzfoE8QOsc3mYozbcksmKiaW5d/0 Ql+GMywv+AJ17d8BSDafBmskq4Oghzh9jkyeChwR4tVd4kd5PT8R0zkciC/w9jwqvqALzS2V RV9g3SYlx9hMkoDlsNJAXyBZSfralxXultEUNrMV0pA366mnKxeik8eGHEiKBS6ChGBDOk3M oGAWoBMwi0s8eGOlQpa0UZ5oR+N9d8FG5uqqk7B5gA0gRddxFwc9oErqG6c3cYDVoWpWjgNz 2ypmtJxxVjB0JASOD7sLZ4k6sDEByzma5Cpcttsoo+nJM5ZWocc7sQm5Gc98HdgBi0zW4nr6 6/ATmMX47AoWU2w97sIZDZOUYYbGpQe/na15hKnAF4EQ8hCZaUCfI7Md6MsbdMFm2SpYeLwI 9ovGwuNPtxuV5TI2fW10dBjI6Fo19Eo4bAUZOmMkU2mXi04r1yVtN/y1Dzp9yPP68ltc1s6M GWp+LLsJVuNFHTPV7TF0p86HR1FbBsY/GRgoeoL39f0GnvOuI9qD1OLH2nk+ziflzdzn/7zr 5mrhO7LrINpIbDwZLtSrK4MCoqFcQzTjiAx10t51ABd/TWfooGU887ir74eeJ5zPZQUaOOwa YNIyngdXMMPIO8j+yee9sC9M0UQeU88ewoO1z8NoD3FjISGQ9SoYT2WwocYa3+OrsRdCPJnN bqxW6T0CsPPL++vbtbmOufVxBRdN40IJEc1JIAqffBB1kTgXWn9t12dm8A54lEWBGLpBFMSW 5DvLDSLQ+ugQ+yjPSWoXQkU46ylwG1aBPeousY2Yo4YCHJ+ekA5cmof41AQ2i2azZoTtnbXJ cTxvJXyAj7JptgNjZ5ffcdULRsFcWbpzR28S7QfM/20RcaepOkbZRr5S3c69Bc7ibUu8zKxs yzEm9zLFDPKsLBDsz/dZvim3uvlRPsQI9vJSf7cot9RXuZnHjkrGevV+re4m/UNGCr5g2kbl xpuIwsym/j6EaEfez6W08vcxv233bIwbf/Vx4U1s6Xaz5km7jD0M5zbbmaZ4F4Yx+Y+yhQZR TzUdSb77QkWd7Vp7K0ekoUup14WtRWRymJB2EzE7wK6i41IbIoB7O7HLRtrke0HffHXhVM4y WxbCu6sLhcthL3VCtomqoXxInV7oRXP89Ahhno2HzOyUxy1vdKOYos89xRwIc3AJ3JsDCDL4 fL+8mu3aEdLfUtP+nh0l1bA3UR9bVRa/xSp/IANnuZrnuN3UVEbSLZSbWWsccPYkKplTQ/kF nAO34KUBv6UwP5eH1QTXbS1c7E4RffHiNFJfxNiwO4zqRhs1XmoHtouWpeU+WcCi1j22Nr0Q KA62LGTQ3TGlttGm+BEYzaVtscGfhhm4Xf7sDbWnDrkqZA8vDRErGcpkBLR5FqG2l7pi7SZt C9uXicnB9woGYmDkYpcDybg24wKJH21Mtzah1Ko/rb7ajCQjGcqIiHULBiRGqrhgqE05ZAE+ D/tnNNaHOeGo/SZ8VdW2tQ8Qs63YCSMfHLZmReGXWP+zrJa2ZDOHkxeSdxl3kgqlzCz505OF tLFiF3QMtCsUU7/E9BRVaETEiEwNCqKO+W0oh4dN0exqx6o0p7wSym0ep9HB89o+iqtcrG5o 3iIj09F073igEtmI7uEQ5kxiwEKrqE76Qt+qfMfPaywHaT4KTOsbFU7dsZ+0mFLKa/cL+lK1 t6R7vH97fX/982Oy//Xj/PbbYfLw8/z+gXnf2Ivurg6oULqWSlecXUVOG9P3iya0hFlXGkIm kQQfAkLMioUDv8trwlU/OkZc/5eZups2hWMlcuy/ZS4HwlVHpeWvqmeU8KCRIF9wZVHTkfsI ADbBDmfYE9meW/FyOwYeMbHjis3zMC0hWnnhkCEMQ0oSy+35IC+Qjs49pZsffArqA/K1XF23 aOiFri7SHY3yWTOsqHvp7/CVmbGbr1CYSulDa4c66jIwrk4w3Nl2lK4mCIccSM4xhtCgCLxs MnzBZSRNo7xoLi/JzbCZ0rqp3Re8TNFnzhpgO5QsIDR4U8zW2Kl+563FHNSXWaSZ81b6NGuL UqTuOG5woLCX7lrteZhStBNzeSfjocT4oOmQCTcuqDviriRDom4OrOBiUM/bTc35eJn7Ql0p Mm7Nv4eQmXFqutPSFJE/EZqMOe2lGqXRSmw+vfbmydKODs40q/Of57fzC4TPPL8/PtjOYWiM qsuQHytDfSrX+a38XOrG/EjlvgzzpZ1mt9NFaD/Ru9Rn/FLbxt34rh0MGIs9YccsDC7nDARd Wi9cHdbSy1osPNXcZLPQc8hjoOIkJuvp1baImQyfEHsis1yA8sg7JQ3zvNdwoCy6CtuRjOZX UZF073a1H0ZCjAE/ZbNpEEZCyKQJxRdlIzWf3ZABUaa72MdFk0e4UmYOwawMwELQFzUHKh7D S0FPSjAMInoL7xT9ld7EWbCezdrk4OldjQnnnrmg+O3Kd7FgAlohoPAjhA51W+SeOD0aEJ92 uccXXgfZV55AQJqfu+7KB/zx7xl+OgdsI3Dgtd7dUzGvV/Fh7rkmcaG4UZODWt54Ws+CrTx3 YA5q/RnU+iaMDz4DQAu68j1nEnsKwsFp1dU22xSMe3a/WQM2eLiJKnxKsybM8KOKnu3ZV3ds /6iR7K+DEyb68nB+ebyfsNf4HburEKq/2DaLcu9qeSq/wNvHhQVL3CGJi/P0sgvzdLML86wm JqyZTT0DwUaF83EUj+thX/YeCpE2Nc96QdmO1XgZdMhAz8jO3x/v+PlvSM7sGVMK82Dteb3o oDy3axZqtfYE3HZQ66vTHVCeyzoL5b2vc1GfyDGc+VYBG+WJ0Omg1rjphIMKP4W6+UQdQyFv 0TE1PiyMkaOPAJSK+vz0+iAG4g9trmPFRfsM3JBdjEeV+Deez+ZtJtSPa3Upqfgi3o8oBrJH /au+PpO/qjEpZ7v+y5vZ1ICPwIJPwRbzazCl9m7pwa9F6OdORbwtd753HFXiycjMBowPDL27 I4m/iviWYZwSXnLLC9IxbjjKvaH2DlHmGOPPB42egqiwiTNyNKqhKc2b9hDXnr3Ct1P+1V7c ug3iUSjyuXxbaroC7qnyGgYtmYGBG61rGOiRqxiv0YAJ8t5O7xnJ2to1SjHmNnv9+XaPhLgT LUQOHN5OmNZx8merm+aC3KRJj+yz1uoz3EN6IgZ3mu8IRNsljSE6q6QxzFHepfoBW86zaiqm tR9CmxIubf0Aaay0GgEUx3SEWyVj7SB6eDHWCoK/pKK3/Qjlb8DPV6ZLIwDtPnQEAd78wcMu 5/EISpujjaWT3jII/LppoEQgIjyCQMdMHOuUho1VScygiox1ei6bDY6XovJ6ia8uUABSxgMp LkGiKjusM3nDSGN8MYh4BpdtFLd7UlyPR+KuBDrorNio47NBm/CNDGXYyLdVOda4YCYwMmD3 itnGGV7WHpDx2hchWt2wi90RXo8+Ce4ZQETX0R9iV/drgy+pe6HSi4GcVXjguJ7tKmA23/NK XpUMAtfKkKt8dOQxiIKE2xhEPBaDZTY6t/styFWEKEvhGV0dxMeXHhPAcSAM3tXC2c39b2VP ttw2suuvuPJ0TtUsliw78q3KQ4ukJMbczEWW/cLS2JpENbGdku17kvP1F0A3yV7QdO5UTRIB YO+NBtBowBAhrVNJK0PEySLn7kTlfaYoDEFCAn1Jh8v94/Pr/vvx+Z5xOI8w6D8+AjP8KHuo YyF3hmFTNLBDfK/IcHdUtmlRjQHTLtne748vX5imFmml+UDQT2BtNqS/3BzqMcrrDe+Yowij hHVexjAZTw83h+Nec+mTCOjbv1T4+fzpJPh6+P5vfEV6f/gbRP7Q1fzxBCzSNgQBKs7cuKCd sgDqB2c3kN7Agcg2HhFeEaAeEInKFzlJUq22KCzH2ZLn1ZIo9RB1cf6Z9sqOSMOspx8Si/sV dzWv9Wg0VZbnnsNCEhVT8W5Bo91wW6tzj8sJft16ckP0+GpZOhO6OD7vHu6fH30jgd+BEOg1 ohLefZQ4ZEzjypdRkLfFn8vjfv9yv/u2P7l+PsbXTiNUIe+REu3hj3Q71gsyhbFtdL6UNjKQ Jn/88JWoZM3rdDUqi2YFH/uHKZxKj552f0EXk8PrXjZp8Xb4hvEf+j3LRXKJ64i2AYYlqMs8 SewTQtX666WrkDyDsYHd7ehlmIbXXu4J/Fd4jjxEw3IvRbDktXgkwPhQ7U3pUeUUf7aeMTNo D0MzKNPUKafzuuBGgYbh+m33DZa2d++QyySeNG3F8zlJUC14yYawSRLwA0hYODZ4byrCVqnH BU5hQ/zeT3ATZFXFsC01LmzvzS03ZsyBU/eKJI1VyWcZ6gnemT3ibGPmoDzo3XU3eVJTDO28 KZxNYtOfjdLr1IZA05BK5PJjWhnbw7fDk8tU1JBy2D4UxC+d5EMzCvLNWZbRNdPqaFsHQ0KR 6Mfr/fNTF/reCbYliVuxLaZz7ZGkAi8rcTmba29uFVyl5TSByq89q89mlxfOJ5g94ez83PmK bsbnM8N0MaDsOD02SVFn5xPPMzBFIvcDcBsQgCvPGwFJWdbzy49nvKqhSKr0/Jx9x6bwXXBD I95Djwo615uxKogOg+ydeS6upOsbfzB5VN+MjSqwSSOVDohWCvyEE/3w8GXPyY5IHIjLSbBl nzMiuq7iyWxuONYBdCmu3FA6VNfz7vjgrshNGuNnH+f05rin9i1gvO3+qf1wQ0ogEE1dsVcZ 6Ci818CKwHsdTfioTGL+Lo/QnByl4Ttjip9gZOkgPrzx40Ze4CF6HS82vM6I2Djlea/EbXlz v0JO+d2rsKB780cU4aUP/WqE4rq6mJ76Z2zkchPRV1GULgQXKwOxFCPuzF5HoBBM5iD6WSG7 bRr7+Z2BrSpzwSJEvZmwykE446lrUPlfcRIWBTUnUbrxeRgLXwpDJKBgdB6PJMJ7bDOI0/wS 2iLnxSSi86V0IqQyM/nsNESjxAkvwZgMQfhkOseYaX4C310BIb2XBD3WZ3AkAjQue7H+Z5iE jSPfk1GFXpc+OyMSbGK8tvaY34jAeVIrFajy+uQexBTOyxmj8sdsbFJM/CdadNk3jDpygmHD B4grPFy0pyuvx5/8lHdi4qfqpprq4y1/Fcg8p1jCuLEuaLw0XVPW88pfD3zcNllcrOOobEUc Rh67HdlCkNgb8RJ5KRBgwlCPxooEWe17LyeTPFEdIC0t4sxTTJLn2Qpbg+/6ipjvlkGUetxr 4Cz0Dl4arIs2skvvlGt74fUGyEIEV0qeUaBFLsoQGEcQT80IRn0WiDyoBXd7KZ2Dgl7jNtcr 4kS99nhLKPy2mvjiPREBGV5mnugRksIvUSiCEZnCoMBfgeAtVMoPynJrtdCwfjwvtAmN+Xhj 304gAnlujlDQpFeFKLdjQzISs2DAS+/FVpRjI4PXaSPo8askSUOahcgrjw480BShj2EhyXve e4rqbjVNyPF+fes3N0par3uwQjsJdWyCETcGRWHHSDCwvTuUu23w1p8tV3kGdF5573kLdnS2 e5+MZbO+Pane/nohhXpQFdQjLztkPQ5oP904wmy9FE5/lXojxtO0iIxSE1QY/N7DQpFO3ib7 alIUF6iwguAUjtVIrhujJSn7LtJwUQl6HwBMOkAj82h+L4d4tAo5W++SfHyPBBkVHj9jHUZ/ TTjJMpooj8wFZN0ZPVYhSK7tdJ6llD+Bk9Z1GqzNHhpEjlWQpsXZ+wR27QYFsQ+Z4+FXaEZK kq5Z3meBSFIKyhcx1mJ6cw1DS/3iXeSIrDPvhfTLE9jBoISGeRQEoFLyCe2HDQhKPFemDaHu 1kdXBz72w9A/k7PJKRY6tsF60tn7pPF6dvpxfF+TLiC5uH+uSOSfXM7aYurReYAoFHO5rf0U 6Rwzo46RiPTifIbiUOh5rYm+Vp0c5OV9wO+LuIj864FyRkw9qU3lfkVlX2nkbZR6ws26pFbn HDpk2VicvXeVe5rrhNYLmuYhon2Nr718OldqZm2Up9H+iK6XO3xT9Pj8dMAU4ZzWVKZtEPDC DeE8juLoLYLXX20Ylm3h8bSQ8SZ8WCw+TIML4PMOSTcaI53oD389ZzT8aAMzi4kCjeUhnVmZ fmbdy8H2poxrT96gGUVDoAQ36spcPD0cnw8PxvBmYZnbl6jdDawi7x9zxYtsE8apZlnsErYW aaQFxs/w3bvmiwe/g0TEqQFZ1FqkDeOHrISSxzlAykC0aOJECxIQiq16h62FXBBb/VtsnvnT NYhKMKmEMS8DDxR5kNf8Upc0nUEsQq+MscI6wvHi0F/MXyVas6Jl47lwkyVkuO+zMPdWRMfl 9dLb3P5E8tfUk4x3BmWr98ZPHgj43JlvTW8feK/fm+UFHGYjY9d5VLxXUJVtMO/FqvDcoFFQ vZFSyM/5vUpKX3/VyKFbcrYphRtSen1z8nrc3WPuWidBEAymoeXXqXy5jWFlPKLRQIN3yWyI d6CQsdsfzc+qvCkDNlsAR7YGIaJeRCOhomotYXAHIbuwC6WgXE5IKUCsav7KuCeo3iMA8Wmk hW1R8xUz0cEVc2UmTDu8fGpmHbHMPotxmihpqWHpqeLcSFOBv9EW5MuzUiVxakRRQIBkDahb 210s4d9Z5LH5B3mDJJy9M6+0FLH4S8rpevpwggYy3sYQoca87JJpMQ6YI4CkET2oWwBqa9Te 5LDp+mAYCrcBeT4UdQQiAsaMqfRjA0CxCmekWQHractGDADMWbusrFvNMyo4r+ItVM1Z0Tqa KgqaUmbcGDCzVo8HQADgGe0yL6khDu1Qk4vSKtAbOPOKGp8XoRZtF3/ZoYyg1HRBg6sFJY1i GETAWDHrOzAQB9zDjp6APBfREUwPh9WX2W5FXZc8Su+8W7E2BOwS/Uw0TMu2XWe038pds90Y r7wRc93ktSee2TsrAfFmXliE5FmCAawou4XnI2tWECQq6HTdLkWtp5oGGXFqdGVRq5l6tCH8 YPZYmkXlem4NqE1aNhlonBlQtTLelVW71XoJlO13GwrTuWxBtpMxNYYTMU5k15iGLKfOYiQQ BtIa/aJfauZ378xiR+PuZ8LIgdPnQH6AeRphPD9HgUowaxWHIRQxWymLTO5yFljqscwG+Izr E4DX/PHfUdxVdejrcJzjcOrl3uVZ5OwoTSFDoZwrzcPDcLfpo9ZBZDK9Ni/0EY2TiB4AxZkR 1GOJwYmC8pZy+PJ149IyWWQP9PLJgQJVkTqG5R6vMoFpUfVGVU54OBsQS4DMMqU3QUgEUzdx G8NQW8KmlOD2RpSZFcNI/8zeeRJYl5ERXfB6mQKb48KTS8zUKiCoDY4hmjpfVjN+o0mkuRvo fNPf8FkZd1XsKra8HOYhEbfWKTxAgXuEcQlbrIW/eFMOQyuSGwEC1RKzRfF5bLWv4ixk09lq JFuYZ+q6Pk4aPo1gFPPCmG6ppe/uv+rBarOoHo4iTaOVYIwTqC8/eU7bgJ5OW/AS4VvuhMUt ZgzyAB0Rc1UHZGfC30Gj+zPchCS1OUIbiK+XaDE3OffnPIk9V8B38AW7Kppw2a2Irh183TI6 ZF79Ccfmn9EW/8xqvnVLOjs0CbWC76x1t1l6DxhAqNy8wNjDqBCr6NPs7OPA3FT5P01I902c Y8ysKqo/fXh7/Xv+oZ/5emk3gkD+tESELvlVjbgzh4F30vfYMEmT3sv+7eH55G9u+EjG0/tH gKvAiHBGMLwjqxMLiOMFSgHIFHlpoYJ1nIRllNlfxKGMlIfLvbErDvAZTFSRVtNjrqIy05vY mYg65SstzKVJAF40sGhIrhjBA38Io4sZS7FuVlGdLNhllUbpMmyDEhRobRj7AIGreIVX0HL4 9LBF+NcgI3XGTHf6+nriSgZKlUFGjVHIS4yj6ROlRejIYgpkLcIOuXToIzrAfXLF2i9yAKpI Gi96MSKtLHz9iazT6/NSSdiPNkQdtqcOnGy2i2a51DXPAYuRWl15V+KrJk2Fx8u1L8G/2CSJ JliCFOXELDJo74zcahJW4ns8w/17EftHMihFyo5kdd2Iam3sNwWR4lx3eg3WCwMtj2revtQR hhH2FYSzbOUzRVmklG54pLEGXVtEJTASpgOWytrDzeHswZaArsH5K72hnrtxvEeA7/EzMt8v KJDDXcS0LEoXURhSYmVnFkqxSiMQPZVUgQWcaWfh1reFMIjY1tgyeWrtqnVhAa6z7cw56QB4 4V94pSqVuwizImvK3/1he4UPExe3oLt+mpxOZ6cuWYL2o24fGZdokgQmrkfzV3Yd3Yylc6jW wVCd3ez5bKoj7TpwDfxCJSMl2B3uBuqdnmlt5r7wd6KjdnrqEHyAzz44dQeu7dkkUE9T7e8s w/ogBWysE6nxr7qozP1IDA5cLfk1mekpJuDH0MfDy/N8fn75++SDju6kyBakSMMwouM+nvH+ aSYRG+XTIJmfa5nkLMzUbLaGOfd+89GHufDWczHx9nJ+wb29sEjOvAXPRgrmve4soov3a7/0 1H55duHDnJ9623V59m6HL2eX/m595KJxIwkoVLjU2rlnTifT81M/amJ2heK5m9Rd+RMePOXB RqpAHfFeN859H/pmrMN/9H3I+7YaXeMCqhsEM8+YWNvlKo/nbWlPIkF5fwVEY6IJOPgEZ+zq 8EEEsktgFywxWR01JXc11JOUuahjkZl9IMxtGSdJHLiYlYgSvsJVGUXc1UCHj6GtIgu5T+Os ibnzxBgFtqF1U17F1dpENPVybnhZZDEube7SL29vrnW9ybiCkiEI9vdvx8PrTzfjhHJq6KvB 36CIXmPEeClI8YdqVFYxaF4gbcEXJcizrG4iTZ1RyFXThmuQ9qNS+AT+znyNOQSqVR9cXpP8 HPt2BzGE+K6YLKpv8lJzAyE2UYsFCO+w5hNhmr377wpRa3NDcZEpXHgG/WooZ0Fx24okyQNh GAMcohFUu4QCMES5eTEuanKOjMoUpn4dJQX//rVraZKLsIgNd14bB3OyzMuAW0c96a0w05v0 iEos0Z/XE+NAqyq4CvObrE3Y9AEDHewkO37Y2H1OJw4PC0Nomxsq+/Th2+7pAUOj/IZ/PDz/ 5+m3n7vHHfzaPXw/PP32svt7DwUeHn7DdNdfcEv89tf3vz/IXXK1Pz7tv5183R0f9k94ET7s FvUW//H5+PPk8HR4Pey+Hf67Q6wWCywgGweaVduNKKErMWYGqeuo1JYVS3UHUpo5CgBEV+er Nss9+dI0Glg7XUWsU4BBqOrSkeiLj+u3H2F9H3QUS2CNJoH2PJ8dmA7tH9f+YbXNn7rKtxix XIbU0/ILAE/BLkgj7vHn99fnk/vn4/7k+Xjydf/t+/6oTQoRg4au384ooEhWQs+aZoCnLjwS IQt0SaurIC7WujnFQrifwKJYs0CXtMxWHIwldFWXruHelghf46+KwqUGoFsC6kUuKZx/wHHd chXcDMpuoPBxJPFpur7lbgQk+Wo5mc7TJnGqyJqEB7qtLOhve7nJv5j5b+o1HHNmegbCeDJC dQshTvtsUMXbX98O97//s/95ck+r+ctx9/3rT2cRl5Vw6g/XTkujIHDIoiB0VxcAmRKjoESw 26Eq9YRRVQPUlJtoem7FovbRYAaT3g307fXr/un1cL973T+cRE80CMAGTv5zeP16Il5enu8P hAp3rztnVIIgZRq7Crijp/tkDYKNmJ4WeXJrJs3ud/UqxmTJzth2CPhHhTFFqmjq0FTRdbxh ZmUtgJVuuklfUASvx+cH/Tqta9/CncFguXBhdcl0PRjbIVGwcJqWlDfM1suXnLNHv0mYJm5r h0ujoIfBYxx4tu4H3+3BgKQRHlt1GqnYbDkttJs5TAlUN6k7MVVF0yXdFncvX32TAqK68/E6 FQEzdlsYHn9TNrIkedd3+LJ/eXUrK4OzKbMICCzd+XgkD4X5Sji2uN3SsWP3apGIq2i6YDom MSPrSxGo7e00pZ6chvGSKbjHqaaO8Hj2pPRu5X55YMok07TSnTEhp7b3yHOnH2kMezlK8G8H V6bh5OLUaUW1FhMWCAu8is5cHgLs6fxCIZnvzifT0S8933BgpvyUgaFTxiJfMeN3U5xPRjYe zVdLk9pmsVq7avUHh+9fzXi6HZutmIoA2rKXIRq+r8HuAEiRN8uYWTkdoksP6MWrBeSsaoH5 jmLhRQwrz4OXZwmwr1+nnPpJUW/vEh26OHc1E1SvnSNgNjNCxz4LI/c0ANhZG4WR75ullL2c Tqnz2ovwjQZozkWUuQUqOJ0ufsbQUQ2dHDuJNOrpr5Cn76GddfHL9Fz9lnB6k7ObQcF9e6FD e4bbRLdnN+KWOd07Kr5jki88P34/7l9eTP26W0N0+eNKMXe506D5zGV58m7Tga3d0xYvqjpO Ve6eHp4fT7K3x7/2x5PV/ml/7NR/h01lVdwGRcm6vXWdKBerLr8hg1FiBYeRh59dJ+Gs4Lcu hVPk5xiNBhE+G9TNU51wg4xbuUHruva3w1/HHej7x+e318MTIyol8UKxcGtkpB/IJiIKJSq4 EzngtISfXhpXRjdqkSzCnfEe1dfhjupANHLomLX1Cg7bZE3/YVKZsoT+mpGOY7II76Wekq7B J5PRVnuFJ6OoYZz8RL7uWArXeKd6EcYuas066FS3KSYgjAOyKmO2xKGJGrJoFomiqZqFSbY9 P71sg6is42Uc4M1y/w5jsHhfBdUcfVs3iMdSJA13qQukH7s8vs6TDomld4NQimZvjldoES4i 6U5CHjfYmHgIEhjsj68YahCU4RfKG4KZ73avb8f9yf3X/f0/h6cvw15M87BJ0A2CrO2fPtzD xy9/4hdA1v6z//nH9/3jB56aRlHZG/oR4EjIhMDfUdcYNrxsKmX+L2PdauXiq08fPljYaFuX Qp8W53uHQnp9zE4vLwy7dJ6Fory1m+NvN7AWzBZa1d6WDxTEJfFf2IGhUklWRptcziGR8C6p vzCrXe2LOMOOkIv1slsWiZcfY87xi7bQUi93kHYRZQEcM/p9CL7yEGVL7nO6V4fo3Nj7RoAy gFmGtQnpgnaAnpAFeJ9RUrQDfeHrJEmUebDLOAvhjxKf1ca65JaXoc58YAjSqM2adGGkO5bX ScaLky6cCKZgNlPDdygLTMwRncCDtNgG6xVdaJTR0qJAM/4SxW3yvSqSWO9OXwYwIJAIsryW 91w69wzaIIADWGfgweTCpOgVZg0W101ryLSW3o8Kf5fb3Sgc4cADo8Xt3OSuGsYnZRKJKG+8 OfqIYuHJtwBYjzgaGFpA8FFfjgvXDBJongC29QIWbpineud7UsslSYNK/zkTjl5xKPgkBs+5 kweuJX3qnlVa2+9ytmTdv8qAsv5USM22T/egGppCYI2+R2zvEKwNHP0mG40No7AJhUsbC13e V0BRphysXsOudBAYNMoQshSc8h0kdyl3jCiSRfCZ+dBjYB8GoF3dxdq21hDbOxZsqBAdc2Bu dksZKz7JDS1bh+LVt76VDRzUqOMWgbaGRYUx6IFXgGgmylIYl8b0GFSPHCBB9AzQ4GAID1NN 6sXIC8YDpYwaJBHAjFf6FTfhEIFBRfAS2nblRpzAOBY1KG8Glx4YI14yE2GT9W4A2il6E+d1 sjAbGORrUkZgEeaJhTJvpBFURCVwf0I5+mO4/3v39u315P756fXw5e357eXkUd5R7o77HRyw /93/j6a1QCkoN7Sp9LE8dRDoVwsNQ6f1U42pdegKjYH0Lc/8dLqhKI4dGiWaN/kmjn25hiQi ATkS3WA/zfUBFBiiSj22MoaxR8Bq4HaTWgaMuFCtErk5BpBMJCIdFbSdlOQL8xd3PCV36Iuh lVVeo1qhLYS0iA135TwOW0zmXWH2cW3tw9bpNu8mrJgtvYpqdBnPl6G+v/RvKMWLkR1kmaO9 SD10etSh5tMlJJv/mDNDqVD61ifQxY/JxAJ9/DGZOaVifKPELtskESAlZWPVo6tzO/vBNOHU Ak1Of0zmTvczpv0AnUx/TKcWuI7KycUPM9W2qoxrXrWytn3PSjCWS2tc1ANAJnFnqBv5vL5d Jk21th6c9UTkcpMGFoZ8JG6EHimmAu5mPb+HY8xyZxteniw+ixX/7syR0U2Pk053I+j34+Hp 9Z+THXz58Lh/0f1QhlagBiAzR3EaqMQGQgXF7HqDHQSNKYhkyJo21i+0pZMyCLurBKT7pPcc +OiluG7iqP40G6ZFarxOCTON5dxmAjNK+N+DGRQo9rO+SrfpIkd1PipLINfmWH4G/4OCssgr +WBDTYJ3YHuj4+Hb/vfXw6PSvF6I9F7Cj67z3LKEqumN66fp6Wyue26VcYEp3LChnrdAEUbZ xZdWMCtsasZKPsTGt06pqGF9YkX4GF9/0E0tKHKKfmFNdBdYIjaddX65mzQoZOk83HcrNdz/ 9fblC/rwxE8vr8e3x/3TqzYgqVjJ5FcUOtgF9v5DUYbuHJ+Ax3BUMu4rX4KKCVuhi2IWRJrV QM687vrXQeiYusE/jdOvw6JzCRGkGCKEX5RmSbZTln70ECu5WoULjjktKqFCEeBJbjWIsOPF BpXuQEoIgpE2EHcRcNVM/9Lc2X3EN4dR4khUysWrL8PgRbjpo20dZRX/qp0IYJFWeWa9h5d1 ljksU+ET6PvRk8Q3W3uCdUiv7ddhk2oSsfzdms87q6RZqDLMIKiEoGfJvulQgwUnURKJK2aq JcEmbYsVuZjajeYw9sdxWTf6PpBgmViC/PLsA0yKJxW0C0Q2VFsSJYhb2kG/noS7ngYEOiqY 8p1yXpRY1x6sY6sbEOdWlYNFF1xYBLCFhm0AqoT10IfKGN8KS9r++jcEYU9fZ/UqLQF+nuTP 319+O0me7/95+y454Xr39EV/KSwoXR+wXkODMsDIa5vo08REkpDZ1INCgX6/aExqChWFAylg nekrlSzDksiMNTTWWOnlDdz84Q1ZuLlNOydLBm3vRGzPVRQVlnVUmhnRYWlgIv96+X54Qicm aNDj2+v+xx7+sX+9/+OPP/49DB6FxqCyVzjrTqSAG+C6DaXOGmw2g9D0/6jR7gmoD8tEsG7p gxiktQPPVnSPbbIK1F9QgKU1qbOxyuH/R3LSh90rKJHAQu/RSmvIZZKXtMTPgNmUjRPpw5pR T5Hy0jFojKnsjAlBQ+/FSXDoF9l0MhRtfth9hwZXXQZ0JoN217LJpNxBRKWF7aSzpTV+DLK9 ies1KmjVL5CpQBcosf4KuSidUhU6pThfUC0ajC0SfMlPQ4aUJDQ5heBdqK1Mglhfg2qiiraQ garKRmId5ooftCCqnxXbcwyb2+brIJ6cXcqAmYrPD2eTwLDg7NP24fiQgSGVuBIZ71XkKwpF 42zyH/MLbsnJse32VJulsbt6UD297VSPptItgPOLVonj7SLP66bgv9KbaZQWLlZcCnK7xnYb 6m6JND9pGuf2ch986NFKizFPTrdzPuqtRhFxL5d7fEN/sYV7pMWiQc96Ueepa5lpshsM41K2 cHozn/ZoW/7vOYA5j7qyWe9fXpGb4uERPP/v/rj7stc52BU2a2x1XQX5xjnW4bgGsFonuv3Y pMZfSvgnkVWUKBRWFgHqRGVDb7mFbgCSSFACRBlJYxhoELNT+K9njbAH0XKDJwnuPuVi0Xcu uQo9WZDp2E3jDBUzPjQnUYTxhr3IMAy8pmULZzgOLmbMtQQVuY62SlY19ijyDvWBvzmKUFrc eEWzo6uCgntUIy+iAV/nW70JBJf3jCPFBiJb+grtTSc6sGl0mwOBtpadm4AYjGgJvGsYRgKX eOMjpWYTYd4EEQh0XwuSXKUWBNqIQp0J7MReE0qnJz3j0nwc6LYSChnso77RWMZlCkJGZPVT BZd5tAZWchNfWephGN2a218CUw8EzNzIt3idG9urEL4jqNlpevSD6ptbUUDPcmTU1Bu0T4Q5 Z0DuL0Khgl6+6/R6CWKlozFuNZRAYlsaVxhRow3zgJgGvw+khLeI0WSU23vFfqkk7XH/B10o FlMGCgIA --wac7ysb48OaltWcw-- From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============5097423008052333548==" MIME-Version: 1.0 From: kernel test robot To: kbuild-all@lists.01.org Subject: Re: [PATCH] sched: Tweak default dynamic preempt mode selection Date: Sat, 06 Nov 2021 13:05:24 +0800 Message-ID: <202111061341.QdauxAuH-lkp@intel.com> In-Reply-To: <20211105104035.3112162-1-valentin.schneider@arm.com> List-Id: --===============5097423008052333548== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Hi Valentin, Thank you for the patch! Yet something to improve: [auto build test ERROR on tip/master] [also build test ERROR on linus/master next-20211105] [cannot apply to linux/master v5.15] [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/Valentin-Schneider/sched-T= weak-default-dynamic-preempt-mode-selection/20211105-184135 base: https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git ea79c24= a30aa27ccc4aac26be33f8b73f3f1f59c config: x86_64-buildonly-randconfig-r004-20211105 (attached as .config) compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project 847a68= 07332b13f43704327c2d30103ec0347c77) 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 # https://github.com/0day-ci/linux/commit/4731291127aa2100c984229a9= 1533b671044a74b git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Valentin-Schneider/sched-Tweak-def= ault-dynamic-preempt-mode-selection/20211105-184135 git checkout 4731291127aa2100c984229a91533b671044a74b # save the attached .config to linux build tree mkdir build_dir COMPILER_INSTALL_PATH=3D$HOME/0day COMPILER=3Dclang make.cross W=3D= 1 O=3Dbuild_dir ARCH=3Dx86_64 SHELL=3D/bin/bash If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All errors (new ones prefixed by >>): kernel/sched/core.c:3439:6: error: no previous prototype for function 's= ched_set_stop_task' [-Werror,-Wmissing-prototypes] void sched_set_stop_task(int cpu, struct task_struct *stop) ^ kernel/sched/core.c:3439:1: note: declare 'static' if the function is no= t intended to be used outside of this translation unit void sched_set_stop_task(int cpu, struct task_struct *stop) ^ static = >> kernel/sched/core.c:6576:2: error: use of undeclared identifier '__SCT__= preempt_schedule' static_call_update(preempt_schedule, __preempt_schedule_func); ^ include/linux/static_call.h:154:10: note: expanded from macro 'static_ca= ll_update' typeof(&STATIC_CALL_TRAMP(name)) __F =3D (func); = \ ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STAT= IC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX= , name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :252:1: note: expanded from here __SCT__preempt_schedule ^ >> kernel/sched/core.c:6576:39: error: use of undeclared identifier '__pree= mpt_schedule_func'; did you mean 'preempt_schedule_irq'? static_call_update(preempt_schedule, __preempt_schedule_func); ^~~~~~~~~~~~~~~~~~~~~~~ preempt_schedule_irq include/linux/static_call.h:154:42: note: expanded from macro 'static_ca= ll_update' typeof(&STATIC_CALL_TRAMP(name)) __F =3D (func); = \ ^ include/linux/sched.h:291:17: note: 'preempt_schedule_irq' declared here asmlinkage void preempt_schedule_irq(void); ^ >> kernel/sched/core.c:6576:2: error: use of undeclared identifier '__SCK__= preempt_schedule' static_call_update(preempt_schedule, __preempt_schedule_func); ^ include/linux/static_call.h:155:24: note: expanded from macro 'static_ca= ll_update' __static_call_update(&STATIC_CALL_KEY(name), \ ^ include/linux/static_call_types.h:12:32: note: expanded from macro 'STAT= IC_CALL_KEY' #define STATIC_CALL_KEY(name) __PASTE(STATIC_CALL_KEY_PREFIX, = name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :253:1: note: expanded from here __SCK__preempt_schedule ^ >> kernel/sched/core.c:6576:2: error: use of undeclared identifier '__SCT__= preempt_schedule' include/linux/static_call.h:156:9: note: expanded from macro 'static_cal= l_update' STATIC_CALL_TRAMP_ADDR(name), __F); \ ^ include/linux/static_call.h:146:39: note: expanded from macro 'STATIC_CA= LL_TRAMP_ADDR' #define STATIC_CALL_TRAMP_ADDR(name) &STATIC_CALL_TRAMP(name) ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STAT= IC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX= , name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :254:1: note: expanded from here __SCT__preempt_schedule ^ >> kernel/sched/core.c:6577:2: error: use of undeclared identifier '__SCT__= preempt_schedule_notrace' static_call_update(preempt_schedule_notrace, __preempt_schedule_= notrace_func); ^ include/linux/static_call.h:154:10: note: expanded from macro 'static_ca= ll_update' typeof(&STATIC_CALL_TRAMP(name)) __F =3D (func); = \ ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STAT= IC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX= , name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :255:1: note: expanded from here __SCT__preempt_schedule_notrace ^ >> kernel/sched/core.c:6577:47: error: use of undeclared identifier '__pree= mpt_schedule_notrace_func' static_call_update(preempt_schedule_notrace, __preempt_schedule_= notrace_func); ^ >> kernel/sched/core.c:6577:2: error: use of undeclared identifier '__SCK__= preempt_schedule_notrace' static_call_update(preempt_schedule_notrace, __preempt_schedule_= notrace_func); ^ include/linux/static_call.h:155:24: note: expanded from macro 'static_ca= ll_update' __static_call_update(&STATIC_CALL_KEY(name), \ ^ include/linux/static_call_types.h:12:32: note: expanded from macro 'STAT= IC_CALL_KEY' #define STATIC_CALL_KEY(name) __PASTE(STATIC_CALL_KEY_PREFIX, = name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :256:1: note: expanded from here __SCK__preempt_schedule_notrace ^ >> kernel/sched/core.c:6577:2: error: use of undeclared identifier '__SCT__= preempt_schedule_notrace' include/linux/static_call.h:156:9: note: expanded from macro 'static_cal= l_update' STATIC_CALL_TRAMP_ADDR(name), __F); \ ^ include/linux/static_call.h:146:39: note: expanded from macro 'STATIC_CA= LL_TRAMP_ADDR' #define STATIC_CALL_TRAMP_ADDR(name) &STATIC_CALL_TRAMP(name) ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STAT= IC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX= , name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :257:1: note: expanded from here __SCT__preempt_schedule_notrace ^ kernel/sched/core.c:6584:3: error: use of undeclared identifier '__SCT__= preempt_schedule' static_call_update(preempt_schedule, NULL); ^ include/linux/static_call.h:154:10: note: expanded from macro 'static_ca= ll_update' typeof(&STATIC_CALL_TRAMP(name)) __F =3D (func); = \ ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STAT= IC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX= , name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :11:1: note: expanded from here __SCT__preempt_schedule ^ kernel/sched/core.c:6584:3: error: use of undeclared identifier '__SCK__= preempt_schedule' include/linux/static_call.h:155:24: note: expanded from macro 'static_ca= ll_update' __static_call_update(&STATIC_CALL_KEY(name), \ ^ include/linux/static_call_types.h:12:32: note: expanded from macro 'STAT= IC_CALL_KEY' #define STATIC_CALL_KEY(name) __PASTE(STATIC_CALL_KEY_PREFIX, = name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :12:1: note: expanded from here __SCK__preempt_schedule ^ kernel/sched/core.c:6584:3: error: use of undeclared identifier '__SCT__= preempt_schedule' include/linux/static_call.h:156:9: note: expanded from macro 'static_cal= l_update' STATIC_CALL_TRAMP_ADDR(name), __F); \ ^ include/linux/static_call.h:146:39: note: expanded from macro 'STATIC_CA= LL_TRAMP_ADDR' #define STATIC_CALL_TRAMP_ADDR(name) &STATIC_CALL_TRAMP(name) ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STAT= IC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX= , name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :13:1: note: expanded from here __SCT__preempt_schedule ^ kernel/sched/core.c:6585:3: error: use of undeclared identifier '__SCT__= preempt_schedule_notrace' static_call_update(preempt_schedule_notrace, NULL); ^ include/linux/static_call.h:154:10: note: expanded from macro 'static_ca= ll_update' typeof(&STATIC_CALL_TRAMP(name)) __F =3D (func); = \ ^ include/linux/static_call_types.h:18:34: note: expanded from macro 'STAT= IC_CALL_TRAMP' #define STATIC_CALL_TRAMP(name) __PASTE(STATIC_CALL_TRAMP_PREFIX= , name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' #define ___PASTE(a,b) a##b ^ :14:1: note: expanded from here __SCT__preempt_schedule_notrace ^ kernel/sched/core.c:6585:3: error: use of undeclared identifier '__SCK__= preempt_schedule_notrace' include/linux/static_call.h:155:24: note: expanded from macro 'static_ca= ll_update' __static_call_update(&STATIC_CALL_KEY(name), \ ^ include/linux/static_call_types.h:12:32: note: expanded from macro 'STAT= IC_CALL_KEY' #define STATIC_CALL_KEY(name) __PASTE(STATIC_CALL_KEY_PREFIX, = name) ^ include/linux/compiler_types.h:60:22: note: expanded from macro '__PASTE' #define __PASTE(a,b) ___PASTE(a,b) ^ include/linux/compiler_types.h:59:23: note: expanded from macro '___PAST= E' vim +/__SCT__preempt_schedule +6576 kernel/sched/core.c e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6567 = 1011dcce99f802 Peter Zijlstra 2021-03-25 6568 void sched_dynamic_= update(int mode) 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6569) { e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6570 /* e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6571 * Avoid {NONE,VOL= UNTARY} -> FULL transitions from ever ending up in e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6572 * the ZERO state,= which is invalid. e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6573 */ e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6574 static_call_update= (cond_resched, __cond_resched); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6575 static_call_update= (might_resched, __cond_resched); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 @6576 static_call_update= (preempt_schedule, __preempt_schedule_func); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 @6577 static_call_update= (preempt_schedule_notrace, __preempt_schedule_notrace_func); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6578 static_call_update= (irqentry_exit_cond_resched, irqentry_exit_cond_resched); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6579 = e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6580 switch (mode) { e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6581 case preempt_dynam= ic_none: 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6582) static_call_updat= e(cond_resched, __cond_resched); 9432bbd969c667 Peter Zijlstra 2021-03-23 6583 static_call_updat= e(might_resched, (void *)&__static_call_return0); 9432bbd969c667 Peter Zijlstra 2021-03-23 6584 static_call_updat= e(preempt_schedule, NULL); 9432bbd969c667 Peter Zijlstra 2021-03-23 6585 static_call_updat= e(preempt_schedule_notrace, NULL); 9432bbd969c667 Peter Zijlstra 2021-03-23 6586 static_call_updat= e(irqentry_exit_cond_resched, NULL); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6587 pr_info("Dynamic = Preempt: none\n"); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6588 break; e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6589 = e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6590 case preempt_dynam= ic_voluntary: 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6591) static_call_updat= e(cond_resched, __cond_resched); 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6592) static_call_updat= e(might_resched, __cond_resched); 9432bbd969c667 Peter Zijlstra 2021-03-23 6593 static_call_updat= e(preempt_schedule, NULL); 9432bbd969c667 Peter Zijlstra 2021-03-23 6594 static_call_updat= e(preempt_schedule_notrace, NULL); 9432bbd969c667 Peter Zijlstra 2021-03-23 6595 static_call_updat= e(irqentry_exit_cond_resched, NULL); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6596 pr_info("Dynamic = Preempt: voluntary\n"); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6597 break; e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6598 = e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6599 case preempt_dynam= ic_full: 9432bbd969c667 Peter Zijlstra 2021-03-23 6600 static_call_updat= e(cond_resched, (void *)&__static_call_return0); 9432bbd969c667 Peter Zijlstra 2021-03-23 6601 static_call_updat= e(might_resched, (void *)&__static_call_return0); 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6602) static_call_updat= e(preempt_schedule, __preempt_schedule_func); 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6603) static_call_updat= e(preempt_schedule_notrace, __preempt_schedule_notrace_func); 826bfeb37bb430 Peter Zijlstra (Intel 2021-01-18 6604) static_call_updat= e(irqentry_exit_cond_resched, irqentry_exit_cond_resched); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6605 pr_info("Dynamic = Preempt: full\n"); e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6606 break; e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6607 } e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6608 = e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6609 preempt_dynamic_mo= de =3D mode; e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6610 } e59e10f8ef63d4 Peter Zijlstra 2021-01-22 6611 = --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============5097423008052333548== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICJrnhWEAAy5jb25maWcAjDxbe9u2ku/9FfrSl56HNpbtuOnu5weIBCVUJMEAoCz5hZ9iK633 +JL1pZv8+50BeBmAoE76kJqYATAA5o6Bfv7p5xl7e3162L/e3ezv77/P/jo8Hp73r4fb2Ze7+8N/ z1I5K6WZ8VSY3wA5v3t8+/b+28eL5uJ89uG3+YffTmbrw/Pj4X6WPD1+ufvrDTrfPT3+9PNPiSwz sWySpNlwpYUsG8O35vLdzf3+8a/ZP4fnF8Cbzc9/O4Exfvnr7vW/3r+Hfx/unp+fnt/f3//z0Hx9 fvqfw83r7OL0948XH08vzm5uz28//H5zenby+WL+x8n5+cez/dnt/vaPw3w/v93/610363KY9vKE kCJ0k+SsXF5+7xvxs8edn5/Afx2MaeyQ55tiwIe2OHKejmeENjtAOvTPCZ4/AJCXsLLJRbkm5A2N jTbMiMSDrYAcpotmKY2cBDSyNlVtBriRMteNrqtKKtMonqtoX1HCtHwEKmVTKZmJnDdZ2TBjaG9Z aqPqxEilh1ahPjVXUpFlLWqRp0YUvDFsAQNpIITQt1KcwdaVmYR/AEVjV+Cpn2dLy5/3s5fD69vX gctEKUzDy03DFGyxKIS5PDsdiCoqpNZwTSa54kpJQnouE5Z3J/PunUdpo1luSOOKbXiz5qrkebO8 FtUwCoUsAHIaB+XXBYtDttdTPeQU4DwOuNYG+e7nWQsj9M7uXmaPT6+4iyO4pfoYAtJ+DL69ptCw r4yQBEs4NiAuJDJkyjNW58aePTmbrnkltSlZwS/f/fL49HgA3dCPq69YfAv0Tm9ElURhV8wkq+ZT zWseISZRUuum4IVUO5QJlqzoQmvNc7GI9LMHxhSMzGrQsUAAcGHecTsIzuzl7fPL95fXw8PA7Ute ciUSK1cgigsioxSkV/IqDuFZxhMjcOosawonXwFexctUlFZ444MUYqlAIYG0EPZTKYBAt1yBWtEw QrxrsqIygy2pLJgo/TYtihhSsxJc4ZbtJuhiRoltA9sIEm2oiFMsJE9tLP1NIVPuz5RJlfC0VUSC 2gtdMaV5uyv9+dKRU76ol5n2mejweDt7+hIc6GCDZLLWsoY5HZulksxouYOiWIb/Huu8YblImeFN zrRpkl2SR1jDqt3NwGkB2I7HN7w0+iiwWSjJ0oRRnRpDK+DEWPpnHcUrpG7qCkkOdFglNZxhUtWW XKWtEQiMyFEcKz/m7gH8jJgIgSFdN7LkICOELjBtq2u0F4Xl6v54obECgmUqkogMu14itZvd93Gt WZ3nU128GcRyhTzZLiXKPKPV9DaqyoLt49DU/EnZxHLRFStNryAHFLtX8BnbKMQaeKWnt+0c1ZQI q8tKiU0/l8yy6JL8SfuDVZwXlYFdKnmz4LAiAfxNDp7AKVFd+0bmdWmY2kXJa7Eip9L1T3dgOKin pZMVaINEKt7tFnDde7N/+ffsFQ5ltofVvLzuX19m+5ubp7fH17vHvwJeQzZlSSKBMKdPeno2Apww H4wCEqUd9YuV3wE3fgQ6RcuQcDBKgBo/p0qL6KH8wNqGQZBwoWVuNSkdzm6TSuqZjkgfbHQDMLoN 8NnwLYhZ7GS0Q6bdgyYQfW3HaHVLCDKKJd2cZEbwqfN8kHgCKTkcuebLZJELq7v6/fEX5TuKC1Ge krnF2v1x+RC22OOhiCuwNCD5A2YucVCQvpXIzOX8d9qOu16wLYWfDlwsSgPRAst4OMYZlQKLJcqU b6f8khqceeeeO/5Hrd4JgL75+3D7dn94nn057F/fng8vtrndogjUU0Rt7AHBRF2wZsEgCEs8Mzuo qwUaRJi9LgtWNSZfNFle69UoLIHlzE8/BiP084TQZKlkXRELV7Elb6xMcaJpwKFLlsFns4b/ebow X7fjxRxDC3A7OAyUMaGaKCTJwLKyMr0SqSGLBBXhow8C6NorkeqolLdwlU547S08A5m65iq2ggq8 V+oMIOfifC0k3FRQ+huR8AiNgB8qo2ARXGWRfmgljpBeCB01y+D8g7cGOtDzxJHpdATdqtXSxwUX MY6Mqy/JlsChJOtKApehETfOUHjGg9VGWnLpBGBY4bhTDoYHXFWeRlcJ8TnbRWhAtoOttu6gIhxk v1kBAzuvkMRGKu3C1WH09EjEB8Aw2hsgNFK1iDIYdyqsA1AY0g2yJKVp3N8xNkkaWcFBiWuOLrrl F6kKUB4+uwVoGv6IjAbqWqpqxUpQNIpof3R3DPGMnS4U6fwixAGDlfDKxhDWvoRObKKrNVAJxhHJ pCROWrpgngK8J4F8SKZecoMhWzNy4R07jZozWGJKIwHnODtPk4o1WgSaoyGaj+dZ5/906KPFdf0Y xEfo9xIKasO3wSfIEBm+kt5CxLJkeUaY2hJLG2x0QRv0yqnlTv0Lki8RsqmVb1/SjQAy270iuwCD LJhSgu74GlF2hR63NGwBvg8sB1kR1FsEw24HyjDG26F2sd5xFstuWPOFdm0gCKgtk+AU1klBImmI TL2wFLryNOWx8R2DAgVNH+tZA95mc6vD85en54f9481hxv85PIL7x8C0J+gAQhAyuHL+EL0D8IPD dKNsCjdGZ4HJVuu8XriYmqYZi4qBa2AjvUGb5iyWYsEBQjTYVQX2vg1P4rkgREOriO5fo0CEZPED iJgCAQ80tuV6VWcZeFPW1aDpCTIUrBV9u4opI1gscgSONbxoIGRmmEcWmUi6JAzx7TA9O4oN2qPx U6jduBfnCxoubm2K3/umFsYleVHvpTyRKRUWl2xurF42l+8O918uzn/99vHi14vz3g6hIwlWr3PP yGEblqydqz6CFQURLyseBXqEqkSv2yUaLk8/HkNgW5IV9hE6juoGmhjHQ4Ph5hej3JJmTUqTux3A Y2DS2OuGxvoPHu+7ydmuMydNlibjQUCDiYXCtE+KrkLQHXUIshROs43AgFNg0qZaAteQ3bYzgnfn vDIXnypO1mXjow5kFQ0MpTDttKrpDYaHZ1k/iuboEQuuSpeUAyOlxYKaLYtSgt9cgW6fn5yeB66+ xpTlVD8bS9gdY3mzqsGG5guCgslXixiKQKOpgvWDitomX8l5ZWBWOVP5LsGsIjVHbUqhqVY7DRKb B0nXaukCrRy0IFijfmVtbKNZyZ1s4CHxxKkNq6+r56ebw8vL0/Ps9ftXF62TgKwTK7oGXFfGmakV dz4yVR0I3J6yKproQmBR2QQo7bOUeZoJvZrwXg3YdlHGHDAcz7EmOFMqD+ngWwMHitzT+hgTQ6DU 5E1eae0vkhVD1yEo6V0CnTXFQoxbQmODQ/VH3mb4IX7L67GTLwvgogyc716YiUDtQAjA6QB/dFnz NqPQHT9TDNNAEwtcbVDG8wWcP+j8xMtpu+xwVWP6EXglN74nVW28e4g/ge6VBM/D0RDzOxJVjgks 1h+jp1tUOn5bUqCbEg8qwCzI2FH26oy6Ud35qhKsDOwCbHObzLigKPl8GmZ04o8HLtM2WS0D84bJ 6I3fAoZAFHVheTQD8c13lxfnFMFyCsQBhSYnItjZqRWwxosiEH9TbEei10k6zAFc5ph53Ay8PG5c 7ZY0a9U1J+BIMZov7QDXKya39JZlVXHjXOugjUPcgQZFGbJ3aUGkZQkeCoiMZ5RLq+Q1OktLTNwu 0SLHgXg19GE+ArYOGdnmFkJaumRUrT35cs268PjWNRZTysze+Tao7QKOk5FGxSF8Ny6iXCi55qWL VvHCK+AbPxxtmzAXl/MlS2LBfIvTH3/YGRngSDe8qNIrSQsNhhH/BJVx+dCaC+KQPzw93r0+PXu5 auLOt3q1LoO4b4ShWJUfgydYuOAn6gmO1dLyKpp6CvF6WnpndmI9dBPmFyPPlusKTHWoALo7sZb7 vZtNxxVVjv9wGu2Kj+shZQsWXsnEu03sm0LJHgCebA/NEqtHUPVlXmbBnivomwfaYA1AyDYfrDcx wTWpUMAWzXKBLlnAv0nFXLGJNiKh7igcARhAEN5E7SozCQAjYh3axa4XaHoxVkczSs61ss6FG4qN nbgBPIzrwXmOi2qNNF7r5gGGzV2ukYtcOdJwjjnKZt7ZbbxKrfnlybfbw/72hPxH96lCSpxIj/yL AB4cF6YLIYqQGsN5VVdjZkPVgm5B0a1mQHTdCcsYpfwvdBiFEdd8sr3d334fTybQcMcxfWEVcYc8 9xbJwlMA90KDR4vSyvzktgW7UDrwryDA8lvqws9TDo5eux+tJ4z7sea7eO576GT01vJDeBN5BLGM T98jYEZ3cla93EZhPBOxZMx1Mz85ofNBy+mHk+gQADo7mQTBOCfRGSBiOqGlNVses4q2HWPCUPQw DHHAqlZLTFzsKL0OpEX8OjJRTK+atC5iNyR9SAQqB+L9k2/zVtJoBhxzJciwx/pDGLwsof+pJ6gr kKO8XrZupZdodvJFEOK7ar28/4zW5gY2qY6zRasoAisTTUwHmFtZ5t5uhwh4ER6nqUgx9sLVxgwB 8LHIdk2emtgdvzbgjhs8VAgrbPQ5lUm3yYIcVH6Fl3WefT4Sno74i6VpE5gjlwFZVSj1mIRxcTXK f28gnF/z9H+H5xn4Afu/Dg+Hx1c7E0sqMXv6igWpNBh2iQLiObaZg/YKjLgyRaNzzqtxix9RQysq gw53cHOK5oqtuS3QiTFuESBbRosigrtLFP7VJ+cxYR2XSAQfijqmMhW4EwQ2+uo4ysqYBr9Yrusw 7VGI5cq0BWvYpaK5KNvS5iYdbdbp0ySN16/U4tq1Ln2vz8fQVaKaKaG3GFmVmnAdlQibgiO0bYpv GrnhSomUxzJGiAP6rC3lCgAsGay5bVgwAy7DbrTGRW2MjBdyWLgR5a7drTEqRdwAmTKYNGMltAQD suhVgt1vd3fv47clIjLme1sEUUHM58+bQNwlgVc1KA1rJ4brxUGQHTHoYNTVUrGUj6b2oNNbNCUS jvwET1eGBw5/GwZaTwXtnQYX0g/uHJcs9IjGVTSNT3eh4GYl02CH4C8zNOEXOKZJrYTZhbmlQZpY xcVUe1PayNsnDgGTh10ZUhGGX47NBqpcGxxXJjYqoB/8YohVw2O3f2ekPqXCfKaswDf0nVfH0BPQ BFRIijWIk92t39wnJbpiq1n2fPjft8PjzffZy83+3sWsXhESaO9PU+VMkd79wOL2/hCOhcm0ybFc h97A/UfD46rr3l66htkvwLezw+vNb/8icTewsgvJPJsArUXhPiJn3d41YK7Cj8XKBbXBE3M7uu4e 98/fZ/zh7X4f2Embx6KhsJ8kPjuNUNT6QGek7N01hd82i1JfnDunrQAT5lE8osoTjPXGs5yYOa1h nOtRDVq3JaCRNtsPc0IVJtVXbN6UImw7/XARtoKjWOve1ejuz/bPN3/fvR5u0Jn59fbwFWjH8x/5 G875Da5trbvst3XqyaWw2sYuKQobFDjc7u4hqjn/BEe7ydnCD/6JX4fvSGxKGSPmzMQzwa6QtPcw 6tIeFZayJGg0xkGfLYEDm9YssMA+UGYC1ooOXOSWaR1eo7hWvDmIAWQVb2+HQRcxC6oxXJIcAmjM DpA7Rowdu2mC0TKIXm1waZ+JtFm0oNgd0EqaE3WDCvUpy9lSj28wh2J/i7kCLysAojSj+RLLWtaR +mtwO61yaivTIzEayJVBn76t/RkjaN4lSCaAbWaoGB2ho9y9zXEXwM3VShje1kfSsfC2TfeXXrYu 2/WI4pXSXSmH8+kCI5T2TU543GA4QKzL1J1ny5S+KnR4riYierb4Wmiy4+qqWcBaXVlXACvEFgRh AGtLToBky8eAvWpVwhLhVLyikrAAw2clRwFTKQYPtqbOXft1JXKjQSLz23ZLhNsijL9jRzqoi+NQ WsXiM44TBFdy2t6uhEO1uqPlG4zyAoy2n8vJT8BSWU/c7LZWRVRJ4x5odC+5IriYWB3wY2sGdw0R joDaa3MSRB7pgrufA6sEwNGFLtXQBDKZLO2iu9zI8FnjBAKIL73/wfa2iH5E9ZVA3JZ17J1myF+o qMBXtMps7VVXRcGYerOjBXgT9e+h/RhXvocyKZHn6zTaXITNnRoubYYTuAJrAiJsOYkXmcpJA8Cb jac9B9azQCAGHQ0VnUrLzKpgsxutI+2S4DzBsh+S2pVpjWE72mAs1EM5jWwf30IkAlrPvq2KHARO jTBAkVdliNLbCDuDzeGK6+gSvKqbAMHSEDVefq+hkCcyLqnCmRqEokSGasEWHQv0QjId17fPqcZW HzZYuML43pcYMNArX9SBRUGdo8WyTTWdjdzhFs6S0NfuPeqFcFe1Rx8RIt/1Bzc4yH3r0c79oTZr t34UWO4FJBMosUK6kWvhsontm051RWqRjoDC7o7Vo91joGFxEGjmEM+0qWTfn+gdWPCLYl4q2mBa nxh2bcs0I/difQFWEimU7Titc8anIaOn2M6+Tz1XGvTNVImzbx5cghuVmq1KjMu8vTMLg7keAVPp pRRpk8/T8IFG5wYCf1s70gdSidz8+nn/crid/duVi359fvpyd+9dSCNSyxmRaS20e43epa+7Oscj w3v7uLSnUy9F6ZWw/mCc1w0FRqzAumaqS2ztry6QsOGCzbEpbEZXIxnq8bDBvUYFLmTeFW8LrEsE xCttBud5Cm5JUUn3Ew0s+lpxIHlEWrsMqv8IxGNq0o6hd2QpLej0NP5uIMD6cPEDWGcff2SsD/NY MoPgAK+tLt+9/L2fvwugKBEKA4jwMWIIn3x3HyL67+cn0SafULSIKMpX+DZGo0PVP4ZpRGGFPr5e GwnjlS6s9v3L57vH9w9PtyA2nw/BurV7hBdeFCzaJ2L9p3uistDL0Rs7AsvFYtyOt61LzJkeATVm fjIGX8NJeJKCgKtFzDq5Lqj9aJaftvajEZjGUr+K5eEcTkt3ZiD2HrLaP7/eod6Yme9f2ydz7QC2 5NtFpekGX7REc88F+AgDKhEunUodA/BMeM1D4jIgxTvCkaLH5RWfMCE5akP/nT62wGZ7teV+wkAO jwFJUgz6Cemqs1LwBX3rRoDr3cKmrYcXsC1gkcWzvf58P/WbiwXzNKlXzonH5s5NVxDvoDqF9Xu/ etDCbeLDwY/Bon2vgF35VGcK9HsHt3hGoh1VBflZB2tzHOnOb6dBqbrS4JZMAO1sE7DeI7K/d5Fa NHuNOaBMQ8LO6ireddTem/USKQKblLOqQu3F0tTqPKvBYs5h9zCmWfAM/4dZD/9XHQiuuzO/UjA4 XfNw/WsZl3873Ly97j/fH+xPIc1smdkrYeGFKLPCoGs08uZjoNaF8n17IBWzMv07eYyt2ofAMW3l htWJEpWhQtECJh5C4jRt7qcXk6nV2aUXh4en5++zYrjUGF+iH6u0Gsq0ClbWLAaJIfMt2JSCx0Cb 9vq/v/QfUiUhzlSIk+FPYiypsWqJ71+vB8zSVki1WG123rPwHiT2VqfKIWirjNOoWMV6HpuhRcM6 SJMH17SWoZLQlhCjsUTdg+oheO7T0Tj+kZbE5pebwNXHKhorZ40J3wLZBI2RGNRS0tY6VsXdcbI9 LvfbH6m6PD/54yKu06YK6kft/byxZMxU4Onyy2ZVNe2VxLCxOWeuPi0mMfYBD6miYbFfdSFQ+/KS bDFeyoFJ0Je/k/VEczvXlZSeI3G9qON+3fVZJvMJkI0xZEz4+wskfJbS3cLQ+eDAuFJ+ata+IY4V olgY3j/gDQexY2n3rG2cCxxiYFug7yytlzkagkj7hMnPnaH75T+o6lrsJSMtKbZl7hA0xw4JBD/4 /S9vVptT8xQVTxQ3TlFZnZjuX/czdoPFTLOCFk4PG8mKUEpbZTvVt4NP61tSNcvNyJtMD//c3Rxm 6fPdP55z5TJtQntMjN+T70CpWxd+tD+75Mk+NFulAyohxiYAZToob2rbjqSKehRbQaCZ/1zWh6IC cThxvdgjDy/EJxGBA+IvO+31u45VWSDkUy3UOtwVdARREjvdHhaJEsz/5+zJlhy3df0VP906qTpz xnu7H/Kg1WZa24iSrZkXlTPtZLrSW3V3KsnfH4CkJJIC5XvvwywGIO4EARAAeVX75kBjqp0R0DNS LwAAj4gEpSEJM5FMxLAYLSpKVw8Kj7PQKlxdAw0upepWGv0GRtoMwL6/PH+8vTxiqo/7fh2aw1sG XtlGtPIrCBoMVsVMTu5paJCPObFovoBTznba0Ovw8LqGzoCBJWC2ODgn6ixE35XI3RCDMAq8lNiV 7w+/P5/ObxcxQMEL/If/+fr68vZhDY1wXK6QnU2NDihvwJ22kzSoD3uL2/WIqONAE22SIt/LrzB5 D4+Ivozb3DEqN5Xs2vn+gpEYAj2sDMxZNSrrOm2vqdLLrF+C0fP968vD84fpTRNlYXdza4x5B+89 mhybI4LdKE6MJ+t7gGeVTw6z0Zq+fe9/PXx8/3F9p2DWPH5iVXCoosBZvrs0TWBpktZizVpFsB0d mUa8goUsH61oYQl9+K4OmlneKwP9l7W0jh+ipCADeeBUr9JCF5E6COgOtTlJcIRnoZfkZMhoUcqa YgZaMIYmiLRL3SEdP7w9/YWL/PEFVtfbsCDikzCfGupeBxKCS4hpkjRlDVQRr69Ec3EcvhIX67LD VKEaGoRYGbyp93Kg7Cx6RG+BSEhNuuZm97GjVbndjrq614k6whRI4yzoIGXD0m89oViHJTviMKFt cDpuUxx3joyUiD7WCQZg+8DvK6Ybustob0h98nfL9FxaCsYTlqIm8mTD9es2BTstRqA01W1VXT26 zWUor/WOqR7DjYI+3tuKxRJHxpU9IuMoC6QITHsPOvZR7yB4L+Q5Y2N5ZarMnRhy0Sb0weRXi9Yr fDeuYSTuwDhMBfxoE0fWUxnzwppi3TRtRNfwBVYw4BhpQz8wW29UIKdrb4dHjtglc3syvRm7gTI3 /SAHCzgM3YyLHG2YmxqZpfDN1KRshklIfjvjIfT28vHy/eXRHnoepMJLusqDPCHn9P9ViyaVh5SZ t+du0qRhrjPGyGy4KbO1UAHC7NEp8BBUu9CshvZgjR9pjCbe9wXoXKqHd8EklKED8GaOFQRgAtci iWLHugzS9Q0squxYemQ4eJ7vk2jgwf9YCG5EI0sYMjIRk1vZZiJFgAnc8ozn8F8R/zsKx534oCvc 3dZjobmC1zjSgXE69CCVTkXmKL38/nae/dYtYnmY64KSg2B0HnTLv29UxjUuib9Aqy1RyzWBKSYL pBCclfGAGUYGcbXfKBS1g6tQ/wB+iuOEjwSL4Q7i9fz2bl4QVOjuciPuLrhdGqyd7QrWjkDSl2BA 1QU/TVMJ+2HZshSkgMqj49c0uqqkA/uQBA+HgifjCjUaOD3ECu36RaCkAyZav+R12qeFswDhlSs8 GvQ7qjEZXk/0QWSjC6Bu8MWc1PBfEPTxAkUma6rezs/v0g97lpz/Gc2Sn9yBEDGeI2y7YxDkHVOZ d1Hp2cvHZfbx4/wxe3ievb88gUJwfofqa5/Nfn18+f4HlvP6dvnt8vZ2uf/PjF8uMywH8LKs/2ii XpXowRf2r7Y86XyBIYwWhuOwtXAdc+OYhkfrLk9tSmMk8ryYXH7ybg7zFHiY0mC0S4A/fi7z9HP8 eH4Hwf/Hw6umQOjrPWb2JPwShVHgEtyQAA5YlUL8ySoKryFFGr3cNP106Cy306hbBD4GgKNtzbK8 dvhEw08Us4/yNLKc3xEnXbeyu1ZkymwXzhG2CEkpZUy2NreThd1NYo0EfmO0abjs+sncPRBoV7sF ck2WuHN8klfkhAhZDzSfiYq8NORVOF4roLN5Y2hdscRicV5qAXIL4Pkcg0E0gW9i+UvTxfn19eH5 9w6IV1mS6iwsrtYeyVEkaXBK8GaRmxOFlyAob1m7SIHV7Z5jeDoizE4lLz2sIebBZjkPQocTCBBk USVonAQV32zI6G5RfzDa/VJ4P5awVymlXHyVeJWclMHIc2U8Zfrfy+Nvn9AGcX54vtwjM1ZCOWXb EBWlwWbjXuJ4PR8nnplESt9CwaFYru6Wm625XBC+3iXb9dyE8yLySiEjmmBeLTfWmuTJaFUWh25M 9KqqkJZU+xNtKQUfaQV8eP/jU/78KcCRcxnqRc/zYL8aqveFd2oGynf682I9hlY/r4epuj4L8nj1 stCsFCEy/MjoN5xCiCGBMtvgV+msYG6bjkLX1gg091JeOxKW63TAnq7SLBs8tvbuCSm9U6v6Ig/R 81+fQc45Pz5eHsWAzH6T/GSwPBJDFEYY9WSOh4ZQm85GQj8xFV/l2SMhuwdcwpEZqyNRguQ0UeDF tL17aEeVOkLAepLUK49RcoWIJwEaCFbLxi37ytL+t4R+GaRiEiap8ibz3JKTIIlB3GaxIwdZR3SM t4s5SH9XyPihjZNgQpCTM+8dWRbQ9pSeqGqa2yyM02s11pnDMtOToIlmM3c4MXZEaIG5MjOVSxaX 6Ga8bWVH0PJ0pRNVignP0uDKok4jTkZn9gQir+N4N/WO01T7Ai+MrLu90S4oPW7GyvcolTlwP77E SR/ev5v8AIR85cI4biL+ha/VjDHADvMDxT8Yv8sz8Q7OFFLK5r1HoMl2XbTCV+rnObV2bWJ8duTK ch8+8f1KMH/HYKPBVOe4URDAOfU7nEza9Y9dPBDZclIHx+uQg5emDscWi9I3845QlXc4cRyKJiYF DNbsf+S/y1kRpLMneRfvkGLkB5Qd8HpRljSIo+UUy0CxNdcFarqnRMvzpnvU9Kpw5KvHz5ZzG4fu T4aJvUPskzryR6Jjr1k7V4fIZ+m6ZMqpJEt2FhEZq2eGyA4AzcdJgNqCcm/pkF6z293cbo3LOoVa LE0fcAudoZFEd4TKzBwuWaF8gYF/cUxOM7ZiKbOusVoY9+BTqt6sMPOvKLflEaDN6iTBH4ann8KR OcODsNQTa3W0eEPMOZ4BrMCjWe9eR5PkeTHqWFj6IFA+vKOb4P3s18v385/vl5lIoRbzGagFDL1S 5CePl+8fl3t9BLqieUPpoR0WBe1RizEtk4i00RIs6zjhP6TvANHztrirgvCoia8GWF3aYDzYcFFq EJxG/mA9oXRyxkZM9YXD4HYmrWMaaVfoihKhVth/P9vH1Hw/CklF+n90xydqFQSx55dGjj4JDSxA 5ZX7yLjK1sDoB8KBs9Rkz3VCe5UQJLGWHMeE48e6nmmMUH/oapdgHdsIN8tN04ZFbmYRGsB4T0i2 XacBhkvShHWafsUbQKJjzE8xCt3gKgcvo/PXVixOLZ1KgG6aZmF4sAf8drXk6zmtDQuhHRRVukcg 7CQ5x/yx+HwdCxwZIPbRIWhhMVMs81C0LDHe6hAXeEEOYq1LFRAUeISUjntCrwj57W6+9BLK8M14 srydzzU1V0KWmtbOo4zn+IgbYDYbAuEfFjc3c8PuqjCi8ts5rXMc0mC72lDWs5AvtrulXuBR+RSg Td3lcYuxhIeaemgA5NQKZgQkkmLVOWfpraWV1fDUNiKbP7Jp0xmrd1VRfigKpdyleBhHehAw40Fb Vtxg76g9wF930de25lSbg6U4bp/M37ApoLFe2S4XYiakPBcB508NV55uUQoMrFxH4NaA30zhnclx FT71mu3uZmM4NUrM7Spotu4Pb1dNs9YMRwrMwqrd3R6KiGsRowoXRYv5fK2zK6v72hni34B2iRt/ dIBWl7/P7zP2/P7x9ueTeP3i/cf5Dc7SD7xTwXJmjyiiwhn7/eEV/2te/P2fvx7vjYTxlc0fuz0r XOLQdltoJrEuyaaeGb0DwR+Dk/XwqqG0ArWdjmlgpK/aR9npC0UfBYfcEERxSXtJgGkvAsqJsV/z liGmB8OiN7aD53uZ13pUWfg0ldG74lh4GaMdsYyTShpEA84649tI3UEkBknobSk9ForXkymGKT6w I+YQaP5SjtHDpCOsk8/sxShaqJomszH+C1bOH/+efZxfL/+eBeEnWN8/kRIcKWweSonUuEf/gZ58 vKPbj+l8vicIA01hVgOBD9EZcdcCnuT7vfk4K0KFy4PwXOqu2EXPq27TvFvzIhx9cB7scjBtlIKb I4yYhPncYZySNGUxnt3BcGu1yPo4yU+u3M1y2g+jNoWHtgw9+nDuCEQYhLvMNkoDa+QB6CW1p2vW 1ELvOUql3QJxPNTQXdaQ2uSzNX6OqSowsxLFl4Cmiyk2PhRp1cgOivMzHWswgeZX+tfDxw/APn/i cTx7Pn+AVj576HxztDUhajro/ESA0tzHIPNEeKAnLPiqW1j6j8i3KoZOIAVLaUFFlLGP8NEBNx6Q wWK7pJ5slG1A506q+Zwly7WRMBKB9rOsHQOlNrwS5O0gtiqAk9R12Y9IjM3XDXsIKwQv0566zAvx uoXSU4aN6BeD7qJgcc2tHBkSYkv4FtLT32mRMHxBk++jnxdDthGFkS832BUofjNaZSyKotlidbue /St+eLuc4M9P40MgZmV0YubgdbA2P5AHXI+HgdCy1/XgLOeGT8dkS7T59QI4u3PMySx8O8eHBXt+ /fPDeZ6xrKj13On4E8S3kOtihHgFKkYPqsRIFycxMm7vzvJukzj5gvedFczXe6c8ooNdv3NNq4v8 Hl84gaOEXNuS5Jf8q0VgoKMjWmSe7K+io+WyqI3V6I7P+hZkcD93eV5r7Xa2CZqM+fg1r70O0oJQ k+hPhg+IVUhBQ0Me6+FB7juM/T3JPl5S+3zAl7pF2wC3utvxgKkx836aG8aJHity8XuO94t7Ks5C 2A4YkTFNV6UhJQcPtY1OHQvlUKJsquVqSYzBCV/xM/N89Th0PksSj7oeGXqJwc956RODKFC+kW1j wGFkqJ76dRiOEwvhBznw3w5RdqivLIbQv72yWrw0ChyK9NCMGsSBfenF9LE4rFq+mS8WUyOEm7om V1lTeNRGQDDwKAJTcIGTTuXjtgzolnxPYCBsyoAY+i8npifs6eExZ97Wt7mo8GbV+K38jYsRzvso 0Lumo1hRRdrjJBrq4GUnTBenzbyGvfMr8iFFjaQAVZ3rCSoVTrqEwlIH3WU95p9VXgcHHpSR63lz yQbpMPYyZWvLviZAGCRgQnDWtLolLKW6JFDxXMvH1UFEV3Kr4GWo9GqbfrEYQZY2ZDUfQQy3LQWj 95xEbjajw+dwfrsX7r/scz6z1RvRBTPi1bx/sSjEz5bt5uulDYS/racaBTiodsvgZmGZ5RAD5/ud Tz6DKdEBK/ioFtCqEPpkQkvvZBMq2wVRBIDQam6XAZ1vZdFWO/MExsErOO1zojpfZ2uGn0/QCL8v i0QR1NYwI1s0B7ODtBnfbHaaH3YHT9YEcZTWi/ndgiCP0918oQuG1DLphUZK1pMCzI/z2/n7B8aY 2Vb5Sg9iPxr5naW7vAjTT+xUa8eqI6Bgdq7+w4mkHsCY+SI0TAB1xprbXVtUXw29Xb1vgGByDpNQ 2JrqKrezaSl3t7eH8+PY7Vbxu+7NR3MtAmK33MxJoPbot+ZkS9BZ15E6arHdbOagTnsAyhwe7jp9 jNIUJb3pRKPxNhqtx+EbrTT0TQ0RNV5JY7KyrYUP/JrClpjiM42mSLrnIV3Dk3ridQWX779OKqK6 HHdA5qRhRlYVLkaWVJJB9kYZJ5nuip4iTtp8jM9tFtaPh+N5Yo2E5cHqKlFZLXc7h4lCI8st9Yye g2q7ubm5Sgabtjgwh/iuE+Ijn9crZbSSZSzY5to8Cc8n1zz5QXqzvFmM+ET28vwJCQAiGIawtRI3 JqosL/XhDEvmC9rnt6NyuvEpgpFnlU0QwLjdLBaTkzrlnalIRs5gVjO8ZiWfsaLgDbFunaYwicbN n1gOR6NmH1pOmk66rhuX7RpQ43SjZgXkBa/C/mJeCHed5JPb71jtNo5HuxTFtf0E2mHFvkwORRBk DXU/3+MXW8Yx5s6Uom20G6MCcscVd3jXJXu3gFjqR2XokU/6KBoV2zVqhJL4fqm8Pa4LF17g7PnW cLgaxaEwOlR0It+rQ3xR++fFYrMc3hIjKN2rCG+KkWRy5zYchI5rRCBVjkqyWqRrmQMMD1nZ2YWF LIvlaJQANpzKw0PpCouetklBDr1AsSxOokbhRysEY8kppa7DFyV1jiO4G+HJlY8uqJNDeIz8+ups 5KdJNgsLl77MMYVDm/vh09bSt3XcwUzebIWWXVARZfm33Hz5R7iEgejtHklxrVYb0XhFKcxoxDdF IR3PBgcI6eZEDLkiwAeh0HwQJrpJSUAx3DiMzNdPBQKvRFqVf3FQ9QUGL1hlZmXaHiDKFS9rDk+h ulqlXyhIAGexYYNAIPxFGQIE7oSv14X600eylZhwKI+Nsjxe4Lv2dwGXNL7D1TsrQFIAxniVUBXo VyTZ0Bx/NB7GBfdJpeimrtWKAmP9NXe79GTlWMLkWw4xchSmrX+EPIaoEZ+S1pQ5fFg6NZ8V6UDU O7GwyvbyoVTxGBRZdxXAn4L0xoqSQETP6m4zyVdMLBAknvFUvIJblNJ1QEHkoIJOW/PKfknSwGHM rczrQbKKsUItbxCWAXHJsrTfKAMI8WIWQsXNAnDg3ATbWVwFDF8VEZcbGjCtm+6yPP3z8ePh9fHy NzQS2yUCmAgRFj/zSl/aPaDQJImyPc2lVQ2C9AoB/E2te4VPqmC9mm/NDiGiCLzbzXox6pRC/G1w ng7FMmTNE9XBSI9LTJMmKJJQN65MDplZscoI40gLhhRcZTfpF4b3+PvL28PHj6d3Y22AFLLPfWac th24CCij9IA1LvStOvp6e5MRZtwYFoBKazSDdgL8x8v7B53ZyKiULTarjTmWArhdEcBmZU+Xl4Y3 G8rBSyF3C90Aq4AgNy3twTmwZnMIaVEB8Ww3p24YBIoHB7tdjKeOgwuQBWMN7Q+H2ExcFVHWQoE9 spB5sB9qu0rO+GZzS/vRKfx2RcWIKuTttjFH6sg8e5QAVJTjNFDC/YIIjBAlB+k4P5xgazI3yq+Y tUUFlP7rCRbN4z+zy9Ovl/v7y/3ss6L6BNozRpr+NOIz4nB09tmrbmlfWoFsGkbb1AXjDNLlbuUe Th+9G9CjapLiLs8ovVigyyDllW/xYDyGbJEQEVPBZQIfcbbPhFfdpKOJTTtVJNuDVJDk9AGLFNF+ OaeOd4FLo+Nol03yeQw5Al3WdVkrSbi7vSylbRQS1+ALsA5vcEGRFytHcCKif/m2vtm5ds9dlCLj tzrrNr4IbLXdTNSXVjfbpXvtpsftupn6vKGtYYKFSMnT0ZccTQDcXn5OG4RAnlxnJRwo+vMmJhfM 3M23jHAGTvqkT6zbkjH3NPNVsFw7rGoCf1D+XBN8NB1l4dPRhcuTA5HuQ0FoqrH7WJB42mIq8HW2 BY1keXIPDP+afalBL3DvL2HHa33LYc4gmbTI6gQt7UEmjpHJrJxIcZo4PlWOTdcClk7w9mZsEneL m6S4ndhLmKV0dIJFf4Os/gzKPVB8lhLP+f78+uGSdEKWA29ra110F/AkW5qSTlAst4vNaLfIoDRH n8vcz6u4/vatzVG1NWqovJyDJp2atYgXpqUmI/qTf/yQMqrqjHYs22euknOd4xWUWCFUUWeZwzwt ZQm0KJDKkFPINEQWTIhr9IknltbaA5Xzvkv4ESQYSgFrtxqdvCLGz/biHxGg/GxNrYB3Oe60ro16 s9IWRRBmHCEq54++jsOThqAMPcfA8WXKUEkEFO1MaGRIRNcVVYIJG1JeozE3Pb/jYh/8aCkHN+FB 7c6vO6BH42vSlLerteNCQPhoH25ofyP5ceqFXru6cVnZkaaR3t6gqDJHNmFET8mEGt6r3W1VRuxr +PbAnRZzSdV+ob1aBZpVvvHoI1dvzkdlnHw1wSpO3jBBDuC2mWoGdXukoQc50zD8IuaEN8bOcgFN h3UopEjVOS7Sr2iBSaCBzzqRUXE7NSfSwD01EEgBR2s4RSMiru7qrIhcd2kdEY+BO041KGuKFm3q 7hUwsirj/k/x39jdQuelG+KyfTSKedHwSXozb5PEcVGFBMVut160ZeUuA0dxcgiFRI3/C9yF9DSO pB6Cxi17S7RT9pboOztA35ydQvixO+dG3tdhIKe5E3N5KtsLW2SFWU80t2IjXjAqoF3M53TEvqAo Xc+IIBaG23WH0mFb/sVdPwjzS1LdQCQo0Hcq2YXxUQfHzeAsuZzq9pfavRhBC9hODSkPFjvGt3N3 t1FP4CynZVxJMPXtYarlIMIxx/MFAu3SMDokunG7Cdw3YgKL65LWQgQe/d2msNsJ7KT6IXZWM8Fh hG6yXMwFo52mWizcPZDFzGFd2UnFaDJQJtwbh1JFTIK8CBIWx3jn69gBDUbzmZxgrMII6AR3RY8n 7sE/cbF3n6vfYAam5AbEp0W7/2J5NwsRKSWc31AO1EzclD8LTqspD/WfdukxlCw5khzhjytWQ/DR PjYo4uQNOI5/Em2XzdweSiHxu+SL/tFU7ZOUGrKDHnUJP4zLFumDy5mVR2wAPz5g5K72NgvGMx50 p7iiMB8RKYjU2NLoXvCuPGoO/svYlXS5jSPpv+LT3HoeCW7goQ8USUms5GaCkph10cupclX5tbdn u2a6//0gAC5YApQOTmfG9wHEvgYiICBvhWAd/8W6MbM5QuNRuybeMPc2VCHN5prWpP0p/KX+/Prd vi0Ye55wMONqXXJx6O5HlN7FZd2sCikc8cj99xfhoqw/v9bVQRjWbsvx1g0vYG5R3AuyMWvAkuO7 n195OsGK7Ae+Rf9dGLbl+3bx2R//rT6rtlOzJkbeCG21zQXyZkwh8N8UVdzZuL0FzFFBf7KFRZZ6 MbHlTd6TgHlUV2m3UKne7kC1Gp0xNvmRwzrCQjlkr+OQVfg+fiHl53IYXq9ViT0iXUj1K1+3zo43 DEi8F0fKqC7A1d+L7u5nSdjQTSNqN2xNVda2XSvCI3nPyyIDF0D46L7WSNley2H/O2X9cgaFNJlQ E+SblZEdLsPJxuSbzjmBZpHkJR7hL3DnMeCBQHqsyhppWnV5q2QyrFB82h4qVsq6sdCxOrkrAdZ2 0X4DAkqyT3GpyK1pBzs0cH5vjXwDH1p+vP149+3jl99+fv+E+k+ZIxl4j3Q9zF7TepwvLh6yBpol Seq4brOJ+HoEiRA/o7CIjvMOO8In40ujp4n4xshOIX0yQlzv2OY9+d00frZO4mezHD/76WebDX32 y8mzxOxJYvgcL8iebLDhsykMn6yV8MkyDJ9sNuGzGcmfzUj5ZGsIs2eJh8dEdk6I9zjLQIsf51jQ Ho8gnJY4jE5btMfVBrTgqbQlEX7NZdLo4zYlaLg7eIMWPNGFRE6fqoXEYfBIp01GXItdc8ekNrvg /f3j2/jhX3tTXgmmoQzDropPSUcE1sIRlNUyeyWRszCpg8gBUBeQKuta2CFovt1ngbAkBlbtZmuV kU9Uxl23j7gEqob34ghJA+65ZjpxFd2vviFdjFPr0iabksDblN+kyc7Pb9++ffj9ndBjQApeJrIp evz2UsLO2wqZRveZusCLW9Yr915Cpr+lUjOF3r4LgqlKoWKVrtAkZaiBP1lUBxqzZLKCNH1OXUoK kjDhxz0z6LBgJ55TOhQEBGhe2BrofLLoZrCq20n0daIRPvAIWPijvKPWAJbWcT8KQ0ZG+RZjQMJg cvRZZ+uT+2i+Wf3HjMI7zt32eUx84xmXlo6RJlZNMvT0aoEC3lytIE6XBAK9Ve2hawujz92YH+ch VY2r7eZs1SUT0g///vb25Xe0RxZ9FFHM2KjS1T1sACCT0a+E2mgwWdU3yx1PBTdK4lkRHmmUTMbH x77KCfU9pFjD1LzIVK6WjYKQQ9exsAtIK56h+rVrMyNhh4Kn1m9uV0MOZxQRsQrAecEmUKkh5cbr PkgdS7q5MgrXJfLc5aMxojsRsJpQU2tBL3AWRx6NjcwKcYrVgwQwNU2Jv28mK7ZbQ4PIbABcmKaa QUGkwlaXoY9aulR5dZfDYaS7I3I9HfA7jQ125rmp+Sxhzxz40fcMVXdwLCod45jBqlKCjrWUrPgi D4j5flFxioqVI5w973YI8S4x9c1OKccJ32r6TR4EFFUOlBmpWKfavZPTxJD5obB7ur0WspMlLRvx yQSp9jkUggr4+vH7z7/fPj1YqpxOQ3kCB5LOOuWz5aW3sryjvIN+eIlT+N0UyfD/8X8fZ+2e7fh/ Zc0aKMLgU6dNLhtWMBKmWKnrFErw4K7Fhxrav2E6Qxtjvma35OxUqTWL5FUtA/bp7X91a1U8plkp 6VwOjiRIApNqOXZIyLoX7QUVDMWkhAEI13Cmc1qN4wcPo9fsrmuQYx+lcujj9AeeM3UBPgrqnIc5 CBwFFHkTDiTU01qEAvg4QEsvdCF+oiqP6e1l3WUJt/dDydQ3VYqQ7zhyEuvPrFUYFNFNPXUnkZkO rhFel5d1N8o/HpLFY4j1Jd1D+gD3Oo7Hmipvmc8fEhdP64+/vKMXrPJYTnDtaklil76vNZ91qtzp +7YvMklUWopYTczSzZgTuGc2ZHCteILHRXwd7MXaBHbIQCvsle+sR5qGEfZYYaHkN+L5yludRQ5t O/ZwudoZNLnv4GuD9YKwA2YKd8kVR9VATdZmsxitqyXSw3uoJ6yi1gTxlW6AZcxaAWdTT+CqUqZo J0q+hPATL0QinRFil5dAiLoaWXLO9w68PoPARirWQ2xquSwQj46mHjbwLYy6pwlJ7Ejne10kRlHi ezGOQRz5doOEZ3t+TGobEalMKfq5MQ5ibN5fCLxmQz+asMwLyHEponKIfgSJMBL12ZoCRO4vRxRd rqiMVO0wKhBPSP2z5hCECdZjTtnlVELxkjTE3q2tvK4ujhU72+1xGCMPa1nDyIeJyJYLrW++GO0L B8a3ASesYGC8DLA0rtkv0jSN0LZ8q+ocey55vmnumMSffM2qPdGRwlm72zgPkiZbpCVgxLTT7Fzg UI2X02W46GYNDBDraCup4DkP0eBFErqUmFQKfsm2URrfI1jZ6owITwJA2NtKnZE6A6O1qjL8JHEE TkmIdZWNMSaTaVtugwL/UeDQHThETUlqjJg4Azvuw3QOtqxdGefRR3xcZCxIUHEOuqoIMIFnpxYM NvAdVI2l94WOpeOhz0rxvYecY9b40VkuOfbyxZc3JWtytOTYwUfPCjcCPPNEg45T71DVXbyDjP69 v7rMe0hOzn9kFR+ojNetTmLPLjvJFbaToeDseilYjPk2AY8jWDUWZV3zYb5BELEI4Q0qt7EqegEL Ulh5gXXlyfGCYanQxOc7L4dmq8Kh5IitVDdKFCQRs1PX5H6Q0GBOuh01y8+Ny06XpJzqyKdOs0or h3gMt9Y0M/iqNcNSwAHsjGuBz9U59gOkEqtDk5VIVXF5X05YNUUeOgzBYxiz35lh4ZgeCfpLHu6l nffSwScE/WpdtWV2wg0wzQyxnojsnEggcQK63poJGlZZNdixVtM5Lgs/K4cvB/cGdWAQH50FBeS4 3dY4DgUHjYOuWnUGMgbA+h/MGKAAQQod5LEXI/UkED91ADHFgRT/RsB3JcSFBGgTA0c9sUOlQOfs VZdgBHgu4jhEJ2cBRXvlLxgp2qlklh40xSbvg/3FVlNPQ3mCadlO+pjHEboSHHtGAupQQVpjLtsj 8Q9NLle1e2kYEj4uBnYC+Gg8IWNU3cQIGV77oNIA7UPN7oqHw9jI0SQUjww9aVdgNL0U790Nddmg XAjolk2BkR7ApWga0ogEaB0LKNyvYsnZK8c+p0kQo/0OoJDsZ7Udc3ncXDH8PmAl5iMfKpAcApAk aEFzKKHe3sw0WyXAAnd5fu+pw1fVlsUjjVJllOwbzXTTysPFsB0hcYx9XkC7LfhQgkZPacd66LP7 wGJ8lj+y/h687tYJuBnMj8ce9QS1LAR7lhIvO9hfr1rWX4Z71bMeyXE1BBHB1pwciD3iY0nmEPUc CmYbp2dRiFrLWSmsjilfBGKdhEQeXg1iqk+wS3yFEVDfMe1F8uYOnypD14zoCEO8BFsASiTCw/AZ hOJpC8IwxGOjMcXmZDhsRAdHjqS7LbWvmjAgSJx9EydxOA4IMpV8zYC24PdRyH7xPZrtdWw29kWR x5hDx56FXkjQ+ZpjURC7nnXPpEtepJ7TeOrGIbuby6noSx9Pxa917D+Iv7+B/0uXkV3JGfj+9QAv JOCFrzlB21s0t6rCSjmMDF0zs8OAPlVa8fOIr3M5sLt24Xjwb7sKuTjExTnSC2YTVdj3i6bki0bs 0HVhlHzfGGIrFw4Q3wHEcGeB5rdheZg0+3PuQkp327cgHQJslczGkcnxAIm7iePdg6Ai9wktqI/0 1qxgCcW6sQAS7DyIlwVFR/s2Ix6ylgY5tiDk8gCdNsY8QYbR8dzkmM/Wsel9D1k7CTm6ihTI3vDP CSFe2YDstm5OiHykBV2rDIw64kc5HIxpnCHA6BNsv3YdKQkQ+Y0GSRKccID6BQ6kPnogJiCyf34i OC577wplr3lyQs0ntBFZWUgobvEcxSQ5H11IeT6imRJXnXsrCulw1Pfu6ybon5/3jdOtPQMMaD48 vRxfPF89lxUr5UzzBTeLwG3qWIHXHmzVtpDKphxOZQueJ+arbzjry17vDfunZ5JvQyXc6NzHodLf hC6M2Urq/dSB382yv98q1GEYxj/CgaZwdPAoZnBXIl1K7UT9OEpnIlEmWDIRPx58c0vcdgG1lfZF OhzBkgPWRNBUvAQLB4VXEwW7pDwbMMIMgy2JrSnNTuN+fvgEr1W/f8Yci8iWLhpNXmfquMRXi2ue rmU+qs6IAOtfQDug6ZUPanGyLr8XI+9LHTsa1vF1gpFg0cE4Iwi9aTfdQFgDr8kW/W9J91DqDod5 kFgJsmrC7H7TKKr8bH9UQmMOlnC7upo9Xq1ub7AaEHk9fP/69vtvXz8j+dzuYKWazG6zAAM+LXtI YWjbWRPqTI3Dx/ROosdKVO/e1x7HJ7Ur3z7/+PvLn+jHFk1HB0VeuwoLp/xrf35/202xsFXHE23p yBkUMGe3W9KCFnj3UY72aOZ3UyWS9f7vt0+8LvCmMcfi5CjTEhjw2EvtYoscm63AAVvHWHUw/A6g zxF4A8tUuiLW/xK+eoWuLs5ecU0TYQVYh53bCFw6GUWDzlBToYcfKuXUZLwbN60rCqfRUUlCLSoI qxZ//P3lN7AWsHjAssa05lhYXm+FjG9zHGbCAJZOw059hjqdBAbc9vq+piTWVLl8x0CwdZAIlI2E Jh6aIjCEy2dI3FUEEHhZRKmnLviF1H4DIGKbeuIp+iibTLdNLspitgaovcYCwHxetsnsSGa5YZZE FnWY1D62UF1R9anaKqQRGhN62ruhxCpXVuWYhoeoLqE/phqJWIQR0VM03+Ui2ZsRl+HaleIqANOg xCrTtliz1EeX2AKUViq1APDM6YVvewP8fERQpte2Y/L5viNmuAyeJqMtzULdnoUK2A2kJzFJzdID Jyr1YHQzg0EiPu67KOcRLG866hhAnpDF5LsSq1xdvL9kwwtq9nimgn9B+dROETBVsK27RNvJz2MB RsL0vEsSOMDSC2uTy3eTn7FEChg3treR+ma0Qr9nhrNxDf4la3/lY3JXoBkHxmwzWcsJpX1D9cPy TeweTwUeO+yYyOFj8kOXu7GZkCSui8mN4DCSsBEc+sYbIcUa0grTMLCasNDW3E05TYmr+0stysQc TKVqpS4USpXW17k0xQ7lBLhcOm4xlb8Kxwq9NbaC0JmHa9WXg9sFNlDacSpdk+VQjhc9M7Ze7CIx lU5WuXORIOJrzHes6uflCyQ9BcMY0sA3ZUKjUuuj87s1s7xYmbstogpCFSbx9IDjPkcWcBN5vvVh ELrGK0F4eaW8L1mzgdR6F8MUmqDsMEWe5zKjO6+KwIA13zzpxcZeWa5v3EE6gkWyIIj4hpLl7oWU fFdoBgYFZ4qrTs5x183F3RqyusnQs52exb6nq//KdwioPqKEEqPlKA8R9UQJuUMHYUk1z5f5gtiM gsauhqy8dbSlBJfqij0agqxmOMaHd8fDnPFWh15gNxGVEHvhDgE+cat9kgT7nLoJogA//pQFueOL ThCMt51iDINX4caKeH5WiwntFcwCaLaY15UnCc2yvDWR77BPucBoq5PgPCsYQWBacAcJPWt+gHNZ f9pdns4U3OjgQoiMRjc/bbEKSXkrq44Q4y2kDh+WEm8CwjuH21vUxhIc/OHITDq6+s8tL8BMtbFV Wt9e2cK582gfeDlnRQbKRO7xB0xo3jMYTR1uCAbxMLDfG2y183L1idnuxneJYShPcJ6qeTtfRHJD jQHHaip5R+nqMTuVGAEelV6EE86WXRrx1GnL08qCc15xzLvykDxudL44PPExb6sADTKXmxsID6Ko w5aUwiqiIMVnEoXU8v/w5Y9Ckrv33bzMxwJ4emWb2g8v9+1o+OUA4EEy1xOB3Q+tL6RQRN2QaghR b1gMxMdbwzFroyByGOQwaPgb7Y00v2+y5BWr+S43wssNdFlI4uOvJzcaLEQSfOIzSNhds0qhCZmw 8gMkivBSAs2YiOLKFDorTrAXHxtHqNLQGP/M7jbKpKGHDRqJxmGK1YeAYrSpAETTAK+qvb2UwYrw mdVgoVsjk0OdibE2jA5SGuwUN65VZ5JIjDWZ5ThFv+zR8YQGLoimxJG3ntLoUWsDEroWVSh8+6le pOtI7Bi5+0OFLs8VRp6lYYQ2oHn3isjNLaWCXfnIEntOiHp4/QkQPXFUOLcGDyzcIA19g5uwNnim AWMX78IO9+vhsl96qjbT2F3yM8uHsmz5DDSbr7dD2LtcBeRbZVRbUKcEjnlP7qofBI99vHo4QkLH mDmM74mvG6xDOM2VOJohDx8nD8cRRpo+8x5NDMBiDrMuCitqaBI/Gt+c7y0VyrbJt7H6xDcenqNJ y0X0oetMFzVO7nUoj4cL/trI5Pa3R3HCscABt1CgRib2C/dr43C5q1B5QXjxo8mdsyhxOKgxWAmm nK+kv2eRHwfoAgk7XtBRgr+L1kmRR9BRzD6OMDH9UMJA/WB/HhIkXkjO6FPf0ZEwU0sIzakjpFFC V8uVW8tnBsk6O1QH7EJ1kId2Sq8BX0ya8Zy6GrCjqiGfHWQPuue94d6WK4SEq8TYuhAU9QaQx6j8 l2uOylnXvuJA1r52OHLOhh5FmhzuhgoUmxo1jJrXSj7I3s1s02CBRfldq7xE7UTMh6nKu3Quabux OlZikym1CkrE03JTgrNVoIN5jm4Y9TjycxIQYsjkfaf2Wr2cnUHeM/yMGQjOA2jx9axhl/bER3h8 Gyk4Iz7FS8zl9ANQof/gDluiT+xhqdBfalZSYKnZBWTIqpY3j6K7AarHvXi8VgpcOeAQJT6XthpO VNLp+9u3vz7+hno5yE7Ye8nrKQNn1FsdzQJYF4MXXfZPP1YaYTPdq/5y3TlALHRdE6kBxWWL225F 20MVC/nx+9vnD+/+5+8//gB3aWuAOebj4Z43BbzC3FLLZaKhvqoiteUfq6ERnlx5uWEn/TyCQn0i DB/h/45VXQ9lPlpA3vWvPLrMAqomO5WHutKDsFeGxwUAGhcAalxbTniqeKFXp/ZetrwRYBPl8sVO fdACWSyPfEFaFnfVHBeQeW2DnVmVCyat6up01tPb8CFl9sHNtCjATSUkdayEQzW7Hv9aHBVa6iFQ ctUwXPS09g0xss0lvBCPfJCt4KqDD/n4a3WID7EOq+KGCy8l4CtfshNPP+1S5dBM8KDZoLcfXqZ+ bETT4lYTOHI+ZWZ2rwO2VOBI15etdD+rh2B+ITaqeCipmqUlcfaSLc+PtXRKwFL6QThrO8G/OlRX M2MgcrxSW1DjcHQRb21ShapEfRbEBXVJvSihet/MBt7/Oj7itvlZb9LSdp4tujc8RNlWl0b73AK+ 8pnk/aXEsJNRnLPYneesKFVDLKsIqZoZQIsd4bkMZUGDHV99opeSFGnlrMbJYcdoE+iDVyBGU22I ya5wnP3ZEiFZnIEszx1+UYFTYWsY6HZGG4e3CUUFA+8d3JAfmfExwOFoh+8vx+pQ8SHMkce27Ph4 XOmd/OV16IzmHRRH57hz7bqi6xxDwHWkfGuiRT8OVVG25vif6c5Y1BEyMBt9A/MkIuMTdNbcy6uu m6+B+YWNHa4xyuM5lXwqcIH9xMc+/LyfozfXYzGo18Wx9L3OHdpGUC4uXXTR+By9TN7kay2wYfnl OBnFeykwFXQYaA7N/TSNYWRND4t9KFeaisxlTla0QHGf44Kbkg8ebddgd1QAH3irmYzxS8qELuqp MLvXgrquI2HyH7qsYOfSYZhQ9L+md1j5A5TxmcjDjn1FqSe+rhgBW52KGWv2eXWILgalkvnbb//6 9PHPv36++693vLEst3DW7oRjfEEArnHk5kdRJONIHR49j4Rk9LSDNwE1jNDgdHToVAnKeOW76fe4 9zUg8AElJQSbkhc0UA3dgHAsOhI2uux6OpEwIFmoi1ez9ZqU74KCOD2evFiX8/zwHvByVB8Bgvw8 0SBK9GLpYCtEImUsXScFvTA1I4kL42UsSISrDijRqFMyUkAbE053kXTMiqMORD2X2xBhXwkDxJnF rS4LDFxPVi2EZXx3n+GlkBVwdo+dtRgc1UqEkuvlLB3LhrwGxb9bN0EceLiNSo2TYlHXPY2iCY95 OfHcz9Jy/WohpmVE5aPXiHhJjW1NN9KhiH0vQYtjyKe8bdXXKQ9GB2WfCw/RyuUZXP71y4+vn/gu 5eOPb5/e/jPvVuxBBfbH/FfWqVr+xaVpXh+I+f//z9m1NDeOI+m/opjTzKFjJepF70YfKBKSUOar CFCi6sJwu9RuR/tRYbtipv79IgGQAsAE5d1LlZX5EW8kEkAiM62znP0eTnF+VRzZ78GyF5hiKRY6 3HYLDgLdlBGmmJdcKTti+1idxrFVwS/vvboDh/EW6IVEsbNCJ8Nv8I1UC9VYLFeYwLsg1N7oF8KJ 05oH2oxHF2hwmtF9xoo6tx935sPgm3ux3x/0niCaZRc/L05UeUXyHccEkoBV0fFS7HpPDWkBiVxi pKg3Pj/O9493T7IMg20v4KOF6Ku9nUYUV7U1/Xpiazv+NdlSqv2ySHVFzMdrso4kvaW5W3MVldCT cryn4tfJTke7d7PLHRf1LqpsYBbFUZqeHKA8vHJSPJViP8tsoGjtXSFj7l3oF5poDbcmJGP+NiIp ESLezoF8uyVO3XYk29AqcYjbyvlyl0I06JrZuIPYpaYJtaEiC3n/Z0NvT8SGHaOUF6VNg1CRrMjN TYfM/FSpaWtRKQSjtzOhnLht9CXaVNjSADx+pPk+yt3i54yKGVEMBk4a+94DS67tiVCR8uKAOiIF ZrGjejbYH2k6/CixBaIHbLeWSKFVnW1SUkZJMGDtbhbTAfEoFN6UIeNK7vsy0duYDq4AKSjp7uA/ yeDJdnNWRA1hB0vhQLzYcodc5EIokdOgQHXKqRxUqI4FkJyjsXgFp6g4ubULVUY5vKUTY9qSiwa5 9Tgdl18THkHUUj9AyBBYg/HylBDpvYJR7sx/wTgx7ox0g2h1oPwA1rzGpglBBdV1aPKewG1VRjLA eqshvWt6A11LBCcR5ktR88ToEssDcaopilKmtUMU+3BnzoPxQMSk4Ozz7Ilj3cOEHsC/FCfIxAvi 1DsxhVRiZDiZ+V5IBV9la1gp25LN3TY+UpoV3DePGppnhZvRN1IVbtlN9ikRq6M7odQb1XZfb1C6 OtvQv5yFM9W+A7pXuMgi3gccsbUL625nT/F3GmpCODwjSomZZB+5yZMPvJpS6kFJ0QTdb42n83Bc gSpHyuhVsLWaNCD3lylJcczTIupuGa134W7y6gYoSyZsqxjMzRdCfglmr5x110PIN0q7+vn2551Q 6dmv94/z8yR6eHg7P0D87En2+v2n0GDR2rG62kbq3tUs9P8pMTctrRMRM0EMD8Oi2Me0hYsSoX6r CxxDoRT8wQ0qEIXikhUOsE5L2m5q6zxTYfPc9zQF+GKvJNo4Yu0+TqwU3YSc524WD0JG17moek6O 2J2yeh38+H5/fnq6ezm//nyXY/v1B9hLv7tTpXOeAbdKlOFnToDbisxoTiG8BQc56gXq4PRiWc0L j5m67AuOHY1rDhwXJ3XMU1Eiu+WjmhesFqtBnihvJL8HJlv11EVEvL5/wKZKR7efJO5GQHbaat1M p7JLnk16A6NFdZRVcklPNjvnvZiLgANAHdDZroLiXk6PhonvqS+GSQ8ZhM4cAA5iwzkO8QYhBAQS ScXgkkvbuNSqKDjI/pZzt+Ukn3MYuEzsfDClpIdtWYp+LjLtHDF6y94DYZ+AezKzYGI4jbRED4MX 6uMozyl0z1evjccxGX6gKUdqzqQxLOCudAxyPCnnVlMHs+m+1KPdSh0CcsxWDbC8JQDMfBWMYrZi AotMXIw5S8GhYDAbDqCiG1ZO0YrP9dQFNo+DxQy/6LCARRaV+FmpBUuiA81HRHJxpfOLT3R+17mF v3MLpHOtNFgazmYjDV+F0Wq1vFkPhR2kKt1qDKgyWg/YHpiCVV0GTOKnu/f34fGKFNTmI0m5pFWg xVR2BsfEGaBcut9XXlaErvrfE1ktXlTg9vv7+YdY4d8nry8TFjM6+ePnx2ST3sIi2LJk8nwnBIb6 9u7p/XXyx3nycj5/P3//H9EOZyul/fnpx+RPoWE8v76dJ48vf77apde4Qfsqsvdm18TAEZC12dME uYSVTuP0CUc82pqOUk3mVuw41DEKWijKksBzuWfCxN+Rf5nvUCxJqiluH+/CUM8OJuhLnZVsX3C8 VlEa1UmE84qcqOMblHsbVVnkaw19qiWEdhT719IODZ4i6s0q8DyflzpfNNSyYCrQ57uHx5cHy7rK lHVJHKK+PSUTjh7UILFlQZIzzMLMTpnXftGVyemboKacUks7xnM3V6BJ1XbkG+kvp5ME5dPdh5hE z5Pd08+zVq6Ge4v+0y6Omd2bkvUVGdeCgV12yPbZU7GNI86o6ahdGTFWxjLPR935scWVQapMw3yD OFy+egb4FKrUbUE/TqBRcFFZM7YOnDzgsMI8Qr7QhjcRBu9yCG4Pc8UdXhwPMREVauEmdTqpY1a3 85l5e2Dw+gNupMT7+WKGco57ysmeRK5sUNyE7qgyRSFyX+ZOdZ16KbQN7JbXxGhpkIVoMUhWkp0n +S1PKMTb9ssQhTtQhvokNyC0jL6iFaWVp8dIsiOuEPCjwO+KpxLhLECt323M0vQFZA4raZuCsmh5 xOl1jVYVhEAZ5RAtcIyPpnmbMl8Fb8FwpWXxlZbKYt7WwTzwNLe097iSQsHWntmqeLNlW0aVPkdA MxGoEI0dZYKaeiSJPDpkHofOBqpMgzkaRc/AFJyuwmXoadWvcVRfmVlf6yiFIxK0M1kZl2GzxHnR FpdhwBBNmCRksPXu5RipquhIKyEYULdNJvaUbYrBVlIz0XN6S2xsSPUFAsxiNTgePeO0KF1HniYz y2lOroxTSCE2j94NXgMnp2L1xwUqZftNkXtaltWzKT50v/LAMwbqMlmHW/AmP17kpsJluDQnfb6s g/bJFLogkoyaD7A1KVi5JYySmtf+YwBGDoz41PSU7ApuRyuVZHdj1K0c8Wkdm3FGFE96QXRUhkTe VrlllcsISUdmrbxIBlusNMJDLkhAm20hbBrjKsCgr08oE/8ddo6MTQc7aw4WQORAN5UbYtve9xfH qKqod4GDTeLwuEZGuYXt45Y2vPa8VlCKE5iSbI9ewEl87RNE5Jts38YZMXAEJf4PlrPG2U/tGY3h j/lyOne+0ZzFarpwWo7mt63oGFIN6gonZWqHS/PMPhPsB33516/3x/u7p0l690voyOioL/fWXWNe lJLcxIT6j4RUqHP8PSyP9ocCUGan90SlpW5O3Qnw+JmP5/2n6ntwYSpK7986pe4ViWZ++bZYr6fD b40rGU/LOa0QCQ0IE6n8VNovfySh5XHpcccq2TUcLvjZ6rVfiAseBdknc8bmgcfPgMIwLoo+8zmF UxhpGed6rOpHFf/14/xbrByi/Hg6/+f89l/J2fg1Yf9+/Lj/a3gRoxLP6kaM2TnMhOlyHpg3KP+f 1N1iRU8f57eXu48zXOOcUf+4shhJ2UYpzwYmzcOieFK0TrjAtIodKTdtPjpG54QdTr9tI1jUORfJ wEW6cX/dUfo3Euqq5fz8+vaLfTze/434X+0+qXOp14i1pM6M1TljZVW0m7SIrUOAjCna8F7HyOzq 7UafOafbDNy2mzl0vC/yECJv5yHqNaiDVUvblcKFoY+1PB4aXZgSR52MI0ewVTEuSOCXMnI1M7tQ W2nWgVmiXCDSQiMu0sLQSCR7U8Eyk8Nyvj9ChN58J3VM2bICgY1R+WFU4lcpillRglmtS6Z05DV1 yiGJwZDoBIaTZHmU7bnrUHUuNqJlhR6+wZQBCQFnEt0ER+j+h50S5XMNKgsNzusWbk0EcTmoXrmc 2rGzdI8RsRxlEfW2oCzkcvilpo8WDzAr00xZUrU7LzdBZdLsS2oYUV2T41mwYNMQOwRVZTANqCXl 4pvKGZ5JEE6HWWgPq2yBxwhSrcvnSzOimyR2vlFsas7cruFxBM/qBxnzNF7ezMbGnt/FTD/Ol/8Z pFvwkZpcXHY+u/NSHtj/8fT48vc/Z/+S60K120i+SOvny3dYkoYGI5N/Xixm/jWY2RtQ7DBLGlWY tJHOc90aqDCJvq/A/Zfb6DReh5vhIFZ+HLWNgb+dO78KfgQt7f2ZegT6dPf+1+ROrKP89U2s1LaI 61uXvz0+PGBijwt5uXN8zXV7kTgm4GhdPtoyFaxoNjsJQRvB+73uqHJQMNFNd3///DG51/bO7z/O 5/u/DEORkkS3teHlRhP0ppJa1s8975TzvShYzhn+VHwILNFwfTasLNK0QEqiuHVS8spfmk2OxsWz MAmJeWqcMAy4pLGOPgf8En9L5OBEHp+A3ZLTJxolHSmwtqT0pM/K26LGNHUbxpvStMNxqgI2+46Z GDacuq+JENKtkLdglcLiyjRLk6yB2Q9QzRaXqJTsovgEj7u3+CWuRPmf7apSwBGkn03WS4/Hasmm IcTOGwPMp6hk1czAfjynqGQ+810bSkAzxxxuqm+Xi6mh2yja2nYwooFTLOslHlJdpzMfpF3mSTBI pYE7DySVios+o0ZfAwECtK3CWTjkKJ3T9LsiiPuYF6LDPakzuM7ax3Y6mtg90frH28f99B92qv4x Atz8IHTmgcQUnMnji9j+gKWcoeLDF0JB2Kpx6ZZfcuDprTc3iRBl9QKS6iBPPAYlAvNGKNVgy9N9 pXxXmm4tNSPabJbfCLNd4PU8Unzz+GXrIU3o2TR3EL/xUodIGDySxEqgOG1Mcl6jTzNMoBlPzqCv 1sGQDtGbbxzfPheW6/YPQ9yEaKrSUy5Sk1GH7x2oYst4jnt01AjKUiEhkKwVww5L6fDG824EBNOb O74MmBug40SypivUq5oJma/mWINL3gq/Prcw4VgO2WLGQ7xDJac9JthS14/Sr/PgFvu6czY18m3n rw5pGiY2lzfoE8QOsc3mYozbcksmKiaW5d/0Ql+GMywv+AJ17d8BSDafBmskq4Oghzh9jkyeChwR 4tVd4kd5PT8R0zkciC/w9jwqvqALzS2VRV9g3SYlx9hMkoDlsNJAXyBZSfralxXultEUNrMV0pA3 66mnKxeik8eGHEiKBS6ChGBDOk3MoGAWoBMwi0s8eGOlQpa0UZ5oR+N9d8FG5uqqk7B5gA0gRddx Fwc9oErqG6c3cYDVoWpWjgNz2ypmtJxxVjB0JASOD7sLZ4k6sDEByzma5Cpcttsoo+nJM5ZWocc7 sQm5Gc98HdgBi0zW4nr66/ATmMX47AoWU2w97sIZDZOUYYbGpQe/na15hKnAF4EQ8hCZaUCfI7Md 6MsbdMFm2SpYeLwI9ovGwuNPtxuV5TI2fW10dBjI6Fo19Eo4bAUZOmMkU2mXi04r1yVtN/y1Dzp9 yPP68ltc1s6MGWp+LLsJVuNFHTPV7TF0p86HR1FbBsY/GRgoeoL39f0GnvOuI9qD1OLH2nk+zifl zdzn/7zr5mrhO7LrINpIbDwZLtSrK4MCoqFcQzTjiAx10t51ABd/TWfooGU887ir74eeJ5zPZQUa OOwaYNIyngdXMMPIO8j+yee9sC9M0UQeU88ewoO1z8NoD3FjISGQ9SoYT2WwocYa3+OrsRdCPJnN bqxW6T0CsPPL++vbtbmOufVxBRdN40IJEc1JIAqffBB1kTgXWn9t12dm8A54lEWBGLpBFMSW5DvL DSLQ+ugQ+yjPSWoXQkU46ylwG1aBPeousY2Yo4YCHJ+ekA5cmof41AQ2i2azZoTtnbXJcTxvJXyA j7JptgNjZ5ffcdULRsFcWbpzR28S7QfM/20RcaepOkbZRr5S3c69Bc7ibUu8zKxsyzEm9zLFDPKs LBDsz/dZvim3uvlRPsQI9vJSf7cot9RXuZnHjkrGevV+re4m/UNGCr5g2kblxpuIwsym/j6EaEfe z6W08vcxv233bIwbf/Vx4U1s6Xaz5km7jD0M5zbbmaZ4F4Yx+Y+yhQZRTzUdSb77QkWd7Vp7K0ek oUup14WtRWRymJB2EzE7wK6i41IbIoB7O7HLRtrke0HffHXhVM4yWxbCu6sLhcthL3VCtomqoXxI nV7oRXP89Ahhno2HzOyUxy1vdKOYos89xRwIc3AJ3JsDCDL4fL+8mu3aEdLfUtP+nh0l1bA3UR9b VRa/xSp/IANnuZrnuN3UVEbSLZSbWWsccPYkKplTQ/kFnAO34KUBv6UwP5eH1QTXbS1c7E4RffHi NFJfxNiwO4zqRhs1XmoHtouWpeU+WcCi1j22Nr0QKA62LGTQ3TGlttGm+BEYzaVtscGfhhm4Xf7s DbWnDrkqZA8vDRErGcpkBLR5FqG2l7pi7SZtC9uXicnB9woGYmDkYpcDybg24wKJH21Mtzah1Ko/ rb7ajCQjGcqIiHULBiRGqrhgqE05ZAE+D/tnNNaHOeGo/SZ8VdW2tQ8Qs63YCSMfHLZmReGXWP+z rJa2ZDOHkxeSdxl3kgqlzCz505OFtLFiF3QMtCsUU7/E9BRVaETEiEwNCqKO+W0oh4dN0exqx6o0 p7wSym0ep9HB89o+iqtcrG5o3iIj09F073igEtmI7uEQ5kxiwEKrqE76Qt+qfMfPaywHaT4KTOsb FU7dsZ+0mFLKa/cL+lK1t6R7vH97fX/982Oy//Xj/PbbYfLw8/z+gXnf2Ivurg6oULqWSlecXUVO G9P3iya0hFlXGkImkQQfAkLMioUDv8trwlU/OkZc/5eZups2hWMlcuy/ZS4HwlVHpeWvqmeU8KCR IF9wZVHTkfsIADbBDmfYE9meW/FyOwYeMbHjis3zMC0hWnnhkCEMQ0oSy+35IC+Qjs49pZsffArq A/K1XF23aOiFri7SHY3yWTOsqHvp7/CVmbGbr1CYSulDa4c66jIwrk4w3Nl2lK4mCIccSM4xhtCg CLxsMnzBZSRNo7xoLi/JzbCZ0rqp3Re8TNFnzhpgO5QsIDR4U8zW2Kl+563FHNSXWaSZ81b6NGuL UqTuOG5woLCX7lrteZhStBNzeSfjocT4oOmQCTcuqDviriRDom4OrOBiUM/bTc35eJn7Ql0pMm7N v4eQmXFqutPSFJE/EZqMOe2lGqXRSmw+vfbmydKODs40q/Of57fzC4TPPL8/PtjOYWiMqsuQHytD fSrX+a38XOrG/EjlvgzzpZ1mt9NFaD/Ru9Rn/FLbxt34rh0MGIs9YccsDC7nDARdWi9cHdbSy1os PNXcZLPQc8hjoOIkJuvp1baImQyfEHsis1yA8sg7JQ3zvNdwoCy6CtuRjOZXUZF073a1H0ZCjAE/ ZbNpEEZCyKQJxRdlIzWf3ZABUaa72MdFk0e4UmYOwawMwELQFzUHKh7DS0FPSjAMInoL7xT9ld7E WbCezdrk4OldjQnnnrmg+O3Kd7FgAlohoPAjhA51W+SeOD0aEJ92uccXXgfZV55AQJqfu+7KB/zx 7xl+OgdsI3Dgtd7dUzGvV/Fh7rkmcaG4UZODWt54Ws+CrTx3YA5q/RnU+iaMDz4DQAu68j1nEnsK wsFp1dU22xSMe3a/WQM2eLiJKnxKsybM8KOKnu3ZV3ds/6iR7K+DEyb68nB+ebyfsNf4HburEKq/ 2DaLcu9qeSq/wNvHhQVL3CGJi/P0sgvzdLML86wmJqyZTT0DwUaF83EUj+thX/YeCpE2Nc96QdmO 1XgZdMhAz8jO3x/v+PlvSM7sGVMK82Dteb3ooDy3axZqtfYE3HZQ66vTHVCeyzoL5b2vc1GfyDGc +VYBG+WJ0Omg1rjphIMKP4W6+UQdQyFv0TE1PiyMkaOPAJSK+vz0+iAG4g9trmPFRfsM3JBdjEeV +Deez+ZtJtSPa3Upqfgi3o8oBrJH/au+PpO/qjEpZ7v+y5vZ1ICPwIJPwRbzazCl9m7pwa9F6OdO Rbwtd753HFXiycjMBowPDL27I4m/iviWYZwSXnLLC9IxbjjKvaH2DlHmGOPPB42egqiwiTNyNKqh Kc2b9hDXnr3Ct1P+1V7cug3iUSjyuXxbaroC7qnyGgYtmYGBG61rGOiRqxiv0YAJ8t5O7xnJ2to1 SjHmNnv9+XaPhLgTLUQOHN5OmNZx8merm+aC3KRJj+yz1uoz3EN6IgZ3mu8IRNsljSE6q6QxzFHe pfoBW86zaiqmtR9CmxIubf0Aaay0GgEUx3SEWyVj7SB6eDHWCoK/pKK3/Qjlb8DPV6ZLIwDtPnQE Ad78wcMu5/EISpujjaWT3jII/LppoEQgIjyCQMdMHOuUho1VScygiox1ei6bDY6XovJ6ia8uUABS xgMpLkGiKjusM3nDSGN8MYh4BpdtFLd7UlyPR+KuBDrorNio47NBm/CNDGXYyLdVOda4YCYwMmD3 itnGGV7WHpDx2hchWt2wi90RXo8+Ce4ZQETX0R9iV/drgy+pe6HSi4GcVXjguJ7tKmA23/NKXpUM AtfKkKt8dOQxiIKE2xhEPBaDZTY6t/styFWEKEvhGV0dxMeXHhPAcSAM3tXC2c39b2VPttw2suuv uPJ0TtUsliw78q3KQ4ukJMbczEWW/cLS2JpENbGdku17kvP1F0A3yV7QdO5UTRIBYO+NBtBowBAh rVNJK0PEySLn7kTlfaYoDEFCAn1Jh8v94/Pr/vvx+Z5xOI8w6D8+AjP8KHuoYyF3hmFTNLBDfK/I cHdUtmlRjQHTLtne748vX5imFmml+UDQT2BtNqS/3BzqMcrrDe+YowijhHVexjAZTw83h+Nec+mT COjbv1T4+fzpJPh6+P5vfEV6f/gbRP7Q1fzxBCzSNgQBKs7cuKCdsgDqB2c3kN7Agcg2HhFeEaAe EInKFzlJUq22KCzH2ZLn1ZIo9RB1cf6Z9sqOSMOspx8Si/sVdzWv9Wg0VZbnnsNCEhVT8W5Bo91w W6tzj8sJft16ckP0+GpZOhO6OD7vHu6fH30jgd+BEOg1ohLefZQ4ZEzjypdRkLfFn8vjfv9yv/u2 P7l+PsbXTiNUIe+REu3hj3Q71gsyhbFtdL6UNjKQJn/88JWoZM3rdDUqi2YFH/uHKZxKj552f0EX k8PrXjZp8Xb4hvEf+j3LRXKJ64i2AYYlqMs8SewTQtX666WrkDyDsYHd7ehlmIbXXu4J/Fd4jjxE w3IvRbDktXgkwPhQ7U3pUeUUf7aeMTNoD0MzKNPUKafzuuBGgYbh+m33DZa2d++QyySeNG3F8zlJ UC14yYawSRLwA0hYODZ4byrCVqnHBU5hQ/zeT3ATZFXFsC01LmzvzS03ZsyBU/eKJI1VyWcZ6gne mT3ibGPmoDzo3XU3eVJTDO28KZxNYtOfjdLr1IZA05BK5PJjWhnbw7fDk8tU1JBy2D4UxC+d5EMz CvLNWZbRNdPqaFsHQ0KR6Mfr/fNTF/reCbYliVuxLaZz7ZGkAi8rcTmba29uFVyl5TSByq89q89m lxfOJ5g94ez83PmKbsbnM8N0MaDsOD02SVFn5xPPMzBFIvcDcBsQgCvPGwFJWdbzy49nvKqhSKr0 /Jx9x6bwXXBDI95Djwo615uxKogOg+ydeS6upOsbfzB5VN+MjSqwSSOVDohWCvyEE/3w8GXPyY5I HIjLSbBlnzMiuq7iyWxuONYBdCmu3FA6VNfz7vjgrshNGuNnH+f05rin9i1gvO3+qf1wQ0ogEE1d sVcZ6Ci818CKwHsdTfioTGL+Lo/QnByl4Ttjip9gZOkgPrzx40Ze4CF6HS82vM6I2Djlea/EbXlz v0JO+d2rsKB780cU4aUP/WqE4rq6mJ76Z2zkchPRV1GULgQXKwOxFCPuzF5HoBBM5iD6WSG7bRr7 +Z2BrSpzwSJEvZmwykE446lrUPlfcRIWBTUnUbrxeRgLXwpDJKBgdB6PJMJ7bDOI0/wS2iLnxSSi 86V0IqQyM/nsNESjxAkvwZgMQfhkOseYaX4C310BIb2XBD3WZ3AkAjQue7H+Z5iEjSPfk1GFXpc+ OyMSbGK8tvaY34jAeVIrFajy+uQexBTOyxmj8sdsbFJM/CdadNk3jDpygmHDB4grPFy0pyuvx5/8 lHdi4qfqpprq4y1/Fcg8p1jCuLEuaLw0XVPW88pfD3zcNllcrOOobEUcRh67HdlCkNgb8RJ5KRBg wlCPxooEWe17LyeTPFEdIC0t4sxTTJLn2Qpbg+/6ipjvlkGUetxr4Cz0Dl4arIs2skvvlGt74fUG yEIEV0qeUaBFLsoQGEcQT80IRn0WiDyoBXd7KZ2Dgl7jNtcr4kS99nhLKPy2mvjiPREBGV5mnugR ksIvUSiCEZnCoMBfgeAtVMoPynJrtdCwfjwvtAmN+Xhj304gAnlujlDQpFeFKLdjQzISs2DAS+/F VpRjI4PXaSPo8askSUOahcgrjw480BShj2EhyXvee4rqbjVNyPF+fes3N0par3uwQjsJdWyCETcG RWHHSDCwvTuUu23w1p8tV3kGdF5573kLdnS2e5+MZbO+Pane/nohhXpQFdQjLztkPQ5oP904wmy9 FE5/lXojxtO0iIxSE1QY/N7DQpFO3ib7alIUF6iwguAUjtVIrhujJSn7LtJwUQl6HwBMOkAj82h+ L4d4tAo5W++SfHyPBBkVHj9jHUZ/TTjJMpooj8wFZN0ZPVYhSK7tdJ6llD+Bk9Z1GqzNHhpEjlWQ psXZ+wR27QYFsQ+Z4+FXaEZKkq5Z3meBSFIKyhcx1mJ6cw1DS/3iXeSIrDPvhfTLE9jBoISGeRQE oFLyCe2HDQhKPFemDaHu1kdXBz72w9A/k7PJKRY6tsF60tn7pPF6dvpxfF+TLiC5uH+uSOSfXM7a YurReYAoFHO5rf0U6Rwzo46RiPTifIbiUOh5rYm+Vp0c5OV9wO+LuIj864FyRkw9qU3lfkVlX2nk bZR6ws26pFbnHDpk2VicvXeVe5rrhNYLmuYhon2Nr718OldqZm2Up9H+iK6XO3xT9Pj8dMAU4ZzW VKZtEPDCDeE8juLoLYLXX20Ylm3h8bSQ8SZ8WCw+TIML4PMOSTcaI53oD389ZzT8aAMzi4kCjeUh nVmZfmbdy8H2poxrT96gGUVDoAQ36spcPD0cnw8PxvBmYZnbl6jdDawi7x9zxYtsE8apZlnsErYW aaQFxs/w3bvmiwe/g0TEqQFZ1FqkDeOHrISSxzlAykC0aOJECxIQiq16h62FXBBb/VtsnvnTNYhK MKmEMS8DDxR5kNf8Upc0nUEsQq+MscI6wvHi0F/MXyVas6Jl47lwkyVkuO+zMPdWRMfl9dLb3P5E 8tfUk4x3BmWr98ZPHgj43JlvTW8feK/fm+UFHGYjY9d5VLxXUJVtMO/FqvDcoFFQvZFSyM/5vUpK X3/VyKFbcrYphRtSen1z8nrc3WPuWidBEAymoeXXqXy5jWFlPKLRQIN3yWyId6CQsdsfzc+qvCkD NlsAR7YGIaJeRCOhomotYXAHIbuwC6WgXE5IKUCsav7KuCeo3iMA8WmkhW1R8xUz0cEVc2UmTDu8 fGpmHbHMPotxmihpqWHpqeLcSFOBv9EW5MuzUiVxakRRQIBkDahb210s4d9Z5LH5B3mDJJy9M6+0 FLH4S8rpevpwggYy3sYQoca87JJpMQ6YI4CkET2oWwBqa9Te5LDp+mAYCrcBeT4UdQQiAsaMqfRj A0CxCmekWQHractGDADMWbusrFvNMyo4r+ItVM1Z0TqaKgqaUmbcGDCzVo8HQADgGe0yL6khDu1Q k4vSKtAbOPOKGp8XoRZtF3/ZoYyg1HRBg6sFJY1iGETAWDHrOzAQB9zDjp6APBfREUwPh9WX2W5F XZc8Su+8W7E2BOwS/Uw0TMu2XWe038pds90Yr7wRc93ktSee2TsrAfFmXliE5FmCAawou4XnI2tW ECQq6HTdLkWtp5oGGXFqdGVRq5l6tCH8YPZYmkXlem4NqE1aNhlonBlQtTLelVW71XoJlO13GwrT uWxBtpMxNYYTMU5k15iGLKfOYiQQBtIa/aJfauZ378xiR+PuZ8LIgdPnQH6AeRphPD9HgUowaxWH IRQxWymLTO5yFljqscwG+IzrE4DX/PHfUdxVdejrcJzjcOrl3uVZ5OwoTSFDoZwrzcPDcLfpo9ZB ZDK9Ni/0EY2TiB4AxZkR1GOJwYmC8pZy+PJ149IyWWQP9PLJgQJVkTqG5R6vMoFpUfVGVU54OBsQ S4DMMqU3QUgEUzdxG8NQW8KmlOD2RpSZFcNI/8zeeRJYl5ERXfB6mQKb48KTS8zUKiCoDY4hmjpf VjN+o0mkuRvofNPf8FkZd1XsKra8HOYhEbfWKTxAgXuEcQlbrIW/eFMOQyuSGwEC1RKzRfF5bLWv 4ixk09lqJFuYZ+q6Pk4aPo1gFPPCmG6ppe/uv+rBarOoHo4iTaOVYIwTqC8/eU7bgJ5OW/AS4Vvu hMUtZgzyAB0Rc1UHZGfC30Gj+zPchCS1OUIbiK+XaDE3OffnPIk9V8B38AW7Kppw2a2Irh183TI6 ZF79Ccfmn9EW/8xqvnVLOjs0CbWC76x1t1l6DxhAqNy8wNjDqBCr6NPs7OPA3FT5P01I902cY8ys Kqo/fXh7/Xv+oZ/5emk3gkD+tESELvlVjbgzh4F30vfYMEmT3sv+7eH55G9u+EjG0/tHgKvAiHBG MLwjqxMLiOMFSgHIFHlpoYJ1nIRllNlfxKGMlIfLvbErDvAZTFSRVtNjrqIy05vYmYg65SstzKVJ AF40sGhIrhjBA38Io4sZS7FuVlGdLNhllUbpMmyDEhRobRj7AIGreIVX0HL49LBF+NcgI3XGTHf6 +nriSgZKlUFGjVHIS4yj6ROlRejIYgpkLcIOuXToIzrAfXLF2i9yAKpIGi96MSKtLHz9iazT6/NS SdiPNkQdtqcOnGy2i2a51DXPAYuRWl15V+KrJk2Fx8u1L8G/2CSJJliCFOXELDJo74zcahJW4ns8 w/17EftHMihFyo5kdd2Iam3sNwWR4lx3eg3WCwMtj2revtQRhhH2FYSzbOUzRVmklG54pLEGXVtE JTASpgOWytrDzeHswZaArsH5K72hnrtxvEeA7/EzMt8vKJDDXcS0LEoXURhSYmVnFkqxSiMQPZVU gQWcaWfh1reFMIjY1tgyeWrtqnVhAa6z7cw56QB44V94pSqVuwizImvK3/1he4UPExe3oLt+mpxO Z6cuWYL2o24fGZdokgQmrkfzV3Yd3Yylc6jWwVCd3ez5bKoj7TpwDfxCJSMl2B3uBuqdnmlt5r7w d6KjdnrqEHyAzz44dQeu7dkkUE9T7e8sw/ogBWysE6nxr7qozP1IDA5cLfk1mekpJuDH0MfDy/N8 fn75++SDju6kyBakSMMwouM+nvH+aSYRG+XTIJmfa5nkLMzUbLaGOfd+89GHufDWczHx9nJ+wb29 sEjOvAXPRgrmve4soov3a7/01H55duHDnJ9623V59m6HL2eX/m595KJxIwkoVLjU2rlnTifT81M/ amJ2heK5m9Rd+RMePOXBRqpAHfFeN859H/pmrMN/9H3I+7YaXeMCqhsEM8+YWNvlKo/nbWlPIkF5 fwVEY6IJOPgEZ+zq8EEEsktgFywxWR01JXc11JOUuahjkZl9IMxtGSdJHLiYlYgSvsJVGUXc1UCH j6GtIgu5T+OsibnzxBgFtqF1U17F1dpENPVybnhZZDEube7SL29vrnW9ybiCkiEI9vdvx8PrTzfj hHJq6KvB36CIXmPEeClI8YdqVFYxaF4gbcEXJcizrG4iTZ1RyFXThmuQ9qNS+AT+znyNOQSqVR9c XpP8HPt2BzGE+K6YLKpv8lJzAyE2UYsFCO+w5hNhmr377wpRa3NDcZEpXHgG/WooZ0Fx24okyQNh GAMcohFUu4QCMES5eTEuanKOjMoUpn4dJQX//rVraZKLsIgNd14bB3OyzMuAW0c96a0w05v0iEos 0Z/XE+NAqyq4CvObrE3Y9AEDHewkO37Y2H1OJw4PC0Nomxsq+/Th2+7pAUOj/IZ/PDz/5+m3n7vH HfzaPXw/PP32svt7DwUeHn7DdNdfcEv89tf3vz/IXXK1Pz7tv5183R0f9k94ET7sFvUW//H5+PPk 8HR4Pey+Hf67Q6wWCywgGweaVduNKKErMWYGqeuo1JYVS3UHUpo5CgBEV+erNss9+dI0Glg7XUWs U4BBqOrSkeiLj+u3H2F9H3QUS2CNJoH2PJ8dmA7tH9f+YbXNn7rKtxixXIbU0/ILAE/BLkgj7vHn 99fnk/vn4/7k+Xjydf/t+/6oTQoRg4au384ooEhWQs+aZoCnLjwSIQt0SaurIC7WujnFQrifwKJY s0CXtMxWHIwldFWXruHelghf46+KwqUGoFsC6kUuKZx/wHHdchXcDMpuoPBxJPFpur7lbgQk+Wo5 mc7TJnGqyJqEB7qtLOhve7nJv5j5b+o1HHNmegbCeDJCdQshTvtsUMXbX98O97//s/95ck+r+ctx 9/3rT2cRl5Vw6g/XTkujIHDIoiB0VxcAmRKjoESw26Eq9YRRVQPUlJtoem7FovbRYAaT3g307fXr /un1cL973T+cRE80CMAGTv5zeP16Il5enu8PhAp3rztnVIIgZRq7Crijp/tkDYKNmJ4WeXJrJs3u d/UqxmTJzth2CPhHhTFFqmjq0FTRdbxhZmUtgJVuuklfUASvx+cH/Tqta9/CncFguXBhdcl0PRjb IVGwcJqWlDfM1suXnLNHv0mYJm5rh0ujoIfBYxx4tu4H3+3BgKQRHlt1GqnYbDkttJs5TAlUN6k7 MVVF0yXdFncvX32TAqK68/E6FQEzdlsYHn9TNrIkedd3+LJ/eXUrK4OzKbMICCzd+XgkD4X5Sji2 uN3SsWP3apGIq2i6YDomMSPrSxGo7e00pZ6chvGSKbjHqaaO8Hj2pPRu5X55YMok07TSnTEhp7b3 yHOnH2kMezlK8G8HV6bh5OLUaUW1FhMWCAu8is5cHgLs6fxCIZnvzifT0S8933BgpvyUgaFTxiJf MeN3U5xPRjYezVdLk9pmsVq7avUHh+9fzXi6HZutmIoA2rKXIRq+r8HuAEiRN8uYWTkdoksP6MWr BeSsaoH5jmLhRQwrz4OXZwmwr1+nnPpJUW/vEh26OHc1E1SvnSNgNjNCxz4LI/c0ANhZG4WR75ul lL2cTqnz2ovwjQZozkWUuQUqOJ0ufsbQUQ2dHDuJNOrpr5Cn76GddfHL9Fz9lnB6k7ObQcF9e6FD e4bbRLdnN+KWOd07Kr5jki88P34/7l9eTP26W0N0+eNKMXe506D5zGV58m7Tga3d0xYvqjpOVe6e Hp4fT7K3x7/2x5PV/ml/7NR/h01lVdwGRcm6vXWdKBerLr8hg1FiBYeRh59dJ+Gs4LcuhVPk5xiN BhE+G9TNU51wg4xbuUHruva3w1/HHej7x+e318MTIyol8UKxcGtkpB/IJiIKJSq4EzngtISfXhpX RjdqkSzCnfEe1dfhjupANHLomLX1Cg7bZE3/YVKZsoT+mpGOY7II76Wekq7BJ5PRVnuFJ6OoYZz8 RL7uWArXeKd6EcYuas066FS3KSYgjAOyKmO2xKGJGrJoFomiqZqFSbY9P71sg6is42Uc4M1y/w5j sHhfBdUcfVs3iMdSJA13qQukH7s8vs6TDomld4NQimZvjldoES4i6U5CHjfYmHgIEhjsj68YahCU 4RfKG4KZ73avb8f9yf3X/f0/h6cvw15M87BJ0A2CrO2fPtzDxy9/4hdA1v6z//nH9/3jB56aRlHZ G/oR4EjIhMDfUdcYNrxsKmX+L2PdauXiq08fPljYaFuXQp8W53uHQnp9zE4vLwy7dJ6Fory1m+Nv N7AWzBZa1d6WDxTEJfFf2IGhUklWRptcziGR8C6pvzCrXe2LOMOOkIv1slsWiZcfY87xi7bQUi93 kHYRZQEcM/p9CL7yEGVL7nO6V4fo3Nj7RoAygFmGtQnpgnaAnpAFeJ9RUrQDfeHrJEmUebDLOAvh jxKf1ca65JaXoc58YAjSqM2adGGkO5bXScaLky6cCKZgNlPDdygLTMwRncCDtNgG6xVdaJTR0qJA M/4SxW3yvSqSWO9OXwYwIJAIsryW91w69wzaIIADWGfgweTCpOgVZg0W101ryLSW3o8Kf5fb3Sgc 4cADo8Xt3OSuGsYnZRKJKG+8OfqIYuHJtwBYjzgaGFpA8FFfjgvXDBJongC29QIWbpineud7Ussl SYNK/zkTjl5xKPgkBs+5kweuJX3qnlVa2+9ytmTdv8qAsv5USM22T/egGppCYI2+R2zvEKwNHP0m G40No7AJhUsbC13eV0BRphysXsOudBAYNMoQshSc8h0kdyl3jCiSRfCZ+dBjYB8GoF3dxdq21hDb OxZsqBAdc2BudksZKz7JDS1bh+LVt76VDRzUqOMWgbaGRYUx6IFXgGgmylIYl8b0GFSPHCBB9AzQ 4GAID1NN6sXIC8YDpYwaJBHAjFf6FTfhEIFBRfAS2nblRpzAOBY1KG8Glx4YI14yE2GT9W4A2il6 E+d1sjAbGORrUkZgEeaJhTJvpBFURCVwf0I5+mO4/3v39u315P756fXw5e357eXkUd5R7o77HRyw /93/j6a1QCkoN7Sp9LE8dRDoVwsNQ6f1U42pdegKjYH0Lc/8dLqhKI4dGiWaN/kmjn25hiQiATkS 3WA/zfUBFBiiSj22MoaxR8Bq4HaTWgaMuFCtErk5BpBMJCIdFbSdlOQL8xd3PCV36IuhlVVeo1qh LYS0iA135TwOW0zmXWH2cW3tw9bpNu8mrJgtvYpqdBnPl6G+v/RvKMWLkR1kmaO9SD10etSh5tMl JJv/mDNDqVD61ifQxY/JxAJ9/DGZOaVifKPELtskESAlZWPVo6tzO/vBNOHUAk1Of0zmTvczpv0A nUx/TKcWuI7KycUPM9W2qoxrXrWytn3PSjCWS2tc1ANAJnFnqBv5vL5dJk21th6c9UTkcpMGFoZ8 JG6EHimmAu5mPb+HY8xyZxteniw+ixX/7syR0U2Pk053I+j34+Hp9Z+THXz58Lh/0f1QhlagBiAz R3EaqMQGQgXF7HqDHQSNKYhkyJo21i+0pZMyCLurBKT7pPcc+OiluG7iqP40G6ZFarxOCTON5dxm AjNK+N+DGRQo9rO+SrfpIkd1PipLINfmWH4G/4OCssgr+WBDTYJ3YHuj4+Hb/vfXw6PSvF6I9F7C j67z3LKEqumN66fp6Wyue26VcYEp3LChnrdAEUbZxZdWMCtsasZKPsTGt06pqGF9YkX4GF9/0E0t KHKKfmFNdBdYIjaddX65mzQoZOk83HcrNdz/9fblC/rwxE8vr8e3x/3TqzYgqVjJ5FcUOtgF9v5D UYbuHJ+Ax3BUMu4rX4KKCVuhi2IWRJrVQM687vrXQeiYusE/jdOvw6JzCRGkGCKEX5RmSbZTln70 ECu5WoULjjktKqFCEeBJbjWIsOPFBpXuQEoIgpE2EHcRcNVM/9Lc2X3EN4dR4khUysWrL8PgRbjp o20dZRX/qp0IYJFWeWa9h5d1ljksU+ET6PvRk8Q3W3uCdUiv7ddhk2oSsfzdms87q6RZqDLMIKiE oGfJvulQgwUnURKJK2aqJcEmbYsVuZjajeYw9sdxWTf6PpBgmViC/PLsA0yKJxW0C0Q2VFsSJYhb 2kG/noS7ngYEOiqY8p1yXpRY1x6sY6sbEOdWlYNFF1xYBLCFhm0AqoT10IfKGN8KS9r++jcEYU9f Z/UqLQF+nuTP319+O0me7/95+y454Xr39EV/KSwoXR+wXkODMsDIa5vo08REkpDZ1INCgX6/aExq ChWFAylgnekrlSzDksiMNTTWWOnlDdz84Q1ZuLlNOydLBm3vRGzPVRQVlnVUmhnRYWlgIv96+X54 QicmaNDj2+v+xx7+sX+9/+OPP/49DB6FxqCyVzjrTqSAG+C6DaXOGmw2g9D0/6jR7gmoD8tEsG7p gxiktQPPVnSPbbIK1F9QgKU1qbOxyuH/R3LSh90rKJHAQu/RSmvIZZKXtMTPgNmUjRPpw5pRT5Hy 0jFojKnsjAlBQ+/FSXDoF9l0MhRtfth9hwZXXQZ0JoN217LJpNxBRKWF7aSzpTV+DLK9ies1KmjV L5CpQBcosf4KuSidUhU6pThfUC0ajC0SfMlPQ4aUJDQ5heBdqK1Mglhfg2qiiraQgarKRmId5oof tCCqnxXbcwyb2+brIJ6cXcqAmYrPD2eTwLDg7NP24fiQgSGVuBIZ71XkKwpF42zyH/MLbsnJse32 VJulsbt6UD297VSPptItgPOLVonj7SLP66bgv9KbaZQWLlZcCnK7xnYb6m6JND9pGuf2ch986NFK izFPTrdzPuqtRhFxL5d7fEN/sYV7pMWiQc96Ueepa5lpshsM41K2cHozn/ZoW/7vOYA5j7qyWe9f XpGb4uERPP/v/rj7stc52BU2a2x1XQX5xjnW4bgGsFonuv3YpMZfSvgnkVWUKBRWFgHqRGVDb7mF bgCSSFACRBlJYxhoELNT+K9njbAH0XKDJwnuPuVi0XcuuQo9WZDp2E3jDBUzPjQnUYTxhr3IMAy8 pmULZzgOLmbMtQQVuY62SlY19ijyDvWBvzmKUFrceEWzo6uCgntUIy+iAV/nW70JBJf3jCPFBiJb +grtTSc6sGl0mwOBtpadm4AYjGgJvGsYRgKXeOMjpWYTYd4EEQh0XwuSXKUWBNqIQp0J7MReE0qn Jz3j0nwc6LYSChnso77RWMZlCkJGZPVTBZd5tAZWchNfWephGN2a218CUw8EzNzIt3idG9urEL4j qNlpevSD6ptbUUDPcmTU1Bu0T4Q5Z0DuL0Khgl6+6/R6CWKlozFuNZRAYlsaVxhRow3zgJgGvw+k hLeI0WSU23vFfqkk7XH/B10oFlMGCgIA --===============5097423008052333548==--