From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============1758527642342293009==" MIME-Version: 1.0 From: kbuild test robot To: kbuild-all@lists.01.org Subject: Re: [PATCH v3 4/6] powerpc/sysfs: Show idle_purr and idle_spurr for every CPU Date: Thu, 12 Mar 2020 06:30:00 +0800 Message-ID: <202003120633.5qH6NDR4%lkp@intel.com> In-Reply-To: <1583919461-27405-5-git-send-email-ego@linux.vnet.ibm.com> List-Id: --===============1758527642342293009== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Hi "Gautham, Thank you for the patch! Yet something to improve: [auto build test ERROR on powerpc/next] [also build test ERROR on linus/master v5.6-rc5 next-20200311] [if your patch is applied to the wrong git tree, please drop us a note to h= elp improve the system. BTW, we also suggest to use '--base' option to specify = the base tree in git format-patch, please see https://stackoverflow.com/a/37406= 982] url: https://github.com/0day-ci/linux/commits/Gautham-R-Shenoy/Track-and= -expose-idle-PURR-and-SPURR-ticks/20200312-041724 base: https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git n= ext config: powerpc-fsp2_defconfig (attached as .config) compiler: powerpc-linux-gcc (GCC) 9.2.0 reproduce: wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/= make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree GCC_VERSION=3D9.2.0 make.cross ARCH=3Dpowerpc = If you fix the issue, kindly add following tag Reported-by: kbuild test robot All error/warnings (new ones prefixed by >>): In file included from include/linux/byteorder/big_endian.h:5, from arch/powerpc/include/uapi/asm/byteorder.h:14, from include/asm-generic/bitops/le.h:6, from arch/powerpc/include/asm/bitops.h:250, from include/linux/bitops.h:29, from include/linux/kernel.h:12, from include/linux/list.h:9, from include/linux/rculist.h:10, from include/linux/pid.h:5, from include/linux/sched.h:14, from include/linux/ratelimit.h:6, from include/linux/dev_printk.h:16, from include/linux/device.h:15, from arch/powerpc/kernel/sysfs.c:2: arch/powerpc/include/asm/idle.h: In function 'update_idle_purr_accountin= g': >> arch/powerpc/include/asm/idle.h:25:28: error: implicit declaration of fu= nction 'get_lppaca'; did you mean 'get_page'? [-Werror=3Dimplicit-function-= declaration] 25 | wait_cycles =3D be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~~~~~~~~~ include/uapi/linux/byteorder/big_endian.h:38:51: note: in definition of = macro '__be64_to_cpu' 38 | #define __be64_to_cpu(x) ((__force __u64)(__be64)(x)) | ^ arch/powerpc/include/asm/idle.h:25:16: note: in expansion of macro 'be64= _to_cpu' 25 | wait_cycles =3D be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~~~~~~~~~~ arch/powerpc/include/asm/idle.h:25:40: error: invalid type argument of '= ->' (have 'int') 25 | wait_cycles =3D be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~ include/uapi/linux/byteorder/big_endian.h:38:51: note: in definition of = macro '__be64_to_cpu' 38 | #define __be64_to_cpu(x) ((__force __u64)(__be64)(x)) | ^ arch/powerpc/include/asm/idle.h:25:16: note: in expansion of macro 'be64= _to_cpu' 25 | wait_cycles =3D be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~~~~~~~~~~ In file included from arch/powerpc/kernel/sysfs.c:22: arch/powerpc/include/asm/idle.h:27:14: error: invalid type argument of '= ->' (have 'int') 27 | get_lppaca()->wait_state_cycles =3D cpu_to_be64(wait_cycles); | ^~ arch/powerpc/include/asm/idle.h: In function 'pseries_idle_prolog': arch/powerpc/include/asm/idle.h:47:14: error: invalid type argument of '= ->' (have 'int') 47 | get_lppaca()->idle =3D 1; | ^~ arch/powerpc/include/asm/idle.h: In function 'pseries_idle_epilog': arch/powerpc/include/asm/idle.h:54:14: error: invalid type argument of '= ->' (have 'int') 54 | get_lppaca()->idle =3D 0; | ^~ In file included from include/linux/dev_printk.h:14, from include/linux/device.h:15, from arch/powerpc/kernel/sysfs.c:2: arch/powerpc/include/asm/idle.h: In function 'read_this_idle_purr': arch/powerpc/include/asm/idle.h:66:27: error: invalid type argument of '= ->' (have 'int') 66 | if (unlikely(get_lppaca()->idle =3D=3D 1)) { | ^~ include/linux/compiler.h:78:42: note: in definition of macro 'unlikely' 78 | # define unlikely(x) __builtin_expect(!!(x), 0) | ^ In file included from include/linux/byteorder/big_endian.h:5, from arch/powerpc/include/uapi/asm/byteorder.h:14, from include/asm-generic/bitops/le.h:6, from arch/powerpc/include/asm/bitops.h:250, from include/linux/bitops.h:29, from include/linux/kernel.h:12, from include/linux/list.h:9, from include/linux/rculist.h:10, from include/linux/pid.h:5, from include/linux/sched.h:14, from include/linux/ratelimit.h:6, from include/linux/dev_printk.h:16, from include/linux/device.h:15, from arch/powerpc/kernel/sysfs.c:2: arch/powerpc/include/asm/idle.h:71:33: error: invalid type argument of '= ->' (have 'int') 71 | return be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~ include/uapi/linux/byteorder/big_endian.h:38:51: note: in definition of = macro '__be64_to_cpu' 38 | #define __be64_to_cpu(x) ((__force __u64)(__be64)(x)) | ^ arch/powerpc/include/asm/idle.h:71:9: note: in expansion of macro 'be64_= to_cpu' 71 | return be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~~~~~~~~~~ In file included from arch/powerpc/kernel/sysfs.c:22: arch/powerpc/include/asm/idle.h: In function 'read_this_idle_spurr': arch/powerpc/include/asm/idle.h:82:18: error: invalid type argument of '= ->' (have 'int') 82 | if (get_lppaca()->idle =3D=3D 1) { | ^~ In file included from arch/powerpc/kernel/sysfs.c:2: At top level: >> include/linux/device.h:126:26: error: 'dev_attr_idle_spurr' defined but = not used [-Werror=3Dunused-variable] 126 | struct device_attribute dev_attr_##_name =3D __ATTR(_name, _mod= e, _show, _store) | ^~~~~~~~~ >> arch/powerpc/kernel/sysfs.c:798:8: note: in expansion of macro 'DEVICE_A= TTR' 798 | static DEVICE_ATTR(idle_spurr, 0400, idle_spurr_show, NULL); | ^~~~~~~~~~~ >> include/linux/device.h:126:26: error: 'dev_attr_idle_purr' defined but n= ot used [-Werror=3Dunused-variable] 126 | struct device_attribute dev_attr_##_name =3D __ATTR(_name, _mod= e, _show, _store) | ^~~~~~~~~ arch/powerpc/kernel/sysfs.c:780:8: note: in expansion of macro 'DEVICE_A= TTR' 780 | static DEVICE_ATTR(idle_purr, 0400, idle_purr_show, NULL); | ^~~~~~~~~~~ cc1: all warnings being treated as errors -- In file included from include/linux/byteorder/big_endian.h:5, from arch/powerpc/include/uapi/asm/byteorder.h:14, from include/asm-generic/bitops/le.h:6, from arch/powerpc/include/asm/bitops.h:250, from include/linux/bitops.h:29, from include/linux/kernel.h:12, from include/linux/list.h:9, from include/linux/rculist.h:10, from include/linux/pid.h:5, from include/linux/sched.h:14, from include/linux/ratelimit.h:6, from include/linux/dev_printk.h:16, from include/linux/device.h:15, from arch/powerpc//kernel/sysfs.c:2: arch/powerpc/include/asm/idle.h: In function 'update_idle_purr_accountin= g': >> arch/powerpc/include/asm/idle.h:25:28: error: implicit declaration of fu= nction 'get_lppaca'; did you mean 'get_page'? [-Werror=3Dimplicit-function-= declaration] 25 | wait_cycles =3D be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~~~~~~~~~ include/uapi/linux/byteorder/big_endian.h:38:51: note: in definition of = macro '__be64_to_cpu' 38 | #define __be64_to_cpu(x) ((__force __u64)(__be64)(x)) | ^ arch/powerpc/include/asm/idle.h:25:16: note: in expansion of macro 'be64= _to_cpu' 25 | wait_cycles =3D be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~~~~~~~~~~ arch/powerpc/include/asm/idle.h:25:40: error: invalid type argument of '= ->' (have 'int') 25 | wait_cycles =3D be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~ include/uapi/linux/byteorder/big_endian.h:38:51: note: in definition of = macro '__be64_to_cpu' 38 | #define __be64_to_cpu(x) ((__force __u64)(__be64)(x)) | ^ arch/powerpc/include/asm/idle.h:25:16: note: in expansion of macro 'be64= _to_cpu' 25 | wait_cycles =3D be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~~~~~~~~~~ In file included from arch/powerpc//kernel/sysfs.c:22: arch/powerpc/include/asm/idle.h:27:14: error: invalid type argument of '= ->' (have 'int') 27 | get_lppaca()->wait_state_cycles =3D cpu_to_be64(wait_cycles); | ^~ arch/powerpc/include/asm/idle.h: In function 'pseries_idle_prolog': arch/powerpc/include/asm/idle.h:47:14: error: invalid type argument of '= ->' (have 'int') 47 | get_lppaca()->idle =3D 1; | ^~ arch/powerpc/include/asm/idle.h: In function 'pseries_idle_epilog': arch/powerpc/include/asm/idle.h:54:14: error: invalid type argument of '= ->' (have 'int') 54 | get_lppaca()->idle =3D 0; | ^~ In file included from include/linux/dev_printk.h:14, from include/linux/device.h:15, from arch/powerpc//kernel/sysfs.c:2: arch/powerpc/include/asm/idle.h: In function 'read_this_idle_purr': arch/powerpc/include/asm/idle.h:66:27: error: invalid type argument of '= ->' (have 'int') 66 | if (unlikely(get_lppaca()->idle =3D=3D 1)) { | ^~ include/linux/compiler.h:78:42: note: in definition of macro 'unlikely' 78 | # define unlikely(x) __builtin_expect(!!(x), 0) | ^ In file included from include/linux/byteorder/big_endian.h:5, from arch/powerpc/include/uapi/asm/byteorder.h:14, from include/asm-generic/bitops/le.h:6, from arch/powerpc/include/asm/bitops.h:250, from include/linux/bitops.h:29, from include/linux/kernel.h:12, from include/linux/list.h:9, from include/linux/rculist.h:10, from include/linux/pid.h:5, from include/linux/sched.h:14, from include/linux/ratelimit.h:6, from include/linux/dev_printk.h:16, from include/linux/device.h:15, from arch/powerpc//kernel/sysfs.c:2: arch/powerpc/include/asm/idle.h:71:33: error: invalid type argument of '= ->' (have 'int') 71 | return be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~ include/uapi/linux/byteorder/big_endian.h:38:51: note: in definition of = macro '__be64_to_cpu' 38 | #define __be64_to_cpu(x) ((__force __u64)(__be64)(x)) | ^ arch/powerpc/include/asm/idle.h:71:9: note: in expansion of macro 'be64_= to_cpu' 71 | return be64_to_cpu(get_lppaca()->wait_state_cycles); | ^~~~~~~~~~~ In file included from arch/powerpc//kernel/sysfs.c:22: arch/powerpc/include/asm/idle.h: In function 'read_this_idle_spurr': arch/powerpc/include/asm/idle.h:82:18: error: invalid type argument of '= ->' (have 'int') 82 | if (get_lppaca()->idle =3D=3D 1) { | ^~ In file included from arch/powerpc//kernel/sysfs.c:2: At top level: >> include/linux/device.h:126:26: error: 'dev_attr_idle_spurr' defined but = not used [-Werror=3Dunused-variable] 126 | struct device_attribute dev_attr_##_name =3D __ATTR(_name, _mod= e, _show, _store) | ^~~~~~~~~ arch/powerpc//kernel/sysfs.c:798:8: note: in expansion of macro 'DEVICE_= ATTR' 798 | static DEVICE_ATTR(idle_spurr, 0400, idle_spurr_show, NULL); | ^~~~~~~~~~~ >> include/linux/device.h:126:26: error: 'dev_attr_idle_purr' defined but n= ot used [-Werror=3Dunused-variable] 126 | struct device_attribute dev_attr_##_name =3D __ATTR(_name, _mod= e, _show, _store) | ^~~~~~~~~ arch/powerpc//kernel/sysfs.c:780:8: note: in expansion of macro 'DEVICE_= ATTR' 780 | static DEVICE_ATTR(idle_purr, 0400, idle_purr_show, NULL); | ^~~~~~~~~~~ cc1: all warnings being treated as errors vim +25 arch/powerpc/include/asm/idle.h 03d989e21479c7 Gautham R. Shenoy 2020-03-11 19 = 2452f5988544ea Gautham R. Shenoy 2020-03-11 20 static inline void update_= idle_purr_accounting(void) 2452f5988544ea Gautham R. Shenoy 2020-03-11 21 { 2452f5988544ea Gautham R. Shenoy 2020-03-11 22 u64 wait_cycles; 2452f5988544ea Gautham R. Shenoy 2020-03-11 23 u64 in_purr =3D *this_cpu= _ptr(&idle_entry_purr_snap); 2452f5988544ea Gautham R. Shenoy 2020-03-11 24 = 2452f5988544ea Gautham R. Shenoy 2020-03-11 @25 wait_cycles =3D be64_to_c= pu(get_lppaca()->wait_state_cycles); 2452f5988544ea Gautham R. Shenoy 2020-03-11 26 wait_cycles +=3D mfspr(SP= RN_PURR) - in_purr; 2452f5988544ea Gautham R. Shenoy 2020-03-11 27 get_lppaca()->wait_state_= cycles =3D cpu_to_be64(wait_cycles); 2452f5988544ea Gautham R. Shenoy 2020-03-11 28 } 2452f5988544ea Gautham R. Shenoy 2020-03-11 29 = :::::: The code at line 25 was first introduced by commit :::::: 2452f5988544eaae0c9f73103c2f7083ef4e2fa7 powerpc/idle: Add accessor = function to always read latest idle PURR :::::: TO: Gautham R. Shenoy :::::: CC: 0day robot --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============1758527642342293009== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICNhhaV4AAy5jb25maWcAnFxbc+M2sn7fX8GaVG0ltTuJ7zNzTvkBBEEJEUlwCFK25wWlyJrE FVv2SnLi+fenG7wBZFOzdbY2yQjduKO7v75wfvjHDwF7PTw/rQ4P69Xj47fg9812s1sdNvfB14fH zf8GkQoyVQYikuXPwJw8bF/ffnl5/nuze1kHlz9f/Xzyfrc+Cxab3XbzGPDn7deH319hgIfn7T9+ +Af8/wdofHqBsXb/EzT93j/iKO9/X6+DH2ec/xR8+vns5xPg5SqL5cxwbqQ2QLn+1jbBD7MUhZYq u/50cnZy0vEmLJt1pBNniDnThunUzFSp+oEcgswSmYkR6YYVmUnZXShMlclMlpIl8ouIekZZfDY3 qlj0LWElk6iUqTAlCxNhtCrKnlrOC8EimC9W8C9g0djVns3MHvdjsN8cXl/6EwgLtRCZUZnRae5M DKsxIlsaVsxMIlNZXp+f4Qk3G1BpLmH2UugyeNgH2+cDDtz2ThRnSXtS795RzYZV7mHZbRnNktLh n7OlMAtRZCIxsy/SWZ5LSb6kjKbcfpnq4czsj9/t0Bnc3eCQfvvlGBUmIk4nEjGrktLMlS4zlorr dz9un7ebn971/fUNy4me+k4vZe481qYB/8vLxF1/rrS8NennSlSCXCIvlNYmFakq7gwrS8bnJF+l RSJDksQqkFVimfasWcHnNQcujiVJ+xDhTQf719/23/aHzVP/EGciE4Xk9snrubpxJHJAMYlYisQX kkilTGZ+W6wKLqJGJmQ2c44tZ4UWyGSPbLO9D56/DhY2nN3K3LLfy4DM4XEvYF1ZqQliqrSp8oiV oj2F8uFps9tTB1FKvgB5FLBVR7IzZeZfUO5Slbn3DI05zKEiyYmbqHvJKBGDkRzBkLO5KYS2Gyy0 eyCjNbZ98kKINC9hKKvV+kfXtC9VUmUlK+7IZ9NwubRae+fVL+Vq/2dwgHmDFaxhf1gd9sFqvX5+ 3R4etr8PDgk6GMa5grnq6+2mWMqiHJBNxkq5pGUBX4u9356d5At1BKtXXIDkAGtJMqHS1SUrNb15 Lf325qz/i83bQyp4FWjq0WR3BmjuIcBPI27hdVAyqmtmt7tu+zdL8qfqJGtR/8GRtUV3sYq7C5CL OUgePCrSRKDSj0GgZVxen171T0tm5QIsQSyGPOf1Cej1H5v7V7DywdfN6vC62+xtc7NogurovFmh qpy+GNTEoBfgbml1ORd8kStYHApLqQr6JWngi6xts1PRPHc61mAFQA44aISIZCpEwu6IcwuTBXRd WgNdRL7BLlgKA2tVgd5zzGgRDawnNITQcOY9lmja1gFtws7ZXmqadEHtQCmQzcEbAkSkchBBgD+o t1GnwX9SlnFPwQzZNPxhygABnogQDHEVCQOqlxmBQAbVgK9CjzLSVrg2tt5vEDUucuxi4CK4o3DD PO5/1ALZ/04BCUiwsYUz3kyUKSgRMzI29cvpm7stxHOWgZInFlvjgE63e1I2/G2yVLqQzLkfkcRw PoW7KwYWNK7c5cVVKW4HP03uDCly5W1HzjKWxJGrh2CdboO1qG6DngNk6X8y6UA5qUxVeIaeRUsJ y2xOzDkAGCRkRSHdc18gy12qxy3Gu4Wu1R4BCioaFu++qTvCS7bAL46Ie7JwCZ2CfmUGRwgZXzgr Atjy2R00EnBNtpUYE0YSUeT6E1YwULZMB1V6y8RPTy5GRrlxt/LN7uvz7mm1XW8C8ddmC5aJgcLl aJsAI/SGaDh4o5b/y2HaUZZpPYax5th7ujqpwnrbjvYAd4SV4Mss3A3phIWU+MIAPpui2VgIl1HM RAvYh2ObGIBMIjVYBJA+ldLK3mOcsyICTEirfD2v4hicqpzBnHD14C2BnaFkulCxTLyHblWONU/e sftOX9c/5+ee8oeGq/HV57vn9Wa/f94BAnx5ed4dapTWdUFNvjjX5urtjYY6DsvJ6STLx8sj/T9O 0C5O3oiDubh4c7clwHsnuDpUnjsICCeL3YaLtzdHpGEbjoTnpTBXF6F09Hg+v9OjNhgzTSuAySDY 86l2M7gLIFg9T7+RNCfh4/iuOlGKtLIztLICqDjEw8kiyRyP6fzMWzusz1GjqJzSlOWmyAA7gEtn UnZ7ffrhGAO4Y6enNEMrr98byOPzxssKBO36+vL0rBNYcGEXVg6MrvLcj4vYZugRJ2ymx3R03gCQ jQntW5nfCPCT/Lt1rBQrkruxUWVZ4zeqCuDrxy5kVINElcoSNAPATmMF1zVF+EKqKJyZ06vLyxPn ItCftoc0XqKnEdsYQyVT0CaDm5zLUBQ1vEF8oGWYDFl0pXN4IQQZlxbxonGnRu2jceyB6sZQoWqz mm2KrQLdFgrtDwtWvDV0YjZJk4zr6wuaFiHtbIK2PEJjHJW7e4L5rA682SAEdqx15ePqgJbNUZXO gBcfPL0UshQUCu1hJhV6FxntXYhQZbRPrVl6cXEiJhwO8blSksb2JZMawCMdxWKAQyWN7hk4HKIg aTesoNeBVz3lXrHsTmUJ2FGaPksYn5qvENGNUrRNBamd6HWntAAJnAgIaH0xYXl4BeCsrPiCsCyx 9p0qtsAbo29ackWf+i2a9lsbwhC3cKm9gCtAD1OWEkwf4Ok0T+gNIcfbm5nlkopIXny4inPnjde/ jSiKiysvKAq4bFYNYr79WecsB8+NFQzXTkyT5tKLD+Bvk+qZd0FtKCiId5v/vG6262/Bfr16rKM/ /S2AFQNU9Zk0hnTvdmB5/7gJ7ncPf212Xd4AOmDzcAYZDY/TmaHu4LS4AzsvV2SmKDlttYdaw4Xc zy+Y2ti7a8JYHfgH5OnPv5hTEu4A4czaEJf13GcdjEIPcw3D+CZsXmAczrtSVs7B76iSKefZqnuR WRXaBJ/nqswT13jRPAX8yTU4C3ErHDsCfhgCZuYZK14gwIoqN7VhRwccUMLQzSyOC5kkYsaS1iKb JQOF3Cd7dBmFMqtKmQzM0MXC2jbfoYL206uGMIlwry4IDoduvYEmAtZZqSbP0wXGWgkEjVGOmG1I Y9hog+MIvswXsDYK3JLCgVc8jTBjhbjXcXyb1ut3Dy/Xz9tg9/e7IX9cqNQGeBKFgT8vdNOwwAoB WNCqtR0F10b5s7eA48BigU8Gbs47N19SwxX6kFNiKC04gkvCRW3Fzspd+Lp35LD3DIz2I52xTkwS 0kLujtHBV5VhiBjUX50parMC7P4v9I3vuyxdb0qiJQbDIhv/gt4jlRltvq5eH20DRov3ASiWYNWO t3bTpe1ygtVuE7zuN/f93hJ1g2KBcbXrkzfQEvZ/PaKFt6jiWIsSqOsBtUl6wcYKiowekuSsZzgZ MJQ25lXP3HXujnFwNH6sv8LE6UjleHnP1W79x8Nhs8aY8Pv7zQsMu9kexrdbqww/1mVVzaBN1V64 02KDK05zbzZrUEu+zl9BN5mEhSIhXukIDdspRBxLAEMZoPsM9j3LMOLMMSkxUHKVFjaxWsrMhJhS HAwkYUPoasEs5YC0IGdeFKKkCXUrppHjQfTT0uMq49bdAEihwHXLfhW8CcO6bF78sc8i2hHn4IKP nR7wh62VbjTi0NFhGpVJKeO7NizuM1inF1+0GR4Apu1TFTXZ6uF+0Q8xAFZrp7M5fcPy4fKbcJ3b xJPFoMWGzHzPpm/HqGEzi2/G+uPpn5DnvpsZ2GLoXLsrGIIiyZgl+g5LbYJQMIfHW99Zna3haX7L 50MzfiPYAm2zwFgp458rWQyHuWHwlKU1dZiVbesGiJ02WtuAgHnu8lS77WkPD584PDnlEJsiDJ/c pjQ7e0/3HXTSZaHcaJydl8hBDuVvnHYccMALbHaeCy5j6eAdIFUJiBwKOUbnMQ5NjC9u8YFndfIc V02IiO1uQ5jeHffn7kV2joWFHAhRP3aV37VgpUyGD9z2z5YFS0FtOkSeKMQesFhwJSOHoLBGRM4a az9qZwOd0oSPaiHHgx4svTalYJEay1Xc3BKnA5creenz9MBjSDwW2rcxwlKZyBas1NaJq+X731Zg g4M/a/zxsnv++vDoJbu7AZC7if4K06YX2lDvkZE6EwwwG2wBFp5wfv3u93/9y6+1wdqnmsctYvAa e7+mazb8jtuzTvCx0fEJhxuQN9ou+KeA1/E9bnyXcMjVMNk+CHB/x7p3TkJpUsxKuQbMZnF0isd5 MhAuz7OxTQ1uRnhLObg1T5UhfbJzTSY37licKTqOowvelVElyVFOSVcyNGS8tQJM1zEejNfdmFRq XVdRNGlyI1MbsqOLhjJQSyCTd2moEpoFBCdt+RaYTps8T5AZsExw5mpROQYwxKCt+xPAI9cSFOFn DFF4AbcmaR7qibqOnj5V69Tn3UsxK6aeecuFPhV9w8jR+jnW3tHRKWS7Cek4i92p9QRYMoK7+Wp3 eLAgv/z2svGiBzBdKS0Ka50J6sh1pHTP6sS4Y+k190GMwYx1kZfqKzEccJ1+BtBZxw4w5e5XRTrE xV3oe48tIYzpkI8/X+fN27pLMJ6gSFDqAETVNV8+3Zqnmn6MRva9gbcgpjq7RL+3H/VmJZhebor0 prUL4m2zfj2sfnvc2OrYwGZND85JhjKL0xJNt3NFSez7KPjLwsYuH4CmvinKcUSnHkvzQua+3NQE kH2quAxHbzBpdw9T67abSjdPz7tvQbrarn7fPJHeVxOX6deGDQDKIhsJMunIh8F0uT3emmdEj5ku zawaxn8WQuRdXwfX5QlAhby0IwJ2cxIKFkwMAEYqZwXzm6yNZ1EEuHuYDrSAEMx/WHmGZaGpAEV7 YRZepTKzY15fnHzqKqUyAfKQY5kAYMxF6sVaAG5nnIHETMRZ6FzAl1wp2pp8CStanX2xhlNRz6N1 0erkWONrejIdtcludPAWU0V3sEXc4XRJHdyuCUXG5ykrqKh8j79KUQNp5iGn6WfZH3XZCma2Ofz9 vPsTUNX48cL7WAhPgOoWE0k2IxZWZdIBnPgLZNC7SNs27N2b0AnTehsXqXUc6UI3gXiVtl+3UY6h LVgzZY5l5u9O5nX5EmcTGQFg6OJWhQLgRVUzAFOeuaXn9reJ5nzciKHFfLAEbC+mUk64WZnLY8QZ 6kiRVrckj74DfAvIQ07Eb+oxliWdJkNqrCr6cJDI6KJrSwOcNU0Ef1mlVI24peKTca0RNJU8b5v9 kaoon35ilqNgN9/hQCocIvrB9MPC2eGPs2PQo+PhVeh6uq0qbOnX79avvz2s3/mjp9HlFNiF+7mi EW4OPacuDr+7wMjChFbBbedljp+FADKO79xzbXuDMbB+J+iuNJ/Sb8Bcxy1osJcfIcLrj/jEDoCm eUnTioksawmvis7clnTSKTmbmCEsZDSbLM20T0azwZFhE9FjmbDMfDw5O/18/eREfbtWM1tOCL/D k07xRILD1PTmEn42cRosWZCU27NLeiiW025FPldT00shBC7+8mJStVhMTG+LUzVtUaaxelnhRzh+ QUKZMusWkIOpXGRLfSPLiU9EloTJcNcJWHgxrUDSfMKM4Q4zTU8519PGrV4puGGTHMk5IEWN+b1j XBn3a/UdUnGLKO7O+PWs4Wev4BPrQH+V4+8cGggRHDb7wyCtbZXKogToNLmqqFCg7FQmB7WBHZwZ DT8guNDFOVCWFiySdK0CnygQmXBQWQwHVEypktgsOIV4bySGibWHjXk8QxE4HZ1hR9huNvf74PAc /LaBfaLjcW8zXynjlsHxPZsWRJLGFt5h9rPON/Uz3khopZVmvJATwRa8l0+0fuFMxjRB5HMzFW3I Yvrwcs0mSzwsKohpWnJTVlkm6NXHTCZqSWIzUc5L8AlaIR6mMpoX3mLjaPPXw3oTRLYEwsHFdTaD Sw8Zcxox5ZwPqlz6LN7Duhk7UOPaiKouGJ6LJCe3ApJepnmsXVxRt4A0VZnjp8H7yCKWeImAvKiH jyU46ayo82pRu/H4Yff0NyZTH59X97aspD3aG9NlwtsjtUnsdhwvi91x11mf8VYITjqC10j8cF2d R2RDehio8nz47lxs6VshlxOzNwxiWUyA4poBPw5thjF18QYNOpCNAc7mLbNNJh7xKG1SpSqV5fNi 4PQr6VL59/aBet8Luc29qw+y4id88NMmomZ+lmkybln60d8ysrscJ+372NnLarevhcbrxooPNuo2 EaEFDieYSDptyKPimjxcFNy9/RqHmGEU3GsXaFdYwR+D9BnDbXUFf7lbbfePdXVBsvrmB/1gpjBZ wHtxP8CwjcqvHorLCf06RZCTlCKOJofTOo5o/arTyU72HNXEx2NI7IKj4OzW6GJ03QVLfylU+kv8 uNr/Eaz/eHhp6sVG985jCnog5VcBkLV9+U471pn1AuEPZStaicIRhwvDTCEDnHYjo3JuTv3BB9Sz o9QLn4rzy1Oi7YxaKcbXE9CRE8u0m0kjPRYwpIDmpjyIlox1WyMRYLRnY2kT33RYwQw1KANSZo7c ch0GXb28IAhrGi1csVyrNdbwj55CnVnDU0Yf8sgDnN/plNEwxNITVo6228bAvrOm+svLzePX9+vn 7WH1sAWYBWM2qnPqFevk2PHm82NU+OcY2eqOM1zCUMiih/2f79X2PcfljyCJN0ik+OycPI/vb3Wg GTKRsYkCtPqZ3Zghg11NkkdREfyz/u9ZkAM0fqrjkRNnWneg1vz9ofyRqpCGYEib3wH0ABeHAlKl E5tRsStQYGcqcEwm/lYIoGI0v/TKTKCxDhCTpIUKf/UaMAruFTpBm5dYgd91lLL/nYJbc/3kNMAI oliimhbpYPmIg+kPb4EYpawLRnE1F4VwYWNdDYFfibSAF01C8zmJExG2TcQETe6QyltmVZLgD9oJ a5gSsE5HGaIinM5J2mlCKizXUkEa/Wxr01h/o+d8wu3SrHt1fllX8rXwKsIqUXBzebSkF4QFq3gT 6H/QcZa6Rl7facZpVNktIhzLXLZMRaDH37Rhuxl6Xq3z7Pap1fjDfu0hynbx0eXZ5a2JckV7xwC3 0zt8tDSi4frT+Zm+mPhgTmQ8UboCBwSfsJz6Wp3lkf4E3i6bCK1InZx9Ojk5P0I8owvEweppVWhT AtPl5XGecH764cNxFrvQTye0xz1P+dX5JR2Di/Tp1UeapKfsRvtqolhMuNfLHL/Zov31s6Hc1ola kSNMIL6QrCnwls/oAF5Dx3pzTgfNG46U3V59/EAHFhuWT+f8lg5xNwwAzMzHT/NcaPqoGzYhTk9O LkgBGGy0/ktMNm+rfSC3+8Pu9cl+zbv/A9zN++CA7gDyBY9gP4N7EJWHF/yj63r9P3o7LxyD4gwR Xz4ugpDbw+YxSOEm/xnsNo/2L5kibmipcjOwcX1BwZEhnGPjczpihilzA07VLbjyITmBpz78sr3I w/Dwc7RBLHRpAcnoizNbBZMqDyEXTEb4t/yQfxcHdnDCH9i9LlHrRQrbrA8cj51Yu5hmFcHh28sm +BGu7M9/B4fVy+bfAY/ew8P5ySldaFSz9lbI50XdOl30Ysl0SKLrTceYO/JEBNvuj9ui/GzC17Ys iZrNpvI4lkFzjKNjMIM+prJ92p7JqLvmcnxDPkvMv8ch7b+/w6TxryX7Pkvyf5RdSXPjuJK+z69Q 9Kn70K+0i5qJPlAkJbHNzQQl0b4oVLaryvFcVoVsx7z+95MJcAHITMhzqEXIDwtBEMhEbuEK/rFg 8oxqpuagO4/bm8mD9KDkm/e3fLudpd+wYIVmAotMBPAQq1QEyuzcWNBIzUwFahVC7vX9cn5BM6LB /z6//wDq659ivR68nt6BiR48Y6CCb6cHw1dMtuZuvVDKWBi4hD6VEeEFe9r6QlJv0zykGQPpxLOm 75Jjmo1SnjLyjo+u5nogbqfoISUv3qi9AZhp+HCQ0WhnNqka1djBNJERtjQFnWRzyG7xon+z43wZ g1vpzGExXigCTi50PVT50UxNxpL2JUfBC0fm1nLDKD5hDILhLmDsuMWkzP19saMHAeXHvZxyGbGN qb3nWOUkigmvGBCS3y/PXz/wWBOwzh9+DFzNhNYQPqsP77NVNN0BWkUX5rrZB4mf5nB8ux4ax0lH 9u6hXgjq9levHbv3utGVToLlkxShSxNzjy7fwfZgHHiqBCQixyG9IbXKqzx1fS81JMnVlOb5Vl6M a4o+4kCaKYKYkQ61Dj3XDzpxkWDVUfpeo9I+3MXk03voIZMYj78J4jAJm1dIc+AdQr/h4N7bmlEV VckxyTDuQ+JCN8oU/FpLmzTdGDHsWtJ25x6CkCSFDghiJU1aaXMBP44BTGF7SVCXHPNy9ddo7PTK CyifT3vFqA8+VqEiJmOitdYjQmzTyP9rPJtre1SNk/oTYkbahjZxGPYfQP41pR8Y71VJSuzmcA6b F6P7+XRSlqz4He9jn3Qk15uFNt0kNbwl4qgUB8t5FJXrw5VWQy8PjLHeCMeZjaAu5UDXqZlW65Gh YkAAkpq4BU8L0PknjenVmRhKT/ikyk3w/1v6zmRpOG/DOyHNLbUqGQjX6M5DjgiPVwwjqbd566Vq AdGqlPjqIHN4DuAVyQ5zNA7JSZJwY7EzIzeKcrMKuguPqBnojnU6IY3cfA1/6PchUg81NCV9KolC rgNjPEUsP6yrA7pL0gx2cEORevCOZbTpzGu/7j40Nl/4CZQIRlpQF5FaxUN43zHJVCXHw2zEOPg3 gMm1c03dluiNV/cnuFAiLnJGhXHLkF9QFQa2yqKLaRjaMD0qvrPdlGUhGk9rXKYq89CTJOS6U5iw WLmM5FY3fIx35TGO0VT5M0A0fUXNDMOqSvA2RLGNnQmJiYXnwQYUUkYx2fYOxLB2DsQBSmqzA6gz gJ8WJQzGvcU2aIki9nlaxUbxgNJxFsv5igXAS1mUcIZY6M7CRq/YKhbghcAI8QOsuBqW7gNDZGve z5yJMx5b6YXnjEb2FqaOnT5fXKEvu/SKug7LQL4//XMIvSzaCbZFyQQcy4N7x0IigWzfaDgaeTym LFhaxU1cpY+GGx4jD3krWZ7kn0AU/OtpjnwWoUJkufxIbq3V8wDlmRsLXR6aPB0OTutjCtg5eGIR jIYlLaSilAU7fejxne9hgxciYOnVHo586Fhyo/SFesZEpIpCynZ9J1aVjaO8jjA8IYDkud04Ohrx BsQAhl1FchZsXNG969XoeRE5I0af0dJphQPSgdddOCV9uY50+MMJUkgOsy3NYhwiNzEPeGUleTz4 1HUNwhup1o9h+bWMjkErTMG72LJCh1kt1qUInaSJwQTVC4WX0qSOZNIl5cI02kDnZTI4vl6xlWko YuCHLjszuWtaOho09UUzRP0SXSeIgi4vGPz9na+z0jpJnspBkjT+44E0eR0cntFq9fe+he8faBr7 9vQ0eP9Rowg24cDcf0n3FcI6tD1QhE8FeUr2hngBP49ZR31d6Wl+fbz39RjaeZXt+iq37enyKK0a wy/poH+XjtHwiTER6nkJNa493Djo3r80919Ut622iHgQNaofp8vp4f3poqmK6124MJxG9pSMhQ5g S2AhClOyUEpDWUzvr/BkcG6pMEOJz921JseNoK9Sqzia8CUw+7pXhXvb7o+rO7zH45YQmi4UpCAT +agkQ0POrrs8cP5cmDMg3XRolW3S5fn0oi1ucyakjYmn3xlWBGesx9fUCrUA7bXpnCEXakgZpBNk NheKWPWRhl/jvkb5FOkgT10V02NL8uNOGnS2l0w6OcdgInFgxag4XIHPPVTsJujfQBuV6kCxBWG7 yaVBTiSGSWEtHoyBkx5AxtyJiO3ncL39Yuw4VIyOCoSGspUGp95hk/Prn1gX0HKFSS0nsVdVLeCU d4VjE2FqTrRC7ZV3WxXhmstdUSM8L2G4vQYxmodiwfAoFai6gf+7cFFDw9xTG9BrsIpRzMRVJOzQ NrKMsZZda0SiwmQNcvk1qIcXQRh7yA83IApGjD9NZ2fpNSMDRzCcJWx8VVhgkrzdqzC/9NmagWyh 4vrTh+/2QAQeb45cZa7VChPow8mb9Bce/MlYs5nojrOT6J9vep84OjhLdkJGQqKlHB3Uhg7s8wpj r2/qAIXaLfi4ipGK6a/MYhUJyLCqwFIZjp12AEN6xydYoyjXjDqHVTO+hkVAr4J2sO34ZSqVwVf0 OagMbX//eX57f/ln8PTz69Pj49Pj4EuF+hP2HbTA/cNgiMaoHMC8CdIJxaptRmwQB/sx8wyoNAjN gKzyoRm/LaSluE0xFmVAzjz3+pDymwm9AyFRhCCy8P2rvaS3NIL/wPp7hW8UMF9EjJN/ejz9kouy z+zKOQxT5Kp3Y76vPF2lxXp3f39MBePChbDCTcUR2BUegKl1OkZAcjgpsOQXbcjaqtDVruy66sxc saNdySQxcrnMR+NK28RrZVqIG22YWMYNhDWn0r5erd6E2fEz+jpBwJZIb4Wkp2aWdeKxir6Qq9xw MjF4eHlWNmhUrgNx9CIZcfFGZihheOIGJTnba6BuLOZmJFVixPOlt4dkRQbjPD/8mwgzXmTH0cxx VCKyjniobpFlVinWNV2TE0+Pj9LnB74o2dvbv4zZMHpCy0KP9inoj1ZrJEy8Iqetf3BiOMfIA5NH Ij3gdrxnwuxKKlp90/yAomM0noi+7NoeYjKYMarHY9dgSKsiGa4kFHjFxtfD7TnfBAlKcjgEjEPp Y96nYyzaWGQ12DS1r0sxxJCM3ljkYWbrqzZc36RoYxdkx0MoAqpFHQjCf64YfJprIKqogJUZZ5dd V+FbJ4DW8SIAVTtHVr+jI68MD10LK7i1KTLEdQ+FuiT64hjNvKiOmgsZ9GBPtRgedUktPmh3NxUh SQ/uXbqjbhEajGInVQouFfraJ7pAf/8mb8WQ6KqXn0TuD4fT+8OPx/P3QXZ5wix254/3weYM59nr uXvdVLUDAnbVDb4bvkHei0ek66Jpz3ZRbcXch2GOd0JWUGV2Ywf5BzsdbbnRsoICVRCZa+Z48LVb w6aojYVSvZ0qJx7wF1Xsx2bOPOAZTAdpsco8S78Cb8nbdB/tFAvKtGjlxS4JX3WiSylN5cfL+/O3 j9cH6SBqcRpbYyjjwllOZ7SRpASIyWJEnwM1eUxf1GcYZc31s9mM8W6Q9fGO+4gCpMf5/zWobeQx nqSIgamYLYeMwC0B/nK2GMUHWgSR3ZTZeFgig8VCYhSX6NmSz+u7yyHDcmN1JM/G1h4khPY/qMlz esIbMu1pUpE5vYskRwnfdOyNJqhjtg1+G86n45GcCvpsL9BPS4QeP8SbIM4ixrcPyI6TxQ5jbtHS +fmT9DnjA6PecDmazhYLG2CxmFvWtAJYplkBHCZMUgNY8pMkAc7UCnCWQ+tDOEsmfk5DX16pv3R4 ejGf2KoHyXo8WsX8StqH6BPJJmFBCJxn9C0HEjNvPYMvgZ+hvJgNbWRvVswcC/3GGfKPnyezYj7i 6aKKcM8DwuliXl7BxDPGcU1Sb+4cWMj894wKbZLorsrZcHil7yLOLNQ74THcGpILdCufTGblsRBw 0POLIMomS8sijzJn4fCTDN1EsWWFuFHMeFwUmZiPhjN6k0DibLjgdxAFsHzeCrDkNwgJGI/47wcf DR7ectJUiNmc/8arXiwTiABnfuVJlyP7gQYg2LAn9EotDtF0OLEsNgDMh9Mrq/EQjcaLiR0TxZOZ 5XsvvMnMWVoe9TYuLa8UpPNt4m5cxjoNmYs8vE8T1zpVh9iZWs42IE9G9gMYIbPhNchySVvMy60r 3cbAKy1GnIGFDgJmxrIJNi1ZQKJAZsGyjRXxujOO2qfPxua2jaD7S9TN7dl2geYJdWzgHie9uZx+ /Xh+IO+p/LyvF3WhjAh7oxcrnJcNfnc/Hp/PA+/cZJP8A/2h2sQxRgufqqDCI11OP58GXz++fXu6 VLKcwfWvaQ9JspqK5XN6+PfL8/cf7xjtwPMtFgRAVREaK2tScsYx00AkLQN4aB0u6ErPTSSi7mvS RdZdQvnZoxlQij5gUVgUIKR3E3QivZefUppFpXFsZrSWBkdRFnavYzVyExR36/lGc9123CSBAXsY tPFQzUxf9Edn1qeXl9MrCP1vKI32g+NiW7X0mqFVjxmiXZLvEhclljhMUsY5UU5SsTketmEhU+pa UatIvllMvLujhFj5fLsirbNdysu3v8ZmQ5T7FD7h9vz2rrkLUrcT8u3MFyWwLjDN7FBLfOsdgEYO KnJ3umR5jlc58HTHgjQfqWFFge9Pxos0LLpRLQsYaJ1QrvR7WwsyTZE2SGkaYl5VmmSbfki+t3I3 Hg23mXXGQpGNRsCM2jBrWAHQkmViU2ZiU/NZjit626CgjHeeCb02BSJCs2Lbs+WOOwc2Z2EFYV8y uFqcEi7kuISrezXv5fT2Rl3HyO+je7uv0aRqm1GHIP3g83WLuO8inaRF8N8DOQVwOrqbYKBSebwN 4DiVjr9fP94Hrf/44Ofpn1o3cnp5k0EgMSDk0+P/DFCZobe0fXr5JcMa/Txf0I3327n7pDWSmqnw 5+m7jI/UP73kHuF73A2AJKOpccfkRweEGc8oyj3ETwTNJ8rW5cv2GesJubEemNuNisibtaL9cegH 9PVS/SUu5kNy0qSpDLOslPEEWc08TJj6QRwyd04VdUxzxnJJ+7uCCfethrYXjAOItPQNNmmB6hoe YfkovTsZrhH+XXjMrZiCSeUAP+1+nO4Ev2LWhR8eA86vWU5ClkXAaYqsE+7InIoQjsbVfsO/f+Ze TH7hOUb63oernOV15aOkBzfPQwuiG0+qc7II6RMuMDhnWewsn1EokMlb02ZiCLiD2pYT8F7ObMkv OzyH4d/xbFTS6ksJEsDiwH9AKOLffw2azrvhWPS5x7jK8PowyVtnipqPKfvxz9vzw+lFRWWkvqYk zRQX4gUhfRFdf+eT7t1Oxexa+jEb2bj+htHBFncZY/ghz7sUcxn1IlDXElOsWQFlB0y6BzsAUagS JLfFgOmmEWqKKi70L0fj3NFbi7Uqw5rkawDCF+F/wdoWplFrRRopmEMS/tYLiSL4eqrsg6me0aWl Z1GxjikCBlPLXWF6F5hkYIqZ8OImrlgywrKOCvB/12Hb6PCJLuHMisXV5iqN3RXUGv+dMFccDSoO o1XgktrVFmSKNFi+3624VMtI3tkeYgeNhnNY+pSjJgK8260ZVBkLY8bWsB1lGSTcTWg7x2wgySBG qwa6DxQR4VBhYpLJZRquQMxgsmeF8HcSrlxSPA5816sTJQkv363aRS1JPdE4LzwMYWMWSAHfLNp6 IADe0YW1D+pvl/eH4W86AIM1AEdv1qoKO7Xae5+Cd+1HGsaYa+yOZc7wOtiMtkEgELjutVLCm/3L cgzTRBR3Qgvq5cddGEiLBvKtyFHne3pvw1s9HClxrtT13NVqdh8w/GsLCtL75RVI6TBKshriCzij 6CtqHbKgj1QNMl/Qh3wN2d7Fzoxh32oMqvqXzLdfY3Ix8yZX+gpFNBozih0Tw2i9OyCaL65BJUDo +/kakXlrZza2P7vEcFpfAzT5DOgzGFMx1n0X01HhDLvrv6WgbYW1i9XtZEzveTVCTGaT5ZBmlGvM Op6MmJOmWRGwyEdXITOHPnH1VhhVag0J4slwbP9W8j1A7Asv3zsOw8Y2E+PDN+n0dg608TR3Dn1n GnsqvbLMqNzg0YDxEzuOLybjif1bgCUzHn3m8ZemcKzMMF9O75jY7to4vDilj0JtpxkzGhwNMmOM XXTIzP4OZLTM2XHtAhvDOBu3yMXUPne+GE8ZqaR558XNaFG49rUTT53iytMjZGJfxwiZ2U+OWMTz 8ZWHWt1O4ZOxr4ds5jHa7RqCK8b+8d7fJbdE2Lnz65/oIHFlQVUJEKwd2JjeZh8q4H/XthmRMOa0 zXwsOgKh8s4M/YF4en07X7in8dFiidYjAGm1W2vKg1b2wvwQmPeYHJKqh5ktuwH66+BlZsMaV7or rZcgjAGnzOXIR81DMkb2CJKdGdlFFceE5Xf8/HA5v52/vQ+2//x6uvy5H3z/eAJhUVdqNaFD7dC2 w00e9D136hktXDaW5SaN/HUoKGHbk5kcetl469z2aNOZuWYSUlRPVXnvqxiLP3+eXweetA2XWj70 WtbfNja0FT594rYNIo+1nDr0BqHBRDibTOkvt4OafQY1ojc/E8REgDNBTHRkDeT5XrAY0rtkB8YZ T+kwMR6iHQ2Tq6gF7r2rbakAJH0T59oxjH7JbVPbA+blxauW3regKonzx4UxE20jgITFfEqrj8lG tDZckOhT0sELnnGnyZP/pScgksRBdvr+pLLciv7neQ2qxLunn+f3p1+X8wO54QdxWmDAZToYOVFZ Nfrr59t3sr0sFvX2Q7do1NQ2CVRWY8yJPv8GY/tdKIe2FN4zuqoN3n49PTx/azLwvNXKGffny/k7 FIuzR/k4UWRVDxrEcJNMtT5VmQdczqfHh/NPrh5JVwqoMvuyvjw9vT2c4IXdni/hba+RamZud6Hn HYME9lDaVOBaW7Kx53/FJTfMHk0Sbz9OLzB29uFIuv5C0SWt9zbL55fn1/9wz1rZ0O+9HfmkVOXG e/ZTy6TtKovxRmKdB7SzeFBiDFXuZirNmYsl5hTPDn2DGXRTl5lP+s6m+W03niU6HHf5sdrjrduO NhxMC8zYZkgvJXRNLvI0isw0jYq2yr1YFCv85TFeKgqooj1taHWHghQhYRipZJztHWxYX5Uvqr4W 6iRclrhexxu0KkNFCItC97PaocKnTyMT8ol2RBjknCE8wNAzPIxLJ77tx2TXYDEcaxH8nYX2XrPS PY6dJJaqmusonA0Wpd4UqizIpWS+C60qaiE97qLW67ucZk8XmZD9FU5EOJyf34FJJ/hLG0xbQW6f f3dfHy/n50cjBF3i52nokw9Ww1t0FK6SvR/GTPAPlzqv62tT/WdzO6pkkgPmFHhABT4VuYFJbqve SjemVB0Npt9kW3OdMRrTtWAcW8OUCcsQhTHHwEvbC0/lqmOYtV3fPKMWiEyXKmWn9wwHlVplxva/ d6PQd4sAho/5awSZXxFoYaoyvLd79fi4Nlxwq6JjiXHjuQ1+0kky0FKmR/3GuypAL6SwPLpe1CeJ wNvloRlnR9K4a/i/V76Rlgx/s2BMHbnyXG8bmLt0CDMEtDX92v7mSSVP2qzFmKOtCkt3SRhZqq7H fE2g0B9cZ861mUWOGahKgZqS/qgow6Nt8k2Y6DpOjFJUwPndpeujgV0+v8tYr0tAgDhOB01diyQt VJbuei/pFoSqQHqIGh27ikD2ebtLCyac/65I12LKTa4is1MPg+BoVYoqKhOHd3r40TGtFXJ90gKS Qiu4TNLxBRMy4S5AbAKhSJfz+ZAb1c5f90h1P3Tb6sInFV/WbvElKbh+YwEYrtc91GUXfkHMb737 0d2qQ/Lt6ePxPPhmDKc+cVUKFM2wAAtuzJA+smwfdx11teJKQYg5EqhIdhKJfFkRdVrNXAwfrZI/ 99oG5jTy84ByVL8J8kQfdkd3WCfGbdpTeXGbj5ycX4Xp7eQtN772j14ewLmht6z+4d8MMftNkxgu DLcHFSjfGHCau8km4D8o17fQ1jwtkDsOR93yFYEkQ7FyW7ZlrCvLcHqk5lBRm3z7TuuSyppk2CvH yAFAWq/14NwtFe9TcTvVt0hFFbs4dvNecb0YiHLihG5o1BGtiHVqY9jvLclLFfbe0PSrshydpLV7 yNyN9QlSv9VZ1VGOV6ROdsmWKbvduWLLbUmWQxyTKpTsvh5bVlPG026Tcmqlznlqbus0Q4NYJujY ndizJ4Fl+eb9M6/erau4JOb3XRNlLfP3ftz5Pen+NhecLJsaYSllyXFEjEZa1SfmnohwPJar2Is+ uRprEG64IDz4SWfUfihktI6dn2k3jHoflO3LRkZjzDBcpeasIRdu56d6RK1DmIO+aQwSGq+R+pXu kjzzur+PG2GGPVSlPY64/XQwrT3z+r2QI6S+y+/O3IqJ9LmNRO1d8tdvr5rNDRKg+UCenNMJrfE1 QItPgZh8fAbIYRyuOyD6XqAD+lR3nxi4M//MmOa0GqQD+szAGdONDojWlXRAn5mCOa0p6YBodbEB Wk4+0dLyMy/4/yq7lua2cST8V1xz2q3KpGIn8ToHH0CKkhjxZZCM7FxYiqx1VLFllyTXTObXb3cD 4ANEQ95TYvQnEI8G0Gj04wtjijAEfXpDm64YwyUEgXh+dfX5S+N+ch9Uc37xlmYDimcCUYZMxO9+ W/jfGwQ/MgbBs49BnB4TnnEMgp9rg+CXlkHwE9iOx+nOME+LAwjfnUUeXzVM4jRDdnufI5kSC+Up F8hXI8IoqWImwVkLyaqolm6dewuSuajiUx+7k3GSnPjcTEQnITJivG8MAq5jCZfAu8VkdezWtA2G 71SnqlourLf1Aaaupu5VXGdxaLlyaUqcN0sVf9f4zvZVeTpA8vp1vz3+HntmLqJhcGn8u5HRTY0+ FQ71gREPlRMnRcWLYJ641PSBrtItESqVTjThIUBoJnMMSiXF6BLQCSb6GtFM0qik541Kxoxe1GC9 RKfMQVYOFDU0gyajpojyeYkEhC9h3clHMLemB9OUTO/woVUyVjsUSi6katCTT8UedTTOeNd2QyF6 8lxSptd/4JP4/fNfu3e/V0+rd4/Pq/uX7e7dYfXfDdSzvX+HBscPyCV/KKZZbPa7zePZz9X+frPr hZU377qpyi+/3W2P29Xj9h/jJW7YMosrbH64wFDkAz3ALAwbuCDP4gwAsg6rJBIL6qNb/emEB3cy cofm9OBxtpy/odbCXZNmsx1NRtlowFPYWVissddxj5Ih84PchSC21m53h4XF04agDfe/X47PZ2t0 cHzen/3cPL5s9t1sKDBG8RRF3L8H94ovxuWRmIxLy0WIKSskSxj/ZA53ZmfhGCqzmaMhbM2LonDA UX0wLla518bt1uUD5b8m2Uzp/GF7s0Mz+dJRCwbC52tBquvb9I/7VDL9rKt5lLmPPw1xWu4Xrz8e t+s/f21+n62Jbx4wZMHvgRWWno3SreHWZDtP75AahafocuKvHzazb9HF58/nX0Z9EK/Hn5vdcbum 9NzRjjqCoTcoc684HJ7XWyJNVseVo2ch49usyTM/OZzD2SguPhR5cnf+kbGab1fRLEZjXx+mjG4Y B7x2rOYC9p1xoMSATJ2enu/7jiKmlUHo4is75oZFZl7nWrLrcGxbGTg+mEi3HYIm51NXfAZNLNx9 uGVSLZhdIbpbSuZx3MwKRtioau8sowJyPOLz1eFnO+Cj4eHSvZlN7wT9Fvrro3+zfq9eUrYPm8Nx PP0y/Hjh5AAkeFtxi5uzDxEkYhFdeBlJQbzzBA2pzj9MmBjbZimeastbFmE6+cQzWTr57BglKMXQ Dt5aY1iWZDLihcl0cmL9I4LRznSIi8+MLWiL+MhYoJtdZi4YG9eOfqrLgDnRDkB8PveyFyDc12FD T/3kCgSvgAvVqs+9mTz/4m3EsrBaqVbz9uWnZQHXbuNeVgayZVw3QmR1EPvrkCFjOWxWVL60TbNH S0pg9t3Yf6yKsvKuFgRc8utlErmknCn9692W5+K78Eo0pUhK4Wdic/T6j1PGebmlywIur34e9E5F xcTFMORlbk+UMX9/2W8OBxNQyx7XaSKY5KrmLP3uVq1o8hXj6tL+2tspIDM+yRrwvRwKpMryeLW7 f346y16ffmz2ygK6ixhmL4EybsJCMq4HZhhkMCP/CR/oa1xVkYzQVpK5XvdE+AauN82pY6QFmnvM m8An+tLi8C41Zgd1a3vc/tiv4Ja4f349bndOuSKJg7ccqAhTC+Qkyilaj3FqrY/LzaGLue++R9fn zo+85WTumvw2cXruFiZFeZemESp+SGuEMSXGw73ZH9H2GO4FB4oHdNg+7FbHV7gzr39u1pg8b+h3 hG+RvUhiWtflvOi/pW4zjEGcCamzA03NDT7xMAEaDVsfbquCwxA9kXqv3cZMF87JLCzumqnMU2Pa 5IAkUcZQMQdgXcXJcLfP5WQo7miC1ClTh0dDCDet2BmgDGjnlzbYKw6GTVzVDVPXR+sODQWwzydT +wY8BCRxGAV3V46fKgq3XxJEyCW/XSMiYHTGQGXevUJeBAjd7xCwfpSgz/2M8cSk3Ev+MULLCozM kChDnn6pPqq60tvvUBbafze3V5ejMrJdLsbYWFx+GhUKmbrKqnmdBiNCWYAINSoNwq/9+dWlTJ+B pG1Pmtn3uGfS2iMEQLgYL5e+KrjdlTDrPCyMbxG0Woqe5QwGYIzzgfmyKsL3+mZgTYvlk1T0nrxB vmlK8n1sYPnOqp52jaI7IkFMJrKpmstPwIW9bgAFupIISjo3pyO0Pzr0SzSAZwxfy1miOtqr8qZn azFL8oEOAP/28ViWDA2H2sGkcB+XA6uNWN7gkeLSpQFPTvtpE/IYI3LPYNfuWyuVaDifJ9Zg4fAW aDg+0I22pFpFL2mmCYZs0Sa/pkIYWzVVPZU9nhHOLreHxWivH2rczUlEpS/77e74i/zf7582h4fx I47KMtdok6fu0FDFoUgStxJTpRxsknyWwBHSpnK5/g+LuKnjqLr+1Bn6lSW+F49q+NgZG6ZBDjtp E0mZib5JlskZNfuGgdV1ehc9PGyXWxl6+7j5E/OMqLP1QNC1Kt+7XIjV1zA5nGMgVDYUjKVXgSQS 9UNCTSU0ulkKmV2ff7j4NJzlApY3ehukjIEVSHxUsWASrc4jTN8ASx4ztTq5Gk3fUhCvAJLEmWUV rfpURiEeu2ghmQp3jCwbQv1p8iy5G1c3zSXmOcEXE8xyN8rc13l4vm0OBg6UmsEnmx+vDxRSMd4d jvvXJ0y+1QuDJWYx2cBSWtFxYfvkoubt+sPf5y6UijLo6CH7uEcrfjGbDPYv/Nvxg253CEqRgSiQ xRVOlEgGnySq4+fqVyKJZ1lqNmDLhdQ7WMNVpCzO7LWFNrNGuNTPUG1lQ+ESljClhC0583pVIQJp 63diqJp8mXEp0pBc5HGZZ5znefeVhnvbU5A8+BqFXLLdpA4MzN0ZQuDDKssIelThSMCnwzELGYqn ierlsy6toKJdIzAcr0Zh+GHadzz1fXNl+myZUGNiWdUultcET/XKgZJeNv2DQi1GN4Rpki8du1Gf 7F9nOv6cm4B67qGQEYbUU0XVQsJgnQr3SlM/oHbRJXX4LtstiFFP5lbSYqVpR/xZ/vxyeHeWPK9/ vb6ofW++2j1YN7YMdiK0Xna7wgzo6GVVR/10W5jbCo0660KnUGZCZOr8yvMaJI5KlG4OWt4wiala fzBfp5QFCezx968UtbC3hQx42UQuHLL4aJ11D9uOKu1JQJFmEUWFtWOo+zK+e3W7478OL9sdZSx8 d/b0etz8vYH/bI7r9+/f/7trKjknUd0zEtLGZriFBPY1TkjuCxfWgf3yrCeU4OsqumV0xprFHDEQ 7HV5spLlUoFgW8uXhbBdFoetWpYRI6woAHWN3+J1KlAdiC+BiTlRF44xadS0MOz+Nn0VOBwDuPIB X7uOeiXr/4MrWv7FzYGy3vcZgYQkGIumzlCdDBw+zrhsnwvqYGJ2jV/qQL9fHVdneJKvUTnkkFLZ 0Pb6fDxBL32HK7mzxRETYV8dms1EVALVPLJ2ONwN9gymS/ZXQwnjl1Ugjo391mRYu8USIKAIOuU5 AhEn2YZAksv5iNToxpEbtouOMWjfaPXdaIlZOmTl4U2HuBzELHQAczcVFSpZeFflLscwDNVL/ZDW oTmtMyXe+6kzKYq5G2NyL0zNGhhUQIVNSg7FIJeh+s+CoLsaLhRCgoiXVaWFCPUPVS095zOqOxyG 4aXrs+2cBNdL+DziB76j8E+FY6riA4+616uKtrUlAPuKlVF9umDsNmGPDabRxNOpV0U7j9aMuOU/ kvw8gEJGUQrrD24y1HfGD1zelJg61vclOp09gPkSGM8H0PfjNv8kIRnnVTWjmiOYdFb0+6bMRFHO c5e8GWD08DkexeQRbNsPmnJMTwLHMPRO/YA5J1s4sKgXaJILxPl4xzD3NqgsiPSM9LihmI7KzKqy y60aumnAF4ZKxrMZN7hqbNVKiDP7pBnCaBk2Aewn81RIJnxlb3X4kebLmNdWFHwstn6NwOGwNRf8 ztzjcJX5mEWWAmN3u8To3g2IQj/EpVrnlOpEqc+e/9rsX9bM1Rf9mbTx3jKSMnfpyRCkiP1JxOFV i3gSFdX8+rKnHEJLbZDwYUfiNYHdgsFoWjBOXlhaxo1SNfpx2FYcUMqNm8KFwOOudZsyF+RgEjsC rg++EQmZ3HlOzfGo9zWc1eZwROkMLxkhZglePWz607KoM87YXssvDc2HXgVsUADarpwYm30WYf5t dNeEiyMUa+YvhrfNcJiz2PA/nG50KMD84NTbQQApVQE9JZY5E0qeICw1MJIqsYFH6gnQRsZDpweE PMkxohuLoigjuOj9lYGURrmzObpR5ftZlzo+j25tx3hrZJR2XRnCM9ukxpUhYxhAgAUgKibyCgHU 6yxPV8vRSwdOZXJkEKKu7dg4feotvRfxdJeWZYiQaPFAGeI9A84ZRRA1nrjtCBQfL9x3ISJq/Y2n 82gYwbpGqBEsfMOPr/LznOQSt+XsNM4mOAunzjaVPkSmcOHzDJSKyeDpD51hPoYkTw7W1UUxZZp7 OAIOuBAkNe/qIEMBZvM0lbAAoLEXa+/WPXJnUC9Y/wOUJwCL+fMAAA== --===============1758527642342293009==--