Content-Type: multipart/mixed; boundary="===============8077519654652772254==" MIME-Version: 1.0 From: kernel test robot To: kbuild-all@lists.01.org Subject: Re: [RFC v2 PATCH 2/3] mm: replace custom PG2KB/KB2PG macros with common ones Date: Sun, 19 Sep 2021 23:35:17 +0800 Message-ID: <202109192314.zZphmZbb-lkp@intel.com> In-Reply-To: <20210919131248.489798-3-oleksandr@natalenko.name> List-Id: --===============8077519654652772254== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Hi Oleksandr, [FYI, it's a private test report for your RFC patch.] [auto build test ERROR on hnaz-mm/master] url: https://github.com/0day-ci/linux/commits/Oleksandr-Natalenko/mm-com= mon-PAGE_SIZE-shift-macros/20210919-211421 base: https://github.com/hnaz/linux-mm master config: arc-randconfig-r043-20210919 (attached as .config) compiler: arc-elf-gcc (GCC) 11.2.0 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/c129ed106a8dd29030e8585cb= 39a779de91aaa6a git remote add linux-review https://github.com/0day-ci/linux git fetch --no-tags linux-review Oleksandr-Natalenko/mm-common-PAGE= _SIZE-shift-macros/20210919-211421 git checkout c129ed106a8dd29030e8585cb39a779de91aaa6a # save the attached .config to linux build tree mkdir build_dir COMPILER_INSTALL_PATH=3D$HOME/0day COMPILER=3Dgcc-11.2.0 make.cross= O=3Dbuild_dir ARCH=3Darc prepare If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All error/warnings (new ones prefixed by >>): arch/arc/Makefile:26: ** WARNING ** CONFIG_ARC_TUNE_MCPU flag '' is unkn= own, fallback to '' error: no override and no default toolchain set init/Kconfig:70:warning: 'RUSTC_VERSION': number is invalid In file included from ./arch/arc/include/generated/asm/div64.h:1, from include/linux/math.h:5, from include/linux/kernel.h:15, from include/linux/list.h:9, from include/linux/preempt.h:11, from include/linux/percpu.h:6, from include/linux/arch_topology.h:9, from include/linux/topology.h:30, from include/linux/gfp.h:9, from include/linux/mm.h:10, from arch/arc/include/asm/arcregs.h:149, from arch/arc/include/asm/irqflags-arcv2.h:9, from arch/arc/include/asm/irqflags.h:13, from include/linux/irqflags.h:16, from arch/arc/include/asm/smp.h:102, from arch/arc/include/asm/cmpxchg.h:13, from arch/arc/include/asm/atomic.h:13, from include/linux/atomic.h:7, from include/asm-generic/bitops/lock.h:5, from arch/arc/include/asm/bitops.h:188, from include/linux/bitops.h:33, from include/linux/log2.h:12, from kernel/bounds.c:13: include/linux/math64.h: In function 'div_u64_rem': >> include/asm-generic/div64.h:224:13: error: implicit declaration of funct= ion 'is_power_of_2' [-Werror=3Dimplicit-function-declaration] 224 | is_power_of_2(__base)) { \ | ^~~~~~~~~~~~~ include/linux/math64.h:92:22: note: in expansion of macro 'do_div' 92 | *remainder =3D do_div(dividend, divisor); | ^~~~~~ >> include/asm-generic/div64.h:226:25: error: implicit declaration of funct= ion 'ilog2' [-Werror=3Dimplicit-function-declaration] 226 | (n) >>=3D ilog2(__base); \ | ^~~~~ include/linux/math64.h:92:22: note: in expansion of macro 'do_div' 92 | *remainder =3D do_div(dividend, divisor); | ^~~~~~ In file included from include/asm-generic/preempt.h:5, from ./arch/arc/include/generated/asm/preempt.h:1, from include/linux/preempt.h:78, from include/linux/percpu.h:6, from include/linux/arch_topology.h:9, from include/linux/topology.h:30, from include/linux/gfp.h:9, from include/linux/mm.h:10, from arch/arc/include/asm/arcregs.h:149, from arch/arc/include/asm/irqflags-arcv2.h:9, from arch/arc/include/asm/irqflags.h:13, from include/linux/irqflags.h:16, from arch/arc/include/asm/smp.h:102, from arch/arc/include/asm/cmpxchg.h:13, from arch/arc/include/asm/atomic.h:13, from include/linux/atomic.h:7, from include/asm-generic/bitops/lock.h:5, from arch/arc/include/asm/bitops.h:188, from include/linux/bitops.h:33, from include/linux/log2.h:12, from kernel/bounds.c:13: include/linux/thread_info.h: In function 'set_ti_thread_flag': >> include/linux/thread_info.h:89:9: error: implicit declaration of functio= n 'set_bit' [-Werror=3Dimplicit-function-declaration] 89 | set_bit(flag, (unsigned long *)&ti->flags); | ^~~~~~~ include/linux/thread_info.h: In function 'clear_ti_thread_flag': >> include/linux/thread_info.h:94:9: error: implicit declaration of functio= n 'clear_bit' [-Werror=3Dimplicit-function-declaration] 94 | clear_bit(flag, (unsigned long *)&ti->flags); | ^~~~~~~~~ include/linux/thread_info.h: In function 'test_and_set_ti_thread_flag': >> include/linux/thread_info.h:108:16: error: implicit declaration of funct= ion 'test_and_set_bit' [-Werror=3Dimplicit-function-declaration] 108 | return test_and_set_bit(flag, (unsigned long *)&ti->flag= s); | ^~~~~~~~~~~~~~~~ include/linux/thread_info.h: In function 'test_and_clear_ti_thread_flag': >> include/linux/thread_info.h:113:16: error: implicit declaration of funct= ion 'test_and_clear_bit' [-Werror=3Dimplicit-function-declaration] 113 | return test_and_clear_bit(flag, (unsigned long *)&ti->fl= ags); | ^~~~~~~~~~~~~~~~~~ include/linux/thread_info.h: In function 'test_ti_thread_flag': >> include/linux/thread_info.h:118:16: error: implicit declaration of funct= ion 'test_bit'; did you mean 'test_taint'? [-Werror=3Dimplicit-function-dec= laration] 118 | return test_bit(flag, (unsigned long *)&ti->flags); | ^~~~~~~~ | test_taint In file included from include/linux/cpumask.h:12, from include/linux/smp.h:13, from include/linux/percpu.h:7, from include/linux/arch_topology.h:9, from include/linux/topology.h:30, from include/linux/gfp.h:9, from include/linux/mm.h:10, from arch/arc/include/asm/arcregs.h:149, from arch/arc/include/asm/irqflags-arcv2.h:9, from arch/arc/include/asm/irqflags.h:13, from include/linux/irqflags.h:16, from arch/arc/include/asm/smp.h:102, from arch/arc/include/asm/cmpxchg.h:13, from arch/arc/include/asm/atomic.h:13, from include/linux/atomic.h:7, from include/asm-generic/bitops/lock.h:5, from arch/arc/include/asm/bitops.h:188, from include/linux/bitops.h:33, from include/linux/log2.h:12, from kernel/bounds.c:13: include/linux/bitmap.h: In function 'bitmap_empty': >> include/linux/bitmap.h:391:16: error: implicit declaration of function '= find_first_bit'; did you mean 'sched_find_first_bit'? [-Werror=3Dimplicit-f= unction-declaration] 391 | return find_first_bit(src, nbits) =3D=3D nbits; | ^~~~~~~~~~~~~~ | sched_find_first_bit include/linux/bitmap.h: In function 'bitmap_full': >> include/linux/bitmap.h:399:16: error: implicit declaration of function '= find_first_zero_bit' [-Werror=3Dimplicit-function-declaration] 399 | return find_first_zero_bit(src, nbits) =3D=3D nbits; | ^~~~~~~~~~~~~~~~~~~ include/linux/bitmap.h: In function 'bitmap_weight': >> include/linux/bitmap.h:405:24: error: implicit declaration of function '= hweight_long' [-Werror=3Dimplicit-function-declaration] 405 | return hweight_long(*src & BITMAP_LAST_WORD_MASK= (nbits)); | ^~~~~~~~~~~~ include/linux/bitmap.h: In function 'bitmap_set': >> include/linux/bitmap.h:413:17: error: implicit declaration of function '= __set_bit' [-Werror=3Dimplicit-function-declaration] 413 | __set_bit(start, map); | ^~~~~~~~~ include/linux/bitmap.h: In function 'bitmap_clear': >> include/linux/bitmap.h:427:17: error: implicit declaration of function '= __clear_bit' [-Werror=3Dimplicit-function-declaration] 427 | __clear_bit(start, map); | ^~~~~~~~~~~ include/linux/bitmap.h: In function 'bitmap_next_clear_region': >> include/linux/bitmap.h:471:15: error: implicit declaration of function '= find_next_zero_bit' [-Werror=3Dimplicit-function-declaration] 471 | *rs =3D find_next_zero_bit(bitmap, end, *rs); | ^~~~~~~~~~~~~~~~~~ >> include/linux/bitmap.h:472:15: error: implicit declaration of function '= find_next_bit' [-Werror=3Dimplicit-function-declaration] 472 | *re =3D find_next_bit(bitmap, end, *rs + 1); | ^~~~~~~~~~~~~ In file included from include/linux/smp_types.h:5, from include/linux/smp.h:15, from include/linux/percpu.h:7, from include/linux/arch_topology.h:9, from include/linux/topology.h:30, from include/linux/gfp.h:9, from include/linux/mm.h:10, from arch/arc/include/asm/arcregs.h:149, from arch/arc/include/asm/irqflags-arcv2.h:9, from arch/arc/include/asm/irqflags.h:13, from include/linux/irqflags.h:16, from arch/arc/include/asm/smp.h:102, from arch/arc/include/asm/cmpxchg.h:13, from arch/arc/include/asm/atomic.h:13, from include/linux/atomic.h:7, from include/asm-generic/bitops/lock.h:5, from arch/arc/include/asm/bitops.h:188, from include/linux/bitops.h:33, from include/linux/log2.h:12, from kernel/bounds.c:13: include/linux/llist.h: In function 'llist_del_all': >> include/linux/llist.h:237:16: error: implicit declaration of function 'x= chg' [-Werror=3Dimplicit-function-declaration] 237 | return xchg(&head->first, NULL); | ^~~~ >> include/linux/llist.h:237:16: warning: returning 'int' from a function w= ith return type 'struct llist_node *' makes pointer from integer without a = cast [-Wint-conversion] 237 | return xchg(&head->first, NULL); | ^~~~~~~~~~~~~~~~~~~~~~~~ In file included from : include/linux/gfp.h: In function 'gfp_migratetype': >> include/linux/gfp.h:347:63: error: 'MIGRATE_MOVABLE' undeclared (first u= se in this function) 347 | BUILD_BUG_ON((___GFP_MOVABLE >> GFP_MOVABLE_SHIFT) !=3D = MIGRATE_MOVABLE); | ^~= ~~~~~~~~~~~~~ include/linux/compiler_types.h:302:23: note: in definition of macro '__c= ompiletime_assert' 302 | if (!(condition)) = \ | ^~~~~~~~~ include/linux/compiler_types.h:322:9: note: in expansion of macro '_comp= iletime_assert' 322 | _compiletime_assert(condition, msg, __compiletime_assert= _, __COUNTER__) | ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:39:37: note: in expansion of macro 'compiletim= e_assert' 39 | #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), = msg) | ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:50:9: note: in expansion of macro 'BUILD_BUG_O= N_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #con= dition) | ^~~~~~~~~~~~~~~~ include/linux/gfp.h:347:9: note: in expansion of macro 'BUILD_BUG_ON' 347 | BUILD_BUG_ON((___GFP_MOVABLE >> GFP_MOVABLE_SHIFT) !=3D = MIGRATE_MOVABLE); | ^~~~~~~~~~~~ include/linux/gfp.h:347:63: note: each undeclared identifier is reported= only once for each function it appears in 347 | BUILD_BUG_ON((___GFP_MOVABLE >> GFP_MOVABLE_SHIFT) !=3D = MIGRATE_MOVABLE); | ^~= ~~~~~~~~~~~~~ include/linux/compiler_types.h:302:23: note: in definition of macro '__c= ompiletime_assert' 302 | if (!(condition)) = \ | ^~~~~~~~~ include/linux/compiler_types.h:322:9: note: in expansion of macro '_comp= iletime_assert' 322 | _compiletime_assert(condition, msg, __compiletime_assert= _, __COUNTER__) | ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:39:37: note: in expansion of macro 'compiletim= e_assert' 39 | #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), = msg) | ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:50:9: note: in expansion of macro 'BUILD_BUG_O= N_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #con= dition) | ^~~~~~~~~~~~~~~~ include/linux/gfp.h:347:9: note: in expansion of macro 'BUILD_BUG_ON' 347 | BUILD_BUG_ON((___GFP_MOVABLE >> GFP_MOVABLE_SHIFT) !=3D = MIGRATE_MOVABLE); | ^~~~~~~~~~~~ In file included from include/asm-generic/bug.h:5, from arch/arc/include/asm/bug.h:30, from include/linux/bug.h:5, from include/linux/page-flags.h:10, from kernel/bounds.c:10: >> include/linux/gfp.h:349:22: error: 'page_group_by_mobility_disabled' und= eclared (first use in this function) 349 | if (unlikely(page_group_by_mobility_disabled)) | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ include/linux/compiler.h:78:45: note: in definition of macro 'unlikely' 78 | # define unlikely(x) __builtin_expect(!!(x), 0) | ^ In file included from include/linux/mm.h:10, from arch/arc/include/asm/arcregs.h:149, from arch/arc/include/asm/irqflags-arcv2.h:9, from arch/arc/include/asm/irqflags.h:13, from include/linux/irqflags.h:16, from arch/arc/include/asm/smp.h:102, from arch/arc/include/asm/cmpxchg.h:13, from arch/arc/include/asm/atomic.h:13, from include/linux/atomic.h:7, from include/asm-generic/bitops/lock.h:5, from arch/arc/include/asm/bitops.h:188, from include/linux/bitops.h:33, from include/linux/log2.h:12, from kernel/bounds.c:13: >> include/linux/gfp.h:350:24: error: 'MIGRATE_UNMOVABLE' undeclared (first= use in this function) 350 | return MIGRATE_UNMOVABLE; | ^~~~~~~~~~~~~~~~~ include/linux/gfp.h: At top level: >> include/linux/gfp.h:441:25: warning: "ZONES_SHIFT" is not defined, evalu= ates to 0 [-Wundef] 441 | #define GFP_ZONES_SHIFT ZONES_SHIFT | ^~~~~~~~~~~ include/linux/gfp.h:444:10: note: in expansion of macro 'GFP_ZONES_SHIFT' 444 | #if 16 * GFP_ZONES_SHIFT > BITS_PER_LONG | ^~~~~~~~~~~~~~~ include/linux/gfp.h: In function 'gfp_zone': include/linux/gfp.h:441:25: error: 'ZONES_SHIFT' undeclared (first use i= n this function); did you mean 'NMI_SHIFT'? 441 | #define GFP_ZONES_SHIFT ZONES_SHIFT | ^~~~~~~~~~~ include/linux/gfp.h:449:29: note: in expansion of macro 'GFP_ZONES_SHIFT' 449 | (ZONE_NORMAL << 0 * GFP_ZONES_SHIFT) = \ | ^~~~~~~~~~~~~~~ include/linux/gfp.h:481:14: note: in expansion of macro 'GFP_ZONE_TABLE' 481 | z =3D (GFP_ZONE_TABLE >> (bit * GFP_ZONES_SHIFT)) & | ^~~~~~~~~~~~~~ include/linux/gfp.h: In function 'gfp_zonelist': include/linux/gfp.h:500:16: error: 'ZONELIST_FALLBACK' undeclared (first= use in this function) 500 | return ZONELIST_FALLBACK; | ^~~~~~~~~~~~~~~~~ include/linux/gfp.h: In function 'node_zonelist': include/linux/gfp.h:514:16: error: implicit declaration of function 'NOD= E_DATA' [-Werror=3Dimplicit-function-declaration] 514 | return NODE_DATA(nid)->node_zonelists + gfp_zonelist(fla= gs); | ^~~~~~~~~ include/linux/gfp.h:514:30: error: invalid type argument of '->' (have '= int') 514 | return NODE_DATA(nid)->node_zonelists + gfp_zonelist(fla= gs); | ^~ include/linux/gfp.h: At top level: include/linux/gfp.h:525:17: error: unknown type name 'nodemask_t' 525 | nodemask_t *nodemask); | ^~~~~~~~~~ include/linux/gfp.h:527:17: error: unknown type name 'nodemask_t' 527 | nodemask_t *nodemask); | ^~~~~~~~~~ include/linux/gfp.h:530:33: error: unknown type name 'nodemask_t' 530 | nodemask_t *nodemask, int nr_pag= es, | ^~~~~~~~~~ include/linux/gfp.h: In function 'alloc_pages_bulk_list': include/linux/gfp.h:538:16: error: implicit declaration of function '__a= lloc_pages_bulk'; did you mean 'alloc_pages_bulk_list'? [-Werror=3Dimplicit= -function-declaration] 538 | return __alloc_pages_bulk(gfp, numa_mem_id(), NULL, nr_p= ages, list, NULL); | ^~~~~~~~~~~~~~~~~~ | alloc_pages_bulk_list include/linux/gfp.h: In function 'alloc_pages_bulk_array_node': include/linux/gfp.h:550:20: error: 'NUMA_NO_NODE' undeclared (first use = in this function) 550 | if (nid =3D=3D NUMA_NO_NODE) | ^~~~~~~~~~~~ In file included from include/asm-generic/bug.h:5, from arch/arc/include/asm/bug.h:30, from include/linux/bug.h:5, from include/linux/page-flags.h:10, from kernel/bounds.c:10: include/linux/gfp.h: In function '__alloc_pages_node': include/linux/gfp.h:563:37: error: 'MAX_NUMNODES' undeclared (first use = in this function) 563 | VM_BUG_ON(nid < 0 || nid >=3D MAX_NUMNODES); | ^~~~~~~~~~~~ include/linux/compiler.h:78:45: note: in definition of macro 'unlikely' 78 | # define unlikely(x) __builtin_expect(!!(x), 0) | ^ include/linux/mmdebug.h:17:25: note: in expansion of macro 'BUG_ON' 17 | #define VM_BUG_ON(cond) BUG_ON(cond) | ^~~~~~ include/linux/gfp.h:563:9: note: in expansion of macro 'VM_BUG_ON' 563 | VM_BUG_ON(nid < 0 || nid >=3D MAX_NUMNODES); | ^~~~~~~~~ In file included from arch/arc/include/asm/bug.h:30, from include/linux/bug.h:5, from include/linux/page-flags.h:10, from kernel/bounds.c:10: include/linux/gfp.h:564:52: error: implicit declaration of function 'nod= e_online'; did you mean 'node_zonelist'? [-Werror=3Dimplicit-function-decla= ration] 564 | VM_WARN_ON((gfp_mask & __GFP_THISNODE) && !node_online(n= id)); | ^~~~~~~~~~~ include/asm-generic/bug.h:121:32: note: in definition of macro 'WARN_ON' 121 | int __ret_warn_on =3D !!(condition); = \ | ^~~~~~~~~ include/linux/gfp.h:564:9: note: in expansion of macro 'VM_WARN_ON' 564 | VM_WARN_ON((gfp_mask & __GFP_THISNODE) && !node_online(n= id)); | ^~~~~~~~~~ In file included from include/linux/mm.h:10, from arch/arc/include/asm/arcregs.h:149, from arch/arc/include/asm/irqflags-arcv2.h:9, from arch/arc/include/asm/irqflags.h:13, from include/linux/irqflags.h:16, from arch/arc/include/asm/smp.h:102, from arch/arc/include/asm/cmpxchg.h:13, from arch/arc/include/asm/atomic.h:13, from include/linux/atomic.h:7, from include/asm-generic/bitops/lock.h:5, from arch/arc/include/asm/bitops.h:188, from include/linux/bitops.h:33, from include/linux/log2.h:12, from kernel/bounds.c:13: include/linux/gfp.h:566:16: error: implicit declaration of function '__a= lloc_pages'; did you mean '__alloc_pages_node'? [-Werror=3Dimplicit-functio= n-declaration] 566 | return __alloc_pages(gfp_mask, order, nid, NULL); | ^~~~~~~~~~~~~ | __alloc_pages_node include/linux/gfp.h:566:16: warning: returning 'int' from a function wit= h return type 'struct page *' makes pointer from integer without a cast [-W= int-conversion] 566 | return __alloc_pages(gfp_mask, order, nid, NULL); | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In file included from include/asm-generic/bug.h:5, from arch/arc/include/asm/bug.h:30, from include/linux/bug.h:5, vim +/MIGRATE_MOVABLE +347 include/linux/gfp.h 6cb062296f73e7 Christoph Lameter 2007-10-16 342 = 01c0bfe061f309 Wei Yang 2020-06-03 343 static inline int g= fp_migratetype(const gfp_t gfp_flags) 467c996c1e1910 Mel Gorman 2007-10-16 344 { 016c13daa5c9e4 Mel Gorman 2015-11-06 345 VM_WARN_ON((gfp_fl= ags & GFP_MOVABLE_MASK) =3D=3D GFP_MOVABLE_MASK); 016c13daa5c9e4 Mel Gorman 2015-11-06 346 BUILD_BUG_ON((1UL = << GFP_MOVABLE_SHIFT) !=3D ___GFP_MOVABLE); 016c13daa5c9e4 Mel Gorman 2015-11-06 @347 BUILD_BUG_ON((___G= FP_MOVABLE >> GFP_MOVABLE_SHIFT) !=3D MIGRATE_MOVABLE); 467c996c1e1910 Mel Gorman 2007-10-16 348 = 467c996c1e1910 Mel Gorman 2007-10-16 @349 if (unlikely(page_= group_by_mobility_disabled)) 467c996c1e1910 Mel Gorman 2007-10-16 @350 return MIGRATE_UN= MOVABLE; 467c996c1e1910 Mel Gorman 2007-10-16 351 = 467c996c1e1910 Mel Gorman 2007-10-16 352 /* Group based on = mobility */ 016c13daa5c9e4 Mel Gorman 2015-11-06 353 return (gfp_flags = & GFP_MOVABLE_MASK) >> GFP_MOVABLE_SHIFT; 467c996c1e1910 Mel Gorman 2007-10-16 354 } dd56b046426760 Mel Gorman 2015-11-06 355 #undef GFP_MOVABLE_= MASK dd56b046426760 Mel Gorman 2015-11-06 356 #undef GFP_MOVABLE_= SHIFT a2f1b424900715 Andi Kleen 2005-11-05 357 = d0164adc89f6bb Mel Gorman 2015-11-06 358 static inline bool = gfpflags_allow_blocking(const gfp_t gfp_flags) d0164adc89f6bb Mel Gorman 2015-11-06 359 { 543dfb2df8ebb3 Joshua Clayton 2016-01-14 360 return !!(gfp_flag= s & __GFP_DIRECT_RECLAIM); d0164adc89f6bb Mel Gorman 2015-11-06 361 } d0164adc89f6bb Mel Gorman 2015-11-06 362 = 20eb4f29b60286 Tejun Heo 2019-10-24 363 /** 20eb4f29b60286 Tejun Heo 2019-10-24 364 * gfpflags_normal_= context - is gfp_flags a normal sleepable context? 20eb4f29b60286 Tejun Heo 2019-10-24 365 * @gfp_flags: gfp_= flags to test 20eb4f29b60286 Tejun Heo 2019-10-24 366 * 20eb4f29b60286 Tejun Heo 2019-10-24 367 * Test whether @gf= p_flags indicates that the allocation is from the 20eb4f29b60286 Tejun Heo 2019-10-24 368 * %current context= and allowed to sleep. 20eb4f29b60286 Tejun Heo 2019-10-24 369 * 20eb4f29b60286 Tejun Heo 2019-10-24 370 * An allocation be= ing allowed to block doesn't mean it owns the %current 20eb4f29b60286 Tejun Heo 2019-10-24 371 * context. When d= irect reclaim path tries to allocate memory, the 20eb4f29b60286 Tejun Heo 2019-10-24 372 * allocation conte= xt is nested inside whatever %current was doing at the 20eb4f29b60286 Tejun Heo 2019-10-24 373 * time of the orig= inal allocation. The nested allocation may be allowed 20eb4f29b60286 Tejun Heo 2019-10-24 374 * to block but mod= ifying anything %current owns can corrupt the outer 20eb4f29b60286 Tejun Heo 2019-10-24 375 * context's expect= ations. 20eb4f29b60286 Tejun Heo 2019-10-24 376 * 20eb4f29b60286 Tejun Heo 2019-10-24 377 * %true result fro= m this function indicates that the allocation context 20eb4f29b60286 Tejun Heo 2019-10-24 378 * can sleep and us= e anything that's associated with %current. 20eb4f29b60286 Tejun Heo 2019-10-24 379 */ 20eb4f29b60286 Tejun Heo 2019-10-24 380 static inline bool = gfpflags_normal_context(const gfp_t gfp_flags) 20eb4f29b60286 Tejun Heo 2019-10-24 381 { 20eb4f29b60286 Tejun Heo 2019-10-24 382 return (gfp_flags = & (__GFP_DIRECT_RECLAIM | __GFP_MEMALLOC)) =3D=3D 20eb4f29b60286 Tejun Heo 2019-10-24 383 __GFP_DIRECT_RECL= AIM; 20eb4f29b60286 Tejun Heo 2019-10-24 384 } 20eb4f29b60286 Tejun Heo 2019-10-24 385 = b70d94ee438b3f Christoph Lameter 2009-06-16 386 #ifdef CONFIG_HIGHM= EM b70d94ee438b3f Christoph Lameter 2009-06-16 387 #define OPT_ZONE_HI= GHMEM ZONE_HIGHMEM b70d94ee438b3f Christoph Lameter 2009-06-16 388 #else b70d94ee438b3f Christoph Lameter 2009-06-16 389 #define OPT_ZONE_HI= GHMEM ZONE_NORMAL b70d94ee438b3f Christoph Lameter 2009-06-16 390 #endif b70d94ee438b3f Christoph Lameter 2009-06-16 391 = 4b51d66989218a Christoph Lameter 2007-02-10 392 #ifdef CONFIG_ZONE_= DMA b70d94ee438b3f Christoph Lameter 2009-06-16 393 #define OPT_ZONE_DM= A ZONE_DMA b70d94ee438b3f Christoph Lameter 2009-06-16 394 #else b70d94ee438b3f Christoph Lameter 2009-06-16 395 #define OPT_ZONE_DM= A ZONE_NORMAL 4b51d66989218a Christoph Lameter 2007-02-10 396 #endif b70d94ee438b3f Christoph Lameter 2009-06-16 397 = 4e4785bcf0c850 Christoph Lameter 2006-09-25 398 #ifdef CONFIG_ZONE_= DMA32 b70d94ee438b3f Christoph Lameter 2009-06-16 399 #define OPT_ZONE_DM= A32 ZONE_DMA32 b70d94ee438b3f Christoph Lameter 2009-06-16 400 #else b70d94ee438b3f Christoph Lameter 2009-06-16 401 #define OPT_ZONE_DM= A32 ZONE_NORMAL 4e4785bcf0c850 Christoph Lameter 2006-09-25 402 #endif b70d94ee438b3f Christoph Lameter 2009-06-16 403 = b70d94ee438b3f Christoph Lameter 2009-06-16 404 /* b70d94ee438b3f Christoph Lameter 2009-06-16 405 * GFP_ZONE_TABLE i= s a word size bitstring that is used for looking up the ac2e8e40acf4c7 Hao Lee 2017-05-03 406 * zone to use give= n the lowest 4 bits of gfp_t. Entries are GFP_ZONES_SHIFT ac2e8e40acf4c7 Hao Lee 2017-05-03 407 * bits long and th= ere are 16 of them to cover all possible combinations of 263ff5d8e82e57 matt mooney 2010-05-24 408 * __GFP_DMA, __GFP= _DMA32, __GFP_MOVABLE and __GFP_HIGHMEM. b70d94ee438b3f Christoph Lameter 2009-06-16 409 * b70d94ee438b3f Christoph Lameter 2009-06-16 410 * The zone fallbac= k order is MOVABLE=3D>HIGHMEM=3D>NORMAL=3D>DMA32=3D>DMA. b70d94ee438b3f Christoph Lameter 2009-06-16 411 * But GFP_MOVABLE = is not only a zone specifier but also an allocation b70d94ee438b3f Christoph Lameter 2009-06-16 412 * policy. Therefor= e __GFP_MOVABLE plus another zone selector is valid. 263ff5d8e82e57 matt mooney 2010-05-24 413 * Only 1 bit of th= e lowest 3 bits (DMA,DMA32,HIGHMEM) can be set to "1". b70d94ee438b3f Christoph Lameter 2009-06-16 414 * b70d94ee438b3f Christoph Lameter 2009-06-16 415 * bit = result b70d94ee438b3f Christoph Lameter 2009-06-16 416 * =3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D b70d94ee438b3f Christoph Lameter 2009-06-16 417 * 0x0 =3D= > NORMAL b70d94ee438b3f Christoph Lameter 2009-06-16 418 * 0x1 =3D= > DMA or NORMAL b70d94ee438b3f Christoph Lameter 2009-06-16 419 * 0x2 =3D= > HIGHMEM or NORMAL b70d94ee438b3f Christoph Lameter 2009-06-16 420 * 0x3 =3D= > BAD (DMA+HIGHMEM) 4b33b6959581d5 Huaisheng Ye 2018-06-07 421 * 0x4 =3D= > DMA32 or NORMAL b70d94ee438b3f Christoph Lameter 2009-06-16 422 * 0x5 =3D= > BAD (DMA+DMA32) b70d94ee438b3f Christoph Lameter 2009-06-16 423 * 0x6 =3D= > BAD (HIGHMEM+DMA32) b70d94ee438b3f Christoph Lameter 2009-06-16 424 * 0x7 =3D= > BAD (HIGHMEM+DMA32+DMA) b70d94ee438b3f Christoph Lameter 2009-06-16 425 * 0x8 =3D= > NORMAL (MOVABLE+0) b70d94ee438b3f Christoph Lameter 2009-06-16 426 * 0x9 =3D= > DMA or NORMAL (MOVABLE+DMA) b70d94ee438b3f Christoph Lameter 2009-06-16 427 * 0xa =3D= > MOVABLE (Movable is valid only if HIGHMEM is set too) b70d94ee438b3f Christoph Lameter 2009-06-16 428 * 0xb =3D= > BAD (MOVABLE+HIGHMEM+DMA) 4b33b6959581d5 Huaisheng Ye 2018-06-07 429 * 0xc =3D= > DMA32 or NORMAL (MOVABLE+DMA32) b70d94ee438b3f Christoph Lameter 2009-06-16 430 * 0xd =3D= > BAD (MOVABLE+DMA32+DMA) b70d94ee438b3f Christoph Lameter 2009-06-16 431 * 0xe =3D= > BAD (MOVABLE+DMA32+HIGHMEM) b70d94ee438b3f Christoph Lameter 2009-06-16 432 * 0xf =3D= > BAD (MOVABLE+DMA32+HIGHMEM+DMA) b70d94ee438b3f Christoph Lameter 2009-06-16 433 * b11a7b94100cba Dan Williams 2016-03-17 434 * GFP_ZONES_SHIFT = must be <=3D 2 on 32 bit platforms. b70d94ee438b3f Christoph Lameter 2009-06-16 435 */ b70d94ee438b3f Christoph Lameter 2009-06-16 436 = b11a7b94100cba Dan Williams 2016-03-17 437 #if defined(CONFIG_= ZONE_DEVICE) && (MAX_NR_ZONES-1) <=3D 4 b11a7b94100cba Dan Williams 2016-03-17 438 /* ZONE_DEVICE is n= ot a valid GFP zone specifier */ b11a7b94100cba Dan Williams 2016-03-17 439 #define GFP_ZONES_S= HIFT 2 b11a7b94100cba Dan Williams 2016-03-17 440 #else b11a7b94100cba Dan Williams 2016-03-17 @441 #define GFP_ZONES_S= HIFT ZONES_SHIFT b11a7b94100cba Dan Williams 2016-03-17 442 #endif b11a7b94100cba Dan Williams 2016-03-17 443 = b11a7b94100cba Dan Williams 2016-03-17 444 #if 16 * GFP_ZONES_= SHIFT > BITS_PER_LONG b11a7b94100cba Dan Williams 2016-03-17 445 #error GFP_ZONES_SH= IFT too large to create GFP_ZONE_TABLE integer b70d94ee438b3f Christoph Lameter 2009-06-16 446 #endif b70d94ee438b3f Christoph Lameter 2009-06-16 447 = b70d94ee438b3f Christoph Lameter 2009-06-16 448 #define GFP_ZONE_TA= BLE ( \ b11a7b94100cba Dan Williams 2016-03-17 449 (ZONE_NORMAL << 0 = * GFP_ZONES_SHIFT) \ b11a7b94100cba Dan Williams 2016-03-17 450 | (OPT_ZONE_DMA <<= ___GFP_DMA * GFP_ZONES_SHIFT) \ b11a7b94100cba Dan Williams 2016-03-17 451 | (OPT_ZONE_HIGHME= M << ___GFP_HIGHMEM * GFP_ZONES_SHIFT) \ b11a7b94100cba Dan Williams 2016-03-17 452 | (OPT_ZONE_DMA32 = << ___GFP_DMA32 * GFP_ZONES_SHIFT) \ b11a7b94100cba Dan Williams 2016-03-17 453 | (ZONE_NORMAL << = ___GFP_MOVABLE * GFP_ZONES_SHIFT) \ b11a7b94100cba Dan Williams 2016-03-17 454 | (OPT_ZONE_DMA <<= (___GFP_MOVABLE | ___GFP_DMA) * GFP_ZONES_SHIFT) \ b11a7b94100cba Dan Williams 2016-03-17 455 | (ZONE_MOVABLE <<= (___GFP_MOVABLE | ___GFP_HIGHMEM) * GFP_ZONES_SHIFT)\ b11a7b94100cba Dan Williams 2016-03-17 456 | (OPT_ZONE_DMA32 = << (___GFP_MOVABLE | ___GFP_DMA32) * GFP_ZONES_SHIFT)\ b70d94ee438b3f Christoph Lameter 2009-06-16 457 ) b70d94ee438b3f Christoph Lameter 2009-06-16 458 = b70d94ee438b3f Christoph Lameter 2009-06-16 459 /* 263ff5d8e82e57 matt mooney 2010-05-24 460 * GFP_ZONE_BAD is = a bitmap for all combinations of __GFP_DMA, __GFP_DMA32 b70d94ee438b3f Christoph Lameter 2009-06-16 461 * __GFP_HIGHMEM an= d __GFP_MOVABLE that are not permitted. One flag per b70d94ee438b3f Christoph Lameter 2009-06-16 462 * entry starting w= ith bit 0. Bit is set if the combination is not b70d94ee438b3f Christoph Lameter 2009-06-16 463 * allowed. b70d94ee438b3f Christoph Lameter 2009-06-16 464 */ b70d94ee438b3f Christoph Lameter 2009-06-16 465 #define GFP_ZONE_BA= D ( \ 16b56cf4b8a0fa Namhyung Kim 2010-10-26 466 1 << (___GFP_DMA |= ___GFP_HIGHMEM) \ 16b56cf4b8a0fa Namhyung Kim 2010-10-26 467 | 1 << (___GFP_DMA= | ___GFP_DMA32) \ 16b56cf4b8a0fa Namhyung Kim 2010-10-26 468 | 1 << (___GFP_DMA= 32 | ___GFP_HIGHMEM) \ 16b56cf4b8a0fa Namhyung Kim 2010-10-26 469 | 1 << (___GFP_DMA= | ___GFP_DMA32 | ___GFP_HIGHMEM) \ 16b56cf4b8a0fa Namhyung Kim 2010-10-26 470 | 1 << (___GFP_MOV= ABLE | ___GFP_HIGHMEM | ___GFP_DMA) \ 16b56cf4b8a0fa Namhyung Kim 2010-10-26 471 | 1 << (___GFP_MOV= ABLE | ___GFP_DMA32 | ___GFP_DMA) \ 16b56cf4b8a0fa Namhyung Kim 2010-10-26 472 | 1 << (___GFP_MOV= ABLE | ___GFP_DMA32 | ___GFP_HIGHMEM) \ 16b56cf4b8a0fa Namhyung Kim 2010-10-26 473 | 1 << (___GFP_MOV= ABLE | ___GFP_DMA32 | ___GFP_DMA | ___GFP_HIGHMEM) \ b70d94ee438b3f Christoph Lameter 2009-06-16 474 ) b70d94ee438b3f Christoph Lameter 2009-06-16 475 = b70d94ee438b3f Christoph Lameter 2009-06-16 476 static inline enum = zone_type gfp_zone(gfp_t flags) b70d94ee438b3f Christoph Lameter 2009-06-16 477 { b70d94ee438b3f Christoph Lameter 2009-06-16 478 enum zone_type z; 16b56cf4b8a0fa Namhyung Kim 2010-10-26 479 int bit =3D (__for= ce int) (flags & GFP_ZONEMASK); b70d94ee438b3f Christoph Lameter 2009-06-16 480 = b11a7b94100cba Dan Williams 2016-03-17 481 z =3D (GFP_ZONE_TA= BLE >> (bit * GFP_ZONES_SHIFT)) & b11a7b94100cba Dan Williams 2016-03-17 482 ((1 << GFP_ZO= NES_SHIFT) - 1); 82d4b5779a7588 Dave Hansen 2011-05-24 483 VM_BUG_ON((GFP_ZON= E_BAD >> bit) & 1); b70d94ee438b3f Christoph Lameter 2009-06-16 484 return z; 4e4785bcf0c850 Christoph Lameter 2006-09-25 485 } 4e4785bcf0c850 Christoph Lameter 2006-09-25 486 = ^1da177e4c3f41 Linus Torvalds 2005-04-16 487 /* ^1da177e4c3f41 Linus Torvalds 2005-04-16 488 * There is only on= e page-allocator function, and two main namespaces to ^1da177e4c3f41 Linus Torvalds 2005-04-16 489 * it. The alloc_pa= ge*() variants return 'struct page *' and as such ^1da177e4c3f41 Linus Torvalds 2005-04-16 490 * can allocate hig= hmem pages, the *get*page*() variants return ^1da177e4c3f41 Linus Torvalds 2005-04-16 491 * virtual kernel a= ddresses to the allocated page(s). ^1da177e4c3f41 Linus Torvalds 2005-04-16 492 */ ^1da177e4c3f41 Linus Torvalds 2005-04-16 493 = 54a6eb5c4765aa Mel Gorman 2008-04-28 494 static inline int g= fp_zonelist(gfp_t flags) 54a6eb5c4765aa Mel Gorman 2008-04-28 495 { c00eb15a8914b8 Yaowei Bai 2016-01-14 496 #ifdef CONFIG_NUMA c00eb15a8914b8 Yaowei Bai 2016-01-14 497 if (unlikely(flags= & __GFP_THISNODE)) c00eb15a8914b8 Yaowei Bai 2016-01-14 498 return ZONELIST_N= OFALLBACK; c00eb15a8914b8 Yaowei Bai 2016-01-14 499 #endif c00eb15a8914b8 Yaowei Bai 2016-01-14 @500 return ZONELIST_FA= LLBACK; 54a6eb5c4765aa Mel Gorman 2008-04-28 501 } 54a6eb5c4765aa Mel Gorman 2008-04-28 502 = ^1da177e4c3f41 Linus Torvalds 2005-04-16 503 /* ^1da177e4c3f41 Linus Torvalds 2005-04-16 504 * We get the zone = list from the current node and the gfp_mask. cb152a1a95606a Shijie Luo 2021-05-06 505 * This zone list c= ontains a maximum of MAX_NUMNODES*MAX_NR_ZONES zones. 54a6eb5c4765aa Mel Gorman 2008-04-28 506 * There are two zo= nelists per node, one for all zones with memory and 54a6eb5c4765aa Mel Gorman 2008-04-28 507 * one containing j= ust zones from the node the zonelist belongs to. ^1da177e4c3f41 Linus Torvalds 2005-04-16 508 * d3c251ab95b69f Mike Rapoport 2021-06-28 509 * For the case of = non-NUMA systems the NODE_DATA() gets optimized to d3c251ab95b69f Mike Rapoport 2021-06-28 510 * &contig_page_dat= a at compile-time. ^1da177e4c3f41 Linus Torvalds 2005-04-16 511 */ 0e88460da6ab7b Mel Gorman 2008-04-28 512 static inline struc= t zonelist *node_zonelist(int nid, gfp_t flags) 0e88460da6ab7b Mel Gorman 2008-04-28 513 { 54a6eb5c4765aa Mel Gorman 2008-04-28 @514 return NODE_DATA(n= id)->node_zonelists + gfp_zonelist(flags); 0e88460da6ab7b Mel Gorman 2008-04-28 515 } ^1da177e4c3f41 Linus Torvalds 2005-04-16 516 = ^1da177e4c3f41 Linus Torvalds 2005-04-16 517 #ifndef HAVE_ARCH_F= REE_PAGE ^1da177e4c3f41 Linus Torvalds 2005-04-16 518 static inline void = arch_free_page(struct page *page, int order) { } ^1da177e4c3f41 Linus Torvalds 2005-04-16 519 #endif cc102509074bba Nicholas Piggin 2006-12-06 520 #ifndef HAVE_ARCH_A= LLOC_PAGE cc102509074bba Nicholas Piggin 2006-12-06 521 static inline void = arch_alloc_page(struct page *page, int order) { } cc102509074bba Nicholas Piggin 2006-12-06 522 #endif ^1da177e4c3f41 Linus Torvalds 2005-04-16 523 = 84172f4bb75242 Matthew Wilcox (Oracle 2021-04-29 524) struct page *__allo= c_pages(gfp_t gfp, unsigned int order, int preferred_nid, 04ec6264f28793 Vlastimil Babka 2017-07-06 @525 nodemask_t *nodem= ask); da90006b76b648 Andrew Morton 2021-09-16 526 struct folio *__fol= io_alloc(gfp_t gfp, unsigned int order, int preferred_nid, da90006b76b648 Andrew Morton 2021-09-16 527 nodemask_t *nodem= ask); e4048e5dc4aece KOSAKI Motohiro 2008-07-23 528 = 387ba26fb1cb9b Mel Gorman 2021-04-29 529 unsigned long __all= oc_pages_bulk(gfp_t gfp, int preferred_nid, 387ba26fb1cb9b Mel Gorman 2021-04-29 530 nodemask_t *nod= emask, int nr_pages, 0f87d9d30f2139 Mel Gorman 2021-04-29 531 struct list_hea= d *page_list, 0f87d9d30f2139 Mel Gorman 2021-04-29 532 struct page **p= age_array); 387ba26fb1cb9b Mel Gorman 2021-04-29 533 = 387ba26fb1cb9b Mel Gorman 2021-04-29 534 /* Bulk allocate or= der-0 pages */ 387ba26fb1cb9b Mel Gorman 2021-04-29 535 static inline unsig= ned long 0f87d9d30f2139 Mel Gorman 2021-04-29 536 alloc_pages_bulk_li= st(gfp_t gfp, unsigned long nr_pages, struct list_head *list) 387ba26fb1cb9b Mel Gorman 2021-04-29 537 { 0f87d9d30f2139 Mel Gorman 2021-04-29 @538 return __alloc_pag= es_bulk(gfp, numa_mem_id(), NULL, nr_pages, list, NULL); 0f87d9d30f2139 Mel Gorman 2021-04-29 539 } 0f87d9d30f2139 Mel Gorman 2021-04-29 540 = --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============8077519654652772254== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICIhOR2EAAy5jb25maWcAjDxLc+M2k/f8CtbMJTlM4seMkuyWDyAJiohIggZA+XFhaWTNxBXb mpLlbPLvtxvgAwBBZbbq24y6Gw2gu9EvgH7/w/uIvB33z5vj43bz9PRv9HX3sjtsjruH6Mvj0+5/ o5RHFVcRTZn6GYiLx5e3f37ZHLbRp5/PP/189uGwPf/w/HwerXaHl91TlOxfvjx+fQMOj/uXH97/ kPAqY8s2Sdo1FZLxqlX0Vl29Aw4fdk9fPnzdbqMfl0nyU3R+/vPFz2fvrBFMtoC5+rcHLUcuV+fn ZxdnZwNxQarlgBvARGoeVTPyAFBPdnH568ihSJE0ztKRFEBhUgtxZi03B95Elu2SKz5y8RAtb1Td qCCeVQWr6ARV8bYWPGMFbbOqJUqJkYSJ6/aGi9UIiRtWpIqVtFUkhiGSC5wNVPE+WmrdPkWvu+Pb t1E5seArWrWgG1nWFu+KqZZW65YI2DQrmbq6vBjWxssaV6SoRPbvow5+Q4XgInp8jV72R5xokBpP SNGL7d07Z7mtJIWygDlZ03ZFRUWLdnnPrDXZmOK+JCPGJR/WY9EGFpXSjDSF0lu15u/BOZeqIiW9 evfjy/5l99NAIG+IM4u8k2tWJ4EZai7ZbVteN7SxNGtDcXCiihF5Q1SSt/2IYY5EcCnbkpZc3KEV kCQPzNdIWrDYsvcGDm6vf7CW6PXt8+u/r8fd86j/Ja2oYIk2JpnzG+vEWZgktxWBkJSXhFUuTLIy RNTmjAoikvzOxWZEKsrZiAYNV2kBZmLrHCE9IxhlS8VeYUrjZplJWyrvo93LQ7T/4m3d318C1rmi a1op2ctKPT7vDq8hceX3bQ2jeMoSeyVwTAHDYKkBtWikTZ2zZd4KKls8qiK85skShkNTZ/0y4Z+h NQJY2xUpCntWBDdVLdh6sHGeZcHJXcYji1pQWtYKdlSFNtqj17xoKkXEnT19hzwxLOEwqt9bUje/ qM3rX9ERBBFtYF2vx83xNdpst/u3l+Pjy9dxw4olqxYGtCTRPFi1tHyiTNGFJhQOEODVPKZdX9oL VkSupCLK00+/aMmCovuOdVvHGtbMJC+IAsdos9MiEEkTyal6YXt3LeDstcLPlt6CZYbkKw2xPdwD 4U41j+5MBFATUJPSEFwJktBheZ1Q3J0MPmBl/mF5hdVgEjyxwTklqeMXCo7hA+w8Z5m6Ov91tCVW qRXElIz6NJe2LWoqVqX0NiCw3jPIJKep8Q+9Wcrtn7uHt6fdIfqy2xzfDrtXDe72GcAOMXMpeFNL W2ngzpNlYPq4WHXkVjqgf5sVjdCMMNG6mNG2MkhpwHvesFTlQRMWyh4bJOmmrVkqAwvtsCLVsdgf lMGxvqfiFN+UrlkS8iQdHs6He2T79VCRBWZEt3VitpLJ5PRqIISE/DdkAbIGs7bsr1GQmznahBQA IOGoLAxtb30sdX5XVHm8QB/JquZgpBgmFBchGRnrJI3inq2A7wfdpxT8akKUbS8+pl1fjEhBC+J4 bLRD0JBOkETYPmLO0W/jv8OSTVpeQ5Rj95C/cqEVx0VJqrDW56lb7vhmn1LCP0Ii6rOrYeCskywh HjJUlS+tMZL2h87kJH5CZ2K5BdU+xs7NLUdHiwzEJiwmMZGwlcaZqIFyyfsJxuMlxAaclPVtktsz 1NzmJdmyIoVd4ej12gCdAtkAmYOHsrJJZlU2jLeNcOIsSddM0l5cliCASUyEYLZoV0hyV8oppHVk PUC1eNBCFVtbUkOF6VTGXvcqKZ0EHeanaep6OFuCaGbtkAD26kMgsG/XJaxBRyPt6btSt94dvuwP z5uX7S6if+9eIMITiAEJxnjI28ZoHWSuPU1oiiGSfOc0PcN1aeYwOZSxw/GwQLlGFFR6q9ARKUjs VDNFE8+QgSbFkvbJozsIsOjvCybBZcH54GXQH7iEOREphNqwa5F5k2WQ+tcE5tTyISpYXILFKVq2 KVEES3OWsUTnU/ZRxArasVadpmgPK22xu0XyYNrCSkYwGwAP2sqmrk157fhjDqUy7BBCRqvZ21Y/ VByysc8VlD5tBpYNBwVKbizcrcNTWhkWFBKM46RtSeoAWwLVnwC/DioyrtwjyG8oVB72kqGQXJmM bdyONnNYVEQO2z8fj7stJjKT3s5AVT9tjmijv8h98ku83xweRuMHfFvDzloVn5/d2hYzYMitBFTQ ApBGcli2TFfBXHtmeismS4Jc0P6TkNPv8DoKDhuCpGOuk4Urwpw9l476WtVUtC0Bg30EJ7uP0f9U KSNV2MjLOrAsZFkmbi9DTw1lP50VFbaLWJKED15PkHoE9oxl064/TpSExw/Da/vbapbzSHS+CDkZ l+ajFRXrpelUFeC+IGhc2CMykJ9EB93lQP7ScD8QHkKdlx6NvZrJOHS5DURDCIlwYPHUQZIJReBJ wRXF4uNpyUJdLeiccHWbL0kKIFl6xpPKumtzpFOEvf9+rDM1Evnl+ITANMJmloYEGEd1ihtiT5bN SDDDBFsw4J4wG8Ul+2yKOgYBSVT17EmenrvB5bKqucX/v9J5wNXZP7+dmf9zKcDrzhFgy8XNZjql 1IR+PHPBqzVJU5NTXl18WjiHvxEC8mHUhJWG3V+dw0zOhkuqyA0BneW47HnlxKGCAzHYG4VSvU1V 3Jo25DtXXCe885AxcgGevSS37T1YCIdgK67Oz4ejVzrtmXK2/gFUUthnthwiiunLOUZ5cw2B7wZK HppBJGaYlHQZQ5i1x6rlQ3urD8Yba6cfHnbfQAiQCUX7b7hZK9VKBJG5l1ZLqK0yZ31/NGXdQhoS PA86H2TAAQIspg1WrDTdZ4DFVPpQQZWPMFEVjgVE9qWcZgt6oA79mjLnfDUN2BAedFOxVbmgxHUP eXt5ETPdw2uDfMeNOukEgO7vWlXEYMRZ33Lrj5Hi2pnMLLMCDyBQoXmzpOjPPbqSp4ZW1jTBPMya mKdNQaX2vVj8YCpvlfUFTApHN1nBmUktKXapq9kpVixuHmYnvb5S9ELqrGrX4OnTwaYSvv7wefO6 e4j+Min2t8P+y+OT6SeOnWUgC3jNMU88xcZPJv/Dfof6G9I6rOVsK9Jlj8Ty4MpyMJ0wQ1VsJ2YF KTZIiK/svkDcNbKGn6sWvLZOrT3Z9pV/LLUKSjuZtnDOZcPYLVB0KZi6O4Fq1fnZFI1Oymlh9Qiw fq4UJvDhJgSQ3cRqFte1dxj2WWmV3J1suQFZwqVyVzegoKjn0xViMZeF1IFoiUVBTQqXo7nug9Qw EXd1V604XCcEbQaawiMy6RPXm8PxEW0pUv9+6xqSvX8lQjE9Gspz7KOEiuBSplyOpFZHIGMOeLBs f0Z7Z+V1u2YwhrsbBnDXJ7SAdelZZ5vzAqKU27wy11d87K5aPh/YMm4qrxQ8pHuHaiFXd7GuxMbS oEPE2XX4zsiZb/C7sjq3ug9VpyVZQ6RuKrtRTP/Zbd+Om89PO32XHuky/ugoJ2ZVVip0hyHTMUiZ CFY7tXaH8JuZg8MUNG26/ke3lbml6LWUu+f94d+o3Lxsvu6eg3G1q02djg7eQw43F1a4rQtw1LXS uoSETl599AbF6G9cc+/qM+8KZLDgJSa+GDydAr5kS+FNDv9RqKOul9IzyO8g9caETrWLjzFzhQmR I5jTYqCsuIIg5rStpCWF/hKtxFyhZJWe5Orj2e8L6w4pEDRDHWYKlliD3WPJuHLysqSgcG5nC79M wKaxygnZgn3c4IfxVA7zHhj0XojVPVCXC+yGyKvhxuW+5txybvdxY+Up95cZHGjrt7RaXR4MuxFh J65TIG0ImCutvDhgp0SY0WthteZcYgo/pgVlCXrCJwpO4ksFSn3+pm8Jnh9fOpyas1bUJD22n1+h YeinD71TSDfHTUS2293ra1TuXx6P+4OXeKSk5FXQIc2N7fHzB3m0Mius4aUDCBJKS0u9chW39BaC JD7UGG7Dq93x//aHv2A2yzdYISZZ0ZBwwDveOr7yFryZXYFlBsh57JGljNitusLJ3+Fn4N7IQSse OmS3mbBmx1+YOxfczqs1lBRL7oHciwEN0r29zJTMNlw2MRRABUvuPITxWBNysDsmFUukv4rcA1BZ +0uo0XW6Ol3RuwnAmtrqPIXCx21aY8sNFGovZwR6qmGOSbHa3KIkxH0WBPA++2ghj1I01MUForqq vWEAadM8qcNeweDxCuokgSAi5B31AajdJpuBwaEACyub0NWwocCGX0ULb7Wl3ly4z3dXQXjiKxbM 2g3TtWKu5prUmsiCZ7zxFw2gcVlhN4a6AqMKiR4xjnX1EOuAuHwoZjwqCcmVmd24lqmB2mb9DWlM EDg1tRZmDIFRUAGwIDchMIJAv1IJ7lx3InP45/JUqjzQJE1sl7d9LtDjr95t3z4/bt/Z48r0k3Qe O9TrhWtB60V3PvBJTCgp1CTm4hNdBkSL1N3cwrgNR1kL1NaMohZTTeEUJaunS2NF6BWd4TKr2sUU iryMrbv8JQu26BEV5GGOgbNs9D510b1+lNMZmhgL45nzoTnMH2HDgS4XbXFj1jO3Wk2UlyTxlifq Yhg7lS4n5UnWIEy/mVODWXnGrWGe1RtYZ24jN3w6CmuFlE4/IbX9iUZB4qzbAhChyjqccwFpxgrl VlYDMHiQTOqwP+wwrYBy5Lg7zN22jIwmicqIQrGwyt+Ai8SXQKHV4x18Vemc0mKd6YdDkPjCfxzw QByUmo3H50v+W8QQnVZoMCLYVJmqZ9bB7ItJBxMLcNtdIA7hQTIxlMDuOxRni8ybVFmiHsEVUf7v yXoR5q8UYf4UCIPqlUHlP2VaEnndUEFS6kndnPVTxtneDv5AW9+troVfo+3++fPjy+4het5jmf8a srxbnFms/KHHzeHr7jg3QhGxpPpdTDVayglC19BsAle8gaEAK4mfw0ypspkTEKANaCBANaOOAGUn gfBhCNCDryrduzhH8s+b4/ZPt8nlaQsfUGMpru7qcK09oba9wCmuJq3/Pp6Y11O7C3PS5zl5pAyW U4BYW4dV//ScuoH1Vb4DhBPQxgyy+vOLrp9Wr2V0PGxeXr/tD0dsXx/32/1T9LTfPESfN0+bly0W fK9v3xA/Grphh1cjvDXhx176gIKUbG4PHQXJvZzTws0ivOzGwsjErQLGTb72bTx/E0L4k9wIMeVf hB8NdiOKUBllcBn3+fN15oOKuEhCsMna0sDWZfhhp0GWwVzfjLOvmg2oup6yhzxgehC1TGHiWbHK fLS236wx5YkxpRmjH+S6Jrr59u3pcatPSfTn7unbdKwTbrrNZMn43UP9P9+RamSYwguik7GPXoQx ta/GhEM1Xv7d3vVDLZZNHeKH6cVMTWqQE0aC/gEe2YPDVgHF6iG4OfAhL3Ogg4//w/HwBukEG4fe 8fYOQUmqZTGBQuVlu75TKuh09Pfi+7Q06mLhSGhUwSKkgoWnglGgi5NqcJzrYk7eCyMJdPs4xjxW d4/TYtRJ8FQuwsJcBKV5SlhBi3ZlYmeJLF06ETyuTywSXw/5BQeC+nrD9DgBECUJS1/n1NgxapHo IhCuBuTlDHhujMrwqYl9KelgxvZ331KdW+q4ke4dZr7Z/uV8ctIzDvP0RlmDMEyNy8Nf+Aak5fEf SeU+qdSorq1gWke6psQ2QrjFNDdA5uQ8+Hx8hr57AOAy/u4VfMfM2m7M9E6dam7+x88TUqmvDAMc EOUlHwiae8CiWO3cOODvtoQ8l8zkKZpAX7xaIVwD3RUTVTo/2qSwa5oeoh9uJqWHKYh9V4mQsubE hcTiYvHbxxAMjMl38cWFbVv4q7/csTev4evLkEXYw5cQoRzHoF1FYNQa9tH+dnZxfj0OHmHtcu3y sVDlOhgEU5qYtvJ4KaIh873jwk6h4MeFPZgoUoTeJN5efHLEQuo4aNV1DuchlJAvCn5TE+v+sQNY QvcQVe6YoQXW/cj5OTQJOvOSul7Cxuc8JE2bwo0ENqbkMSvMm40gbxR9uAVkU8FhmrJfAoJCWZSn ApcYJjAjJ1MjCg9OMEqHJki9L5JDNCjH72SnLc4J5JRSNN5PwUxQu7V8fLNw/bZ720EA+KV7SeDd 9XX0bRJfz3Nrc2XFswGYSff70w4O/uEEK//1Sg/XfdProPX3JGLmlX6Pl1noq4ERez3dg6LXRQAa Z6ElJvHcxQliofwOcCLdfj34UtjVTw9NZaAPqjHw3+Cz3mGk8NufRqjXOP1poa3i/6RJcr6aaWNo /HV2HZQXT+e6yBqfXRuSqSASsqJTaEiBeR6Qes2Co8PwumiWUyhVMrSlwCtSc5qeNq+vj1+6ItFp yUH09b6zAwA+qmOT04MIlUy+CJ3QaJcwd/qRILuZzthcWt/ZdYD+I0YPOukWmlnlenJR2cMXJ9eb gVs7SWDetp3YkPngPMB20vbXGF0HkWLO+KjGuwzp0DJLVvhnJhyeHTIpw5e8FkkV383c3VhEIOOT K9Mvt/19dSj86yX/xZ/V8yQonvCHKMNBYXbTKE0s159WEj8E4Ph3NEZoDB6f6Nd9TrI2QPt/rkNP zCyqgsyMT0lovRZBlcyMLPH64fRYr46zMFifOu+9eE2rtbxhxnjGdLJ7mDAnc339g0l76I1X7XsH hLRLaalAQ7rsx4OCpgOX85W0jDuXwnNvegMpXfsWVlxik0Xpp48hXV0L+y+/4K9WlqkHgfV4kDL3 3hRUiXRuXvF3yynUKWXamlZPuN3pEK4orfF+MEjZPZbF2Wajm0WTFERKFrps1zn/bRs38q51v2aN r4cnVd3jpOi4ez0G8qt6pZY0/O2V7l4IXkPyWzHv08KhnJ+w9xD2o6iRdU5KQdK5vZPQO8fYfnKM H2vSVDgQkeFLbOes9cBWqeCjZmBT0drlCwA4me302rZHmnb6tAtkE+YsWDYjRno8g38RRcNTn7SU me9hRyThssY/HmVvJlDdxnjhVGT+ez0bn1GiGv3Ex+sWmL+p8vS2O+73xz+jh93fj9td9HB4/Nt5 chwr/farcOVqv2xDxSgXnycsVo2MvbX2YPPhVANbrEInwab0ZxoQpfO1uYUIrkWm3kt2DW9I8OP4 blBSXpxd3ga2UBPvG04XnZmNO8A1/M+BlWJdTABtt0zLDlR+6e4T9h3YzDUcDPCQ4UUND9THv3gz p3arkZCBNxLBP/QEqJWtFqkEJSW+nZfuISu9W6oOnDHQUuN0lW+YoIV58zB6jmyJxef5xGgHxMtu 9/AaHffR5x3sDG9MH/C5dwReXRNYD+c7CGZd+IQ119+J6Qezw0dzIlsx2+2a3/3RdYGsMn/ZbGzI GfiyPlHg/B58tkyYnRfDLz9P0DAYb+KoDXQMLaF17raDewi+rwKf6bPtsfiRUjjdqjLnGQP2A5dM Eec5D4KrhIU3DbjcxXVRbHOIssfdE37b//z89tJfef0II37qbNJ+bgB8lMh+/f3XM+IuyPkbXAjA l/PnZ2cesPp0eRkAuQIcwezC27dUv3/KM/sEfecWrMaaJJBHzdW2LLO/9Qq8muph/l996dNlqcxL cKulKTjouPCTPswgIfZYhpARVvC1e3KpyhXnRZ9TTjSYGreR+tGiThIinAeUdVImjEwY1MmH7ebw EH0+PD581boeP4J83HaMI/7/nD1Zk9s4zn/FtQ9bM1WbjSTfD/NAHbaZ1hVRttV5UfUkPZuu6RzV 3bMz8/36jyAlmSBBd2ofchiASIoCQQAEQDs5gx07nnMGmRVHsz6Nzow7ZHlt8i8CS/nUHlDlu1Nb 1KbjcoRIFQnlCUqZUaYsR5mCckmptne8KVTmq6ruN6ppu4enL3/ePd2r+ALzDHd37iHC1BzkBFIx /ynUcLogpQ7QsKkTY/SXp1TBHfvNSfSUU0XRQVxkM0rggcnt15ikNVNpricz/2b8QLk0lT04HxQS ytKGI9EzQLNTkwkbCurO8ADkoFdmiRSooIBYo8n2qHyE/o2X+AATOS+IZyHfiYAVLvAcOqCiMHf0 sfPmvdug5LkUtkE/pi9i9zk+NwNzIYflIDlFsdEOr2lA7jKoLqRycEkDwLP+tK74x7MrmtmQGwAR 91XT55bKHva+gwaF6+h9o6i6NqM12gMXUgDIH31eeyJVQFvteVcvuq7P6M5BXZI4HpFYualAWG1d ACdRlvSBYx4bAO7xqDll075bSTmetFVjChPJtXbVnH1phoAW7SRcLumI3++enrX4vUxdC0nJa5XI SLsJgELqtqu5nB6HyqCRlq/KKlI0aCB9tbsGhdYX22CDNEETDzuKuBV0/TCg1JpkzwspEFu2txsa 0G1DKeFAAEugFvk0SPS0XByqjte1d9fqdFYYLTi5oOPkq9k/yv/OCh1YqWoWtRBr9qhVgvzub5zF CV8gv5HCzRmcSgv1DEqnjDbV5Av49nI/e/l89zJ7+Dp7/vblfvbx7ll2f4z57NfHbx9/h3a+P93/ dv/0dP/p3zNxfz+DdiRet/VvY18yjaZy11oqXpv3zZkYFrdJm10KbVHHrWKXIt+ZKGxKzC1V7fs6 dknagSd04i7UOFGuJUflaFjxtqmKt7vHu+fPs4+fH7671q5i/B3HjP0uS7NEVTzA8H1W9gRYPq+c epVKZHY+MaDLyk5idEhiqVLcQp4dne04kuUGmTuMfVYVWYsrkwIONo6YlTe9KpfYU2ELBFn0SjPU OQFBtsHjtMeyuoo2jxbGt+QhNcce4T6h6fo2E3rj50xPAtb0KGxAtGdnYo9CKuwpNWqpa1IhICP6 2PIcT4DkagtQWQAWi/EcfSxQ6l8JOkv67vt3cPUNQGVTK6o7lZBpLZcKdssOPhTkTVibAuQjFzZr DsCh3gWNkxPRtJfSNhRJnhlVyU0E8Itil18iS0oMBBVdOdMkAUteBVb7hFCyjIIktd5M2ksKgaGt WC6VTYp7yplUxApSD3vtC+jqrFBV/uO3ry93Kq5ftun14kF/UDJulzPTY4/A/bnhUpKoonK3Ppqq td64SA51NL+Jlva6lfDFJl8trLkQdcbAm2/JWCHaaGmxtsgd5q4PDkj+sWFQGamtWpZrD49KUsfY rFGlRgAbRhtnl40MdSt9eP79TfX1TQLT77N71SRVyd7wMsQ61F6aKsUv4cKFtr8sLt/79U+pt3xp iOJOAWIVAVIyqswAQwKHL6w/N03hFEY2kYIV4lg6WtmIrkifn0kRdbBt7l3Jxc79MGq9Yd/9+VZq WXePj/eP6tVnv2mBJefp6dvjI6H6qvbTDMqd9alPAisi+RJQOLBl1gJWryAFgLPZTRj4hl7xoWdI 659Xu2+LLCe6LlhzynIKI3IoLJbMo66jnkNYd0hxkxRqCq+MCfT2ddeVhJDQL9+VzFFnFGYnlW2+ o3zFE8lptwoD7FG8DL6joALqRFoFbS/fmJ24z+04EbVdty3THZn7bYy9SMguJJNj+9QmAFt0GSzI h8GCuPasPr5wnys6Tpu1l5cCW/sV/muLedTL96YO/y9dZcKsJzLBYecjxwYbFlQovtZowlJwMRDN MilyWUk2rE32fF84Onvx8PyREHjwF3L9XviCi5uqxBc4EEitt08pmz9Gmyr/WPA6KZTfo7n2QhnH rRLAPvWi5kgWZkki94r/yN3BTVKams8Sah1JqDQP4JS24K7YJkjsagleekcQjiV4iMFOjnPYwtQr 5TVoV//U/0azOilmX3RVD1J9UWT49d5L+7OaTLCpi9cbxq+k5postjuYy7hXsJ/PuSpSJ6CAk61f aAM7i4eLZKLAxsFNII5ODIh9fsyo3sZSZmjUh9s6a2gHVdoafFDtzP9DyZF2uMnmAmR5DqUXBQJC ISRIIEdAqbzltzTqporfIUB6W7KCJ7inYRWZMOQOrSBdRWRyF1TFSm0EnFAhGJxcoPK/tdx7Ue3B AdCzbrNZb1cuQmqACxdago/IGPxQns0B9OVRzl6cow9k4/rx8h1IxKFLPyUpstw+IPUIfkFIoDKZ +vxD1eQoUhfjP0jjklzATjM/RLU40OIA020W1G6DaH75x+P/fXvz9Hj/D4RWcjC2ElIVZqiidaUO 0jjReWUGW5tQVaxKV37c2Hid9EA/mzYxstDh97XP6H77mDyPH7Do8xrAYajhisI55oxiGgj7SdKT sYsh8HAUAOmJl7N1RHC+Umq5ZWqJwYkg8TY6tGDgfnvAcUoASx8Uckcy89gNIZVEaCbX56nIZsLe BwFq2UIKpAtlwOkfhu9Y3KBKRApq3++hSSkVUmFQUQoNUVmEThNDcmHNpKl7aI7e9sYk+Ypu16or aGJ2ia/T1i4qNG7G5jxOCpd7yiOyUlQNeO7FPD8FkVmbNV1Gy65P6wq9sgGGszYqisSgQCds6bEo bvGmIL/Sdh6JRYA8fcqG6gVZGVAqoXklIPAJOIcnuD7KPjskveR5Wq4d+GoRhadVEMAoqPBEOD5K KmmAIFNNgWFzb8x9g9Wp2G6CiJkn8Vzk0TYI0C0fGhYF9JnU8AVaSbRcBsSgRor4EK7XhtNlhKtx bAPDeDwUyWq+NByqqQhXG+M37PJy6qS6V8+He0+MdrUEm0YIB/Nl14t0l5H2FhdJ37TC7F/aT/Iv KNmFI1kiszZ/lkkFr3C1Xg2XTBAZm/cFuHSAebZnCXKFD4iCdavNms7yG0i286SjsnImdNctVk6P PG37zfZQZ+ZbD7gsC4PBdhy1Zvyi+mq2+7/unmf86/PL0x9f1IUYz5/vnu4/GbUMHkHN/iSX7cN3 +K95c1YvkNv3f2iMEgB4tSIMOlVnEFPJwJFb40tpkkN1jUEwM8CVSGbcxalmJc5nGEDqqJ12ppoy TXtOE8FHB5vDWICE0sKXThvGU3UbpVk8EKjsasFCxxubJEhaK4hTWEZB1RnwbqraokY4DG328vf3 +9lP8rP8/q/Zy933+3/NkvSN5JWfjTDNYbMUphZwaDSM2FTNUO2Jbu/SxSZwIjRTGtToJ3HrTFAJ 0TP4FFZh8mq/p1U6hRYJhMaL2zJBM9KOnIo8f/oJacWpb+RrcpdM3xA/ydXfV58VcKEBwQAAz3ks GIVgOLVigsNdm567MDRNUxsjHT3E1us703lWl0r42kztL5YepCbBEmeAEn6opXHvb6jPisRtjOVH 5ozXWmKTZDC9rgJUzAMqQj3cbRNXUD59qGBqoFShfzRwgNaFWxEluXiKZ38+vHyW2K9vxG43+3r3 8vDf+9kD3Cv0293He8RN0Bo7JPyaw0vheWHIdQVJshOzQB040y3Y+6rh760p2GfSUEHZCgAVOyrc ryB06AKfJ+q70tKszcgUHImH6A5melRSJegCBxK6EJdogQ6AUkrpLgb76RaBkvwoUGJ3bAUy6t9u Od8BPggeIh/eplTiBOKmuFTRnEsorelMi/FSCsI0RIpP6r9LQjWyMyPARuIhmqNgJdtL6wp+WM45 i1Kli42JQp6uODjDOPLqSnANNxHLKYaYPbTyJO4oxXPDa1yIXsKVYUzOpUSKktXiUHnx7YGrwIgT h8K6vjr20Ittdl5QyidgMUKqzu3skeb07aypUf34AoJCJ+btLxcM8DACfMga/N1MjjZHMMH795T4 RRSmlEOIgxfDK/uV1X1XdE/pEWeEp4W6z9D3AXSALN3ULmeouq4EwcFhS4HGI8WmqloVXY9Kf14l g4ppVZlCSK/srnEXwfAobVUAN45ZcvgrKwYSCEzc1QDfebiHYdSax2p2pi7TJvJp60IJgMFN5ebq BlgtrKQzMOVjtXhV01QYldpEXb+BiGviIV1DKMuyWTjfLmY/7R6e7s/yz8+uKrvjTTbElE6NjjBo nfLYTfixLMVYiOdaj4bbQSUqgMHtjvnr9z9evGr3mFJh/rSSLzRstwO/YI68yBojVGTgDfKta0zB pJjrBswUsfcIFxZPOgBSKYfHKiks6BRFTfCuukU+YQ3NTiRQ71/GVPiiCfQDcjnElRVNP8J6llLL wUDXy+XGiLSyMFsK096YvrkJ/r4Ng2XgQawDcnjv2yhc0Z6MiSbJa7EOQyqIc6JJh4zWZrVZEiPI b25ien6yGmzy6wOwk3UovErFzKhpaRO2WpjRaiZmswg35Lg0I14fV15s5hFVsgZRzOeeDrr1fLm9 9nRh+jwv0LoJo5BAiBLKDp4btBtMWK0Du+Mos3NLKlgTBeQ4g5gV5PNDlMnV71Pl6Y7LbcQOnb40 0lZndmbUuIVaYGBmUshjSa8F2Zl6ikBBaMiC5Ia5XG/0JLVF1LfVMTlIyHWeaM/5IphTfr+JpPOs 34TVcpV1BEYnVxIr81algkjjwyv4lGQ09Hj4Kbe+iABJ07AWFDy+TSmw3L25/LeuKaRU4VmN7w8g kNK6xgH6E8nwahRKnTKpW0wprNS5pPpgKhouzt8tRGBmOb4ibOpXMQAne93BfRq+bsnepHKLruXQ UFbXeaY6sjGSB5bbNQ5iUYjkltWeOJNK32vGSo9rXxOcRNd1jNkdDuEleNDTh9MeRKurC/oo6ISO aTeGQvFUAL0mUMUMkYqlIb1KSk6kwUGWwTdoeN1mphJ4QR1YeWbo0t0L7iZuWUxi6mzPxFEQQ9If sj+zpCqoyOrhjeCbiqTJMkOOGUC534v1xvRNY+R6s16jzm3slpxvTEbxAKJowiAK7W+LKNRRTkEG TSO6o9yReZfwhn6h+BiFQTi/goy2NBKCcuBaPp6Um3m48RDdbpK2YKEZ1Ori92HoxbetqEfjgpyJ gYReWAQhcsa7+MUPdLb44d4W/u5Stg3mCz/OPGdCOFjbpqVtIg+sqMWB+18gy1oqRA+R7FnOOrp9 jXNkJiLpknmAg7dN9O74jreCOs01qfZVlXLPGA48zcyyFQh3K4Hy78Wq8zzNcx6FgR+ppRU5dA5H Dq+ubrESt+sVlSGCXvBYmndPoQm8aXdRGK092Jx5BFeWe5hCScT+vAnwabBL8jpXS2U5DDf+dqSm vJQf/7VWChGGHtaXYm3HBFwx4iMQ+2g198ibwtqy0ecrutUx71tTGUX4MutwICdq+WYdUta/SSP1 cysTGn2fFO4+WHaBZ28p+L7ySGn1/2a4nJ0cnvr/mdMBNogQkmnm82UHE/Eqtd46Xnntc9pu1l13 bbs6S/srpK04kww2eIh7qgQd6ImmqzOPrJ254NKg9mxrrVhsAs+GIydFSTfPUpLoKAg629vlUHh4 VyOX3o+o0OvXuCzB2XwmDq7Zoc7kkIDiObosGOMEPpNGyDaM5pGva9EWu9f7Pqo70cYjcbqhbrNa 0slmaLJqsVoGa8obYpJ9yNpVFHk44cN4MkZt4FXO44b3p93SwytNdSgGHcnTPn8vlr6N6AP4mc09 brATuSmfNEzqleHCodRQe9UhnJxlryLMGi41yPrcxMe2NU9AJvSHqoTaL6P1aHfRJtFKLoWq9Nni Ix1oqpJn1ct7hxNLLdGc6MEHOO+Cnh4g+G3WkgP0AGjsdj6M3x2+JNhso6U7fJdqu760grEF2yzc QSs3WCx1FKvK+wWZZlBdk6yifiE6SfZjzmeR8htKOLRZZKPAz1KzckA72K59t7WB6ib2grnUtxmz r03SiKQIA8pXprFNtj/mqq4BPWFN1h4Ry1mtqzUdhZsLjZ99uzqS3FebxuXQiPb8+Fl7JCAnWCJX wcKDPDpljIZ5THab5ZqWWQPFuRhY4hUi1a9/gm82wdLxLRpM01QtnAyBo9C+ZEARpWwdbYJxVXv7 0QYIvbQUbjnhnA62wWr+yrLS6kDvfpphb7NkWZfPKfGnwD75p5HXBCAvhOzvaLcrZXa02jqfXoJX 0YpRK4LNaZV3mJDmpOTkwXbDGejV8jp67UOriEC1iokPJbUJUMtGTrbGLdq64El4RX43BdfWsHMw dbh7+qTq3PC31WyMLhqesrQn9RP+HkIUjQBNQNSsuSHDvjVabsHIR6qh+sYLBBpi5whiCYKzYeeB JqGoWU11WOV1IlHmtUPDex3LBafa0UchJvw4TswlqJYV6uJqMgaPmuLpZJE6F9SHcZ/vnu4+wrUf Tkhyax7jnoz5kP+IKs/0ZdT6xm5hUo4EF9jh7MIk3QUMt5CnqCQqXNy7lXK9vcW3DagQUwUmeCBP IcQRwnKGW0aHLO6nh7tHN+dp8P+phJsE7y4DahPhQOChKsjXNwrxrNtVAYRujKNugRWxZLI8CAP8 wRHKnZyRBOewmlDjGXvUGl+ntLWGiOQ39tyRPZCpFMZrBFfOGAeKSzYzCe+PqmTN4jr+cu+7hfVN nUripKF9awpxG+NtUap2c1T4DsE7B26d212gYw/+KQMigy0xEuYjR4nlFsL7BhNB2QyzGjrjg5iR hNoDB/xBuDnSDso7AmwGG0D/rIuCmEUJfX0WT+1mSXwvDfZ2WKHgBgPofULwHT/5wN6n4EQLhSia YO9T74l+kqTsamKSNOL1eRJJuOJi3dleChtNdjE+SrsCHTIrsl0vPV7EWZMy4nWHMlo+uF9w6t39 Xcv2wOiv4a8JU5qyj28hz8j/ysNz13pX7UnpAVu6K+BMopgdU3XhehguoyDwDdIcoH9kRSfkFslc 5crEvd7MkI1Si97TFib4gXHBiav1NTwU7oya18FeYH7+kDgpBPXMhxYSai3kteetLsjX30jR8nKX Zx05agt/RWqWWacqQvI9T6Ru0xADc4l+YOVLwwdf/IIQP/DNwC8VzpdUE3XjU9NVBwX2DJrwH+j3 lMVHmhU0yivdzznRq4RSfdpkUkZdGRLP44yBzS9sc8bG9uOKd5YfovqBEcFubtfYNkreIL3XHlHS NrkVKzCgSp1TklqhcWV/SMnrSct+L8wqwZCS3eLLn4aWVcILmVFfNxA8ihg7v7Z31bV168GQKHtt 0rg0YCGKIM09FxJK9E0i+hjXK2GizrJUYRRJTJY7KeukgB3OJDMMbKPtPoFp4Lq+KR7cSKFMPyop Qg8FSsZTXcS9jgxVgbjKcW72IM0tabGlVUFOjnyyyGhUm8g/NZWkIWV8fguFOdWtC5exjHAXgqol KKBVxV4PURqXRymEoI6kLp9LcrhrverYT6mLuNGv5imF/NGrSCyob4HBdsk0BTtIUhRwKoHFsRst zOKPx5eH74/3f8mRQOeqktVlBJdvLB9jTayNfXWrTVbuPbyqe/CFUF7QehgWOG+TxTxAt5SOqDph 2+UivNqppvnrSr81L0F+UB00GZ2OAPg0Mx6+0nyRd0mda+kz5hhem2Pcy1CMGfwAnj7GwK6JXdjj f749Pbx8/vKMOEZqVvsq5q39ngCuEzJ4b8KiZC2rj6nfyWsDhWw9HHPg3fKQorPkC5v//fxy/2X2 K5TBHSrZ/fTl2/PL49+z+y+/3n/6dP9p9nagevPt6xsocfezw5JKffS9jBI5mMVYuw1dSC9yJg2e rJOTz+FmQTPiQxF1HWfWIkyKaDNfOkAdO+GCb6qS2R8DKm+JlrovTq1dEDp4m1OcqMtbWcBM8H2p qo1jU8hCqhf1YsekNovA0N0McFZkp8gCdbdlJaw5sWtGjTBUMIMssaNZaH+QliUqi67hwpoCXuzt bsAbkde0gafwVY1sNIC9+7BYbwK7pZuskKva00xeJ9GNJcpwAS0FaldLu7OiXa8iiyGL02rROYSd wIBh08bAaoyZNmE45QEgZ4u75Yr3fPq6tHqoO+YAKKbSZRASbs9jw7nvYzQ3c6szMU+iReh8C7ih A27p9G8/ghctmROkkHVjCQXR2r+lKr9bUMC1M5hjueJ9HZ3J0xcguC3fH6U+Y/Hv6OVDjWlXXlyT +b9AcCx5feB2WyO032H4KWsEazn2DgDiXJCpRhKjTV+bvst9y7PL663NhU3Cpmos2V9Sx/kqdXmJ eCv3Lint7z7dfVeKz+TVxhstryB6+Pj/jH1Zc9y4suZfUcREzNuZ4E7WmegHFMmqosVNBKuK0gtD bau7HVe2HJI9595/P0iAC5YEyw+2pPyS2JFIAIlMz+LCHVjKGrNP4jKz9SI31Ms/+W2yDbxm3/SH 89PT2NDiYPQJaejINEzLx31Ray4qeMsX4IBreqHDa9j8/Ecs/1MrSOue3gKTCmHJ8ECNSSU2EKie aV2plSFqzt9pQeRuJzAE3ISBuzC9KOJZqn6ThrCApmGp4fS09ay8cZc144VZjm+QQpwaRplcfMsF y64SgO2DL6n65USvirbggBKhSbPnAd8Ctje+gOmJchp3XiaueNrirnr+mMLXTy/SzWdf3IMBV3bU lKbzM+34cwWyQ6nRu51ywyxcI5zinV4n0lUkI6Mfoxe+4jP1joeTmDJ1pvoB1Mw8MkmY4RfVnGcQ rhrY1qKotfqs6paS7EQmZ/QaRzBo57ArcTxR9VRXQOODSS36vWLAz4nnHvaq5aNeqMnRJX78seI3 WmO+nzIH26yvWTOwCEjetvzxm1qRAy10AhwVGq0A5KnMeqH47fz9uW5z3G/HzEIPTFwZBYDDfjhL RBK27CIBYgof+3kwPmFan7VlCrZrrQvL/SLDP+miS8LKKnbGsmzVspdtkgTu2Ml+FZc2lENuzUS0 WbE25Tok/JaiFxQyh+rei0Nc27R9p6mdgnYPni61jmn5S+YzQm2REk9XQLjbLWBoxIKpJsddKgf6 mOiLeR4qWfD7LNdxsIc8HO8K7UKcEVkTosFuF2ykD1qnML1W85cMVLazu4fXINbxMzPAQLdk2CG1 ekDjDgPCdODIaBuauklBI8fTyEwxpoV8TCWoBtcJKYK49LOVQtGZZ8pIMq3V5sNxnYSIVPBzQ9NA I4KRiUGKdJKpUvMRPBTaHOT6tOc6XGohkGKav37gsN5T/VwrmOahiUGSWq606QBOoCxNamranFra BsLQ5zUl7MehPRL9syfWIryNLR8DXrXj0ewGUq3WJqCKSGdVpmUINPJ6dgj87fvbz7fPb6+TDqNp LOyfcvjIm7HMI29wjOEHaqWl9IazWDXCFuWH42x18SPFuR2Q4bodjL/g8HKFTvKCx/5QTlSF2Rct NF/yK/n1KzhIk7V2SAJOWlGx0Lamu4O2b1k6EIcHOTlj4OiGSQL+S9AHiyrDFEyGLIGAcx7u8q49 PbL15w78GNR5f226ewhgAXfWTHcnFQTkgPiYHy8QKeiFbcu+8OBFbK/GS/bxf3hic2wjo8BLYZbz 1IkwBQiYgZEHOJYOJRhdOfmV+OEA9XCuU80wC1Jiv+FZCEC6DIDNA3JOuzbvVC5C/djDVoWFAexu d2oxOJ0puUwrUd7FLhgaaHVG95WbqGdLM5KRJHTG9tziznlXtp0TbZW5bNnSIC8XM1CxnbFPnUS9 TTBQRT7oqInMy52JUDa81IOHBRnc0ME1tJmlLcCl0ckSL3VJqK8O2+kg2p5eAbAyNkvfpHnZ9EhL FCmrMl/f1YPZ5UP5bG0pqBbhZaHje6sF3sk2QOuwVU+1Vfp4DOwQUtEZirDy8c2Vi2qRCouPJGzs uxRA9YChQB4eXUnhCX+DJ8JjPKk8yXbVWGkitKT8jN8e0XdmSx+P9ZnCmrnJVuPR+Fa4vZ1VTb3f yKfVefQ6510pezWTZSUyFgX7uD8GKTJZ1iNqc4Iz7Tq8IQMYS7zNwhb3TZwfQnM1AFSA32Cle5PV ELCEgrVgMa+23cv3l4/nj7sfX79//vmOGOsuooYtWoozyGWen8b2gAhlQR9xQQMRUNhKaUHhu/l+ xmxZBnYJiePdDndsazLi7z2QBHG/PgZjjD2sMZNDhtwKhtuou4HGyFK2fupvNxr23tnkihCZKKGb ZY/c7RJsS7aVL9laXVa2GF2cVpz8VjLBZio+2R5C3RPBL/Ylhu1qd09HD7uYNwuKSbIV3eq3wNsC /S0QWZZXMN0sUb41lAOyPViC/dZ47Z5q6+f0FHsO5mpKZ4pQTXhBcS8hGlts8W1usN0e+8DmY15R dKYwxtsVsMQyDDiGKksT6pPfrMhvtGzsbbTs4Kv5zPEbLcuRsX7obxtmQNzh2+hwLYCVaUWj7YnO 73Q3Vcr1xMv8GA6daLpLok29WT2EUsiHwEN2dBMU7dBMxcVvgPl413g2Ejgx+XBrN+N7Vev622vy zBZib+dnpr4Yi4a7AjXrip1V6dhYZtu9uDAyPfg3OWmZbWnbcorI3FvhgaJKjVT0CPcDhXC622uO xHlDPMnFU7pZGNm9fPn63L/8l11HzIu6n+K+6TquhThekCEO9KpR7gJlqCVdgczsqvdiB1lj+C0B sqhxOjKLqj5xsa0g0D1E1kK+LlqLKMbUJ6DH6AwDZBdv9hAv9NbJCZQyivHUEzfenrzAktxmuaG5 cZZwu4x+FFrKGLpbEoo1kb8T1ZvNEm2j0ky9bNJTTY4EuzxfMgBbV2L2WkqDuMSGBQewdZYDO1Sd 7Kv2Em+fmvR78aTNXKIezgX3c3HGjuRhH6Vc100EHrSFO1sWIdtC15s5moO2+5o/KboH9VBMHEqa zNyeGiGNF1ejGlFXxRP4/KhYd3Ei9/LprBa+Irzdt+cfP16+3PFzBEP88O9itujyQBlaeovZwdKi gsxPjtDxLOHinMzS3ovhgVIn9uE+77pHuKwe9MpJlpQ6eThS3fZSYMLIUm/mJRilWuyNV6HCn8WV tHvjq7xIjWcjGgd+VCEMIXv44bjYsJZ7XzbSU1M4dlvNrNpKClJ5zTRS0eiNDd4200tq5DYdMtsr ND2mtJWn2icRjQd93Ob1k1gn1MSqNmWZbeQmbrM38AE/+5lA7E2HeNMO90Zzz2qFFXaQalJg92ZL q8sQ/q3LZM7BlHQSZh4TYc0e8yMnmLRHnBOxGYwMad3SMdWs3BUGs6JM+I2D4iZXkB9pKhu4cuIs ehWa+pp5pblJpJM1Z1WciKmrk88YKAHq4o/j1zSbLJ3U73jMjZFiRtcCn+9lFWKpzw0CEStk/2ti DmW97wX+oK6zVgG8GMNz6st//3j+/sUUzKvDbk3CCrolENnEUusFP15H8T7BXDP0tudUz2zCib6V MX+H4evNOFHVAG4rEusFEM5mzAL0bZF6iV1espG0m65cJPNBrZHF6njIbjS+cA6lrylZ7ISe2SWM 7iYupsKtsJcYibGqu9VV1wQW15hqHsIpjXV9KmtPS0fYruuyvfV38onVREziUFUwpw7Pcktg6WVA gIMqO0eXhn1o0ZCFQCm9RLd61TpdOMu29jl3kmYKlcnPEjKGGJBEG+sK59ihrhAFLpwr6RkKr0oa VbgBMgoB5K1mY/hOP3yfxYo5cherDGNEq6kyTc+NsBOyuTN9d4cUVggJ7DhRwKnva7fbYhIXtKHW hXHowGWuL89VpAYiLAMT2jdqttpdo22GpMCTuHx9//nr+XVLOybHI1s4weGXLiTZKn5ujVpv2GSj uc1pXpXz2KsLz0KNAwX3X//5OtlzG3Y37BNhcjxm1AvkKxQVkYM5rgjTlbT8l0/cK7ZvWjnU7c1K p8dC7l2k7HKd6Ovz/3tRqzNZnJ9y+XXKQqfCmFousgCgkg5+mKbyYMdSCofsXVP9NLLmjJ7vyhyK 3YHyqe9YU/VxNVfluZVzILuUlYFQ1t5kQDyIQgEXB5JcdgyqIm6MjIep36VtO7j64vG+sXcbAqXn ti3lM06JugQFm7GMCFyav9O2imTpuCdgzC2HH5u8JmrfTP7cIGjPuTXIM/PaM1zACzpSDXhGoecA hmQQ9wvUO0e9CpwKOZK0T3ZBiD18nFnSq+e40gib6dBpkYMlKvp5I0m9vxW6hyVZ5ke2871gA3Jm oXJk+bnqgrgkN0dCY+SNlPYP4ANuMMs3Aarlkw6esgesBjOc9eOZjSDWXxA8eauRwNe5gzSSoczN bh31oWGUATxRx0yl2Mh1YvHMfDniuYPZyAVt4RsT4CPf8U3AUHhmAPRG+YR3pk9LwlKjNQfeoUiF lhR7P5Kv8Fd6GriRV2KpioCGDa+AG0Qhdhwq1ZFrrGjtuTtVS7vskGpWrScOxM2K9pFviXU0swjL k2qPbUhnHjYKAzccsBw4ZDG7kHm8ED8fl3liH9tWSByhvRBMNccGqMyxS5DmBkDxYL/IgGrvB0hj Cz1/hyQ1qfqxOQmO5HzMYex4uwARYHOwIEwAdH3ooCvqnGvXM0kcYq0CTil9TF0+nPNyKpNwXGnW 5ZxS15Ht+5f2yna7XRiYlQB7+JFoloana4U6luXKFFFm0USaQxDbP4Jwk31BVR+dM5ZXOStmDY4O Qa41h4MISThW9A/HzKw5oINyhiFQH0Q8GSEQJW4kN7NmuXhOfmwgqHHejteCon7VEf4DKVhvsQbO sQaROcGz5cgDRG4kbSSJ4EsRcRgem43qizMZXoux4ll+OXT5w1bX5tW5NGKbGlx6rOx5KMHzrTXx iQov7DFiUlUm/d43abTNSYeQz3WCZLc8rzGRFEuGU9l4RDK+L7r7a9NkWINlzbzhIJhJ0fQ0EvuQ 22dvfArXsOt3U7y/ny+vYIL//k3x9clBkrLNcFH3fuAMCM+iRW/zrd5Usax4Ovv3t+cvn9++oZnM okbcpGxUD+5hamo2NtBpp7TYVCRrvpYY9xvFg6D28MDMLN1GmHs0W/r87ePX97+3GtzGIhytXoqs ICy3v9+fN0vM3/uzQvMy47NycQmAV0xm852xp3lNG9zn0GapsD2RNlAffj2/sp7Chsj0MddleBHk SbGa4fJEK0zJWHn6nFWVlLOd0VR2a96rHOkyc9xdSZ+esuZoUozYRwtQN1fy2JyxXefCI1xxcSdP Y17DEpUhWUAUQ/7ehqXGVj8dpo/0QNEinDr4Cmxh8ulz4wjo+vzz8z9f3v6+a99ffn799vL26+fd 8Y01yfc35TRoTnJNClYQpLAqw0hzpBl1prqR7wxtXC2p5ZtrjE1eY6dEzVax8PPk7e1jC6RKm0OP jA+FLGWp6IZwYD9U58PCiIyVya+8lIOySoThrY8jHynetMCYgDguRjJTAHAfeeJhn1NS4pKkyuuD 54Irt43ywV2tE+3QDKejEOxr/Vhkk2fywrlRiqei6OBUyWyNqhwgVo9crPmCYTvTxevBsJkzodXO ixwkZ3gc1jHQsYGUVLsBG3j8rjdAkNldgIkcelZJcMONJCd852BD6IoQhVsABODvrbFubushcJxk exRzT1VIqkwTZCIOTberwz5yN9NlyuGApTo7MjSROQ4G0k59BT6gBnjAj33I76RRIPbUrKTjqiHy LeNHZorjyMPnwKpHe9MwXinxuWxVIg81gsyBZgDXrAor7cE2Ay21UDQ2SsOXaCU14X7gOOz3eDtw eFOKMH2kz+9xIbk4g91IYbJEQWo/vbbRpcBM7p4IQ3ARIAyXtsbfFE8CK/ZiCbrZ+12fue5uU8Rw hQbLYTZ82GxZmvqun6Pf0zSEYWepvbgs1uFVjQ/4BJNHwfQEUG/p2VLLnlTs+In+VVEdW6Yk4t9U LRTd0b8BV77Ecy0fnatSbob5JvFffz5/vHxZ1YT0+f2Lopsznjbd6h+I0NpQWuwVZ72yJyhgoVnR nBp+yo/wLrDSQYyedcVlOkDFG48gCQJZ/WvkWVPZJo6Tp+SrQn6YLVLVPB9wou4OgRNrjDiXuyLp mFa1BdWOhQWm+1Ba/ZP+9ev7Z3iaPscBMfYd1SHTXCABZb4lUakijsmxZXsRZRDBB9SPXezAbgY9 1fSc+xUAIxwPO/rkH5HeS2IHK5zsKUmhg58kcIaTyp63VuhUplmKAbQyKsQDODuoIR6HTcMTnhy/ mMBo6hUK0BerXyVfQbVFgF4ZNDckvBvB+Be1oFlQ2Zh4ISYYUTUiXsm4Gbbo5SJFX+ZAX/O7HflJ 80yUA9hCKpPurzyml+hGK4oNgUmLkHQjX68To7qhbQRO9kDKB2AAd7/3d2jMeM4gXvPwt676x0e2 YoMzCToeLVE1eQenLteqNJckKM/GMDEuVjh1YEXr8NDSAvdCpp8RfZqciihgy0RbFcZEmSA4gLAk yjjCcJg/noBTD74FYcioNFaj2QewlASPq2Wbi4uRlvJJkrRV4uC3OyuOGzkseGTxtiAm4uAGYYzf DU0MXE+1TuTlHg35LMGu4FZYvmRbqElgUpOdEyNEL0SIuxgpCyNjVh4c5Vd0xjf8uYTtk3mLLO2f ngYjWimXN0C0JKM4iZTodT/k2tAFFV9Puk0PIZMGuE0dZ6isdtN8Idx8GM9z7YMEvcASIFyMacUU Vn4a8T5xEr3w0y7PXrg8NbxIynARxJEe9UUAbBrlYrrpUnY+AdDLQqvQwe1qOHr/mLApglkBclhE ntOFCtkPIlSPxUsf/5RtPa0VFG5lu1TTAXS7a6ApcY4NqbcYeip5w419YpsSPfi6O6vJ8HMACFqs a6t8pJGyImhA3JZGrqNeGosLXBcXahuhbnnJDCPPlSpfCS9UzzXEQc999sW+NY9CsoM100sQahIN Ri7CeNQmN2fbUiQxRjXH7oIgKhPD2BqBTtT53MOcKDNCzpkSAXqKCaqfjsMn19L1Yn9rWpaVH+oy YTLb1YgP1aD34vLITNM8dQNsiWi20wzYNEsPM3vllatC1zE0JaBa+5Ab5xrDi1Ptgo3BAfp+bQI1 K+GVuqEmTQyGuilOWTGa2XDC0lgTNv01SFyt60QoaDBkHyzIZBmPfmNBpvN0PXvwHFi2/C7EENoc 5BAmeAQLP6ZBvjzY5v76aEQeUyL8M0rUY7JyVe5EMkKZeos92eHfzqYao77O8zM2rvIZKyYERinH ynX0KC7qukqrsz5STAZDK5cjVdh22+vJ2hT5WD5sm4Mha0aXK3AohpypPE3Zk2OOMYDB9FlEg6Ln KkdTB7sHbvawycWU3qOQyAYERwKJLNhVSD0tkLAs9HdKj0hYzX7gb7gkJnEOgIwHiWcSXWXWuJas Jg42qsHGdTu1+bjCRPThLEHazn9FpoctVkie1xo0WBI0zh40UBUI0hCbd+FIC4kN9o3OsD6gUVki tPXMLbiCuR62DCssnhxRVUNcdOqQOvRD1cZMQxPUcHdlUm3zpdjlfN9rRy6haoyu4GGIidGVpaDl znfQMcOgyItddLIxJSKy9e/WQ3SJi6m8MVorjqD9yk1YbbmCOohvsjWm6CaXUId+gyuKsc3zygM7 91B1RaOAtl27zhSioxH2zFGws6aeRKgLFpUnkTf4KiQ29Ja02cb+Ztq7EO1G5AhArzB6KKEzWUse x4ljy5lhnq1D0tZlTY3tIiWmNgzcCE28TZLQ1hsMi7ZnYtU+xDsP7+g+8l3LesOxWyN6w8RZZUpu MbX7At1EShwpYUu0RSLpJy0YyyEZUOVbZjk/5UqwZAm7MDkb2bIH8IYY5jw7WwLo+6oV57ph11Yn rGiL/ZQVhL37ZQ6qYbDIXhf65pyeaNrlcK/Wg7/2zXKthz5YunD4s/052wFghYbDJwcV4svJE5Zf H7k3JBNj8QLLYtr1D56LOg+TeaqLZ+lD9n0Uo2dFKw/1qpbgNQOI4koADaskjiyCzWppLrGUR7bB dSzlFrupfdNYIqTonJcuP+xx9UwwtNfOlhPflN2YqHCktcfdOMlJ8e3peKnQsJYS42PiOhGqbDAo 8QJUQ+VQXGNQ39LQjdQwsArKD71u1ZGxebdFpzjcQp8T6kwxWg/pzMyavOUBicbmokEUNCblAYaB WTZRAg22VzHpqA3HlPM0CdOfLUkbSiOelrQhBa9BGLCc0qCIbXkyn3Ljcrok+2KvxhW1HoWn0yn5 Whag1E1fHDSXGdzUhqOwc2z0uLsKF8LB7+KP788//vn6+QOJUFoNY9GeL75Wmkx+scv+EBGVsn2B UalGzdqRnIdRW7IkZIptitaEs3GvS2gAhhWmeXmAV5hq3vcVnWJx6nkf9uCfCX1JIXFB5NeRNWY2 Hoquglg9Rt1S+ewHaMe8GrnJxpyvVh4bBt/RU8X+x1CanvIlwgMcDL18//z25eX97u397p+X1x/s N4isqZi+wHcieGzsOJi2PDPQonSjQM2QBycc2rFnG9pdMujtp8C66wPJWYetmOJVRFctcXP/l5w5 hHnO9Cw5kTVRc2XzPWNKztnWbRUp2UAsaKt4TuQd0LC5ocRFlcugdtVeSkIpyOVo8QLFQdbHVlBc yFtKfc5KtbD81Ut2ZRWvCgQpLxlVyVME6mN7VuktqfPF/D/7+vHj9fl/7trn7y+vWrtzRrZk9+Mj k7TD4EQxQZIC81o8KqHEQs90fHKcHl4KtOFY934Y7iJr04iv9k0+ngrY/XnxDgvBoLL2F9dxr+dq rMsIK2cGAT0qDJkaDymCuHrczDovi4yM95kf9q58T7JyHPJiKOrxnhWPSVVvT+TNpsL2CE/EDo9O 7HhBVngR8R1j5AvmAmKt37MfO9/iPhfhLXZ+gGmUKGuSuKkl77puSiar809sXNS4CxmTu3Xi3VN6 i/tTVoxlzxqgyp3QQfd1K/N0KN9TRz7wkPCiPk7TlnWQs4szJ0D7PycZVLvs71lKJ98NoitedYmT le6UuYmHeT2XBpBwyTuW2U5xICMlycC944cP+KgA+BiEMTqyatAMysQJklMpbzEkjubCrXH5jFPD rqJMURR7mAsClHnnuOhMqyBkGITNJgcnjK95iBatKYsqH0aQ4+zX+szmSIPydQWFV+CnsenhFmVH 8Fo0NIN/bJb1XpjEY+j3NukqPmD/E9rURTpeLoPrHBw/qB20jyw7aZz1MSuYEOqqKHZ3aMUllsSz ZNjU+2bs9mwiZL6l1+ahRfqa+P6QWtzZmh9k+zhAzcRMVhplbpShRVxZcv9E0LErsUT+J2dw0EGs cFU3Kjsx6bddN/kzNcIqypgkxBnZn0Ho5QfUJxL+GSHbDdQcWHI4S17cN2PgXy8H94gyMHW4HcsH Nqg7lw6Oa6mEYKOOH1/i7GqxfEH4A793y/xWXYuejUc2oWkfK06FbSy+bTGVmJKdXcmf2JsaXsAP gReQe+xizGQNo5DcV3jufdaMfckm1JWeboz+vmWsmeMlPRM7aH0njsCv+pxYOoXztEfXYhUjMXbn 8nHSieLx+jActyXwpaBsl9IMIEB23m6HZ38tshyeVdPxCl6NtruYyV6I8jkObeuEYerFnqwWa1qi /Pm+K7JjjjXRgiiKJrxWfv/r+fPL3f7965e/dV2fB/w1do1QjabOxyKtI09f59ITG1RwjQ47G98Y emkHoZ7TkdRDHKHWUXzvNmkJjFRzfyN6MiXLA2R22Sc718P8eqhcu8g1hoWKngfsgItvp3pW1T6K XE+rKuiprIhZbihmVX4korNpn7UDWOAe83GfhA7bvx+ulozqa2nZp8Nuru1rP4gMudWRLB9bmkSe IfMXSNd02J6S/SvYNwZQ7BzP2FAC2fNxJ/QC5xaBYohZKtefihoe/KeRz9rNdTxN9esbeir2RNgy xZG3iQZ6CTUcsypF2JKtTOLQyIRpG4c22BAg8Dy+jkLWfwl2mKixaMoaJN9mrkcVp1KAMMUI/AQP MGsiP9hAY8UUQEGzduOzyNMShTMEkl3i0Jw3EiRM2zZOL2Y+4ySGS5bqlLVJGESGkJDB8VPsubZR he7AJ+JITvvF9k49tZoYCo9u1mDmS6cZrslfU3gq1a+0noATPJiUZQm7X+wEhHv6uOQmscz2JtGs +BSLDyXC4aF2IuFnGiENDILcAPJhCVNyL8VFb9iJvOlGgcvHgR5sQpt0aXvUinqsXO/se4YyKgRP ZvPrUNSPwHUaEj+MsROLmQM22J48BWTAl/0ZyUAgz+AZqAqmqPgPiv3ujHV5S1rcSd3EwVSxEEsV VDQ/1M4dW7bJNGYnGz+edZ/OtnjGbm0OT4ga7PEapZk2JPsio9rx1vFsnIyUsAhi95rKXjKve37K Oz6ci+5eSxU8/XekzvgzLa64HN6fv73c/fnrr79e3ie/A5LOctiPaZWVSmR7RuOn9Y8ySS7rfHzM D5OR4kKi7N+hKMsul4PwTUDatI/sc2IArLGP+b4szE+6/DK2xZCXdITYfo+9Wl76SPHsAECzAwDP 7tB0eXGsx7zOCqJE7WbgvulPE4LOIGBhP0yOFWf59WztX5LXatHIrx8ZMcsPbOPOxptsLAXZkPS+ LI4ntfAVU66mI3c1GTjbhKqy+XFEh8Y/z+9f/vP8jjxkhC6YAhAoSSrymv3N5JDWWuw3tmPCfPIw 8HzJqdonx32u/z2CI9VAorWXztNyAY8mcMWDHZZAq7oZf9KllhVeJyqUa8WUzVBL+lr1oId2TWtJ vB2Iq0bjhK9cVJ5AWU6sh/asK0b1wSR0UKV1MBDYnjDNS7Wg1NebmVGmi6MuP4J7Mvx5B3BWND2j cgs6JFMzKvZMSg19EMp7f+iW1TOdNExJoobHYrTJetZWmCqH7XRTYaoKDPCuIRk95bk2o/kKppIo 62H5MRYMioq0xkAB2nzFZt4n6oz1GW7W6B++gTBhzv2VmDmOmfo4UfnEeE28wXawDDiJTX1NoGAX NiO2Mgo4F2gqW1whyoXlRzN7WZjifuvzisn0Q3o/tuBeKL2XnfKp2ZR53o7kAB6coYqj4YmXyzX4 gGlLfLfPQ43n072d4W9nSR0kSMZSbVriy1spg0HsZ7YYzB3JwpPOu/MxuxSb+KSqms2wsojtCFNf tkfUdHdkefKqsZXH9sQUNbYNn4/0t7rOcnYna/43u2JOtKparuLLlZ5p8zpSopogcC0HVqfLUX6V w6BJdZnKg2pDwtfc8+f/ev369z8/7/73HRPO80MDw6wAjvvTkvB5einUYD2AlcHBYXt1r0fDVHKO ijKF93hQVxuO9Bc/dB7wHgUGoXZj8ntGNZ0fyH3WeAFmcADg5Xj0At8j0kYGyFJQH4lKKupHu8PR iVQ6q1HouPcH+Xwc6GIfodIaMMXy5CcNiyajt6uBC58C09K51HHF7/vMC/G3pyuTeA92gwm3e1xx /dW9iqg+lVfMbke88giPNorvthXUrXykpsnA4taxQmo8XQm0PgJRWizyHbTHOLRDkTYJQ7SoLexP OjQ57HnkiuqOR7DOvYSeE5fYafvKtM8i17HkwZTYIa0x1V3KJM9kmXJDcszfX4osb3D9fJL2wtzl 7fvH2ytTw6czE6GOm3IoO1cVP++ljawOKWT2szxXNf0jcXC8a670Dy9cJHtHKqZ8HNiOQ0p5XSxM ePJvPbYd20x1j/gag3zWNb3d6Suez7QN6sl93lx07+RTV9xoPEkuNkc8DoZhTza3DW3OtTQn+Z9j Q6nxKlVFwFsfE2sFJk6okmCdjfOjQonUyhYfE2HMy8wkFnm6CxOVnlUkr49wjmykc7pmeauSOnKt iqxQiUwcsSqw2jSHA1iQqegnNilMClOOW+4Q8aJirFHASE1pLUau2Ma+AxAdDXP9NFxDkabLHmsC zlCYdtnIs41nSYYxJV3GtHtPzWraGIxskzMS9JKWZ9k16XjQEr2A5wSac9COFXWvNdn8PlEph9im TJ9tNszQneuNvQXvxL4cLwQMfayTTuq7T2xGwwHTdpo0fziDC0A8TgCvAvesRA39/JT9i/z68vVN dl270JQxCuExupyUZQN2fU/5H1Gg9MJAwN+dCJGpFs6i7wJ2RuOsAXIouvxayHaRMnVUQnHyCip6 Ch/hw+GqUgo6HdIoZeBpgsMaS0n2+b7ZW4oBTugc+UWkgvaEpqSygFWjuuyYwQPuPJy3pOynayIs Dnk35AuwzbLDRPqmbZgMfjT6rYErEHvfcbyC18rYEg8ck98pvdQLWSiZmZ7xireZ5n4E5So8ipW9 Ku67hkuAHldVuPBJT+2cCPvDltnCRtusOPSDITYVvMN2BXwoTa7w1lLrvfR4rM8anX3E3UVCCa+n gvalanUMPJN7TpaEJecsZ2O/5ifFSHNJKBs8hpCgb+kdlwh3f729s33by8vH52e2tKfteXFEnr59 +/b2XWJ9+wGPxD+QT/4t2xLPNT9QMO3sbOWfWSgpsL4GqHqwL1pLDmc2omy9s+RBC7NnOACdi0O5 KBhWrCI9FMY6O6NDesE20lqZvVM/4Kl3bUWPJgRXbFDXszFSAdGGyeqzfKuftWTYYDwVkeeCqwib 5Pz0FMSBg4/2xb2+EA9K4jI2edz1Y2fM8Ac/a51RN4wzyu06KO1B3pX5JUe7RHDd53m1J9jtj8pX kfRkT4UHYTjAJVFWPoLBxnFkSlC+PUjB//++Ty8UD3S4sumRwIXdO/TgpC3zPiTfXt/+/vr5jmng P9nf32T/1iC2uAdWUpzVvpnIA1wvHRor1mVZZwP7ZgvMKrjaqXhkki0maMjuQPSVXWEqakMYyzDu qF1lE9uEVHG0pXHAzBdevu14Udtgto5hEOQ4nvui1DVigYJxzngszzleweMgFXyzjkfXI6xHyGzu Y2OAvS8maARTvxMnqesLh9ujTclqoLgGw4FjX4aOfLshKZXoVw+K/8uZyl0Sjml7tkGq4YGKmSdt Kl60D4kTIQ0kYAKwbMWswjSN3cQxUdqjWU6pjXRvqTyodFVTIwlaMpqDo9gRmyq14Gwgb0jFhW1e KO0JsU3fLrE9KzS4uz6MAvyh+cJ773tJMtnO8OP4W+z+bjceu7OYRJvMk/Xthl4kz4Lu5fvLx/MH oB+YpkNPAVu6t/VqPVS4yfB0YwW3lsgYLc1BXhIRFGLH4EiDaENAFxtmpnnvc0TJpQ06NuBDbkQ0 FWa7S4CZL7MYu87c6pJ9poJ9iLEhFJOyMLu7r75+fn97eX35/PP97TucTPHHzHegTz3LrY52O3/3 zNTErYJyHssknBIwNxhr7/9+AYW68Pr6n6/fv7+8m+NG1ROET2Rk+RBhmLaBaToaeOjcYAgKZJPE yZgizjMkGT+mgMv3anK2OS9WG3U125o7uzfVK2NmmfGCplmvp1eMeQbes7GtOVhVrqAlrlHGBo6U 87/NPOZoCkS9udPhKmUMG2Nw5ruk2F6Hu3nMFCe3ClSle4osMBMm9CBLW/75Bi7W7/7z9ec/v92u kK5vPuBWsiX7XAq6bbQL57Fev89c3I5zzC8VOvF+e2CYCc8vzDd6ZAp0YhELE8pNQVeterMy0yd8 Fm3l2x/aI8EPKrh9bJ1NPgUnecfmMhbFatFoylJM+O0tEEl3seDbKBvbEp4x1XnGXF9246QjqntD A6XYesdR5cmKigxWRI3Rq2MWv40Gm7VQsRIHUkFcN7Ej4+m6AeItdB+4ToDWhiEu9iJCYgjCxPJp GOL2+RJL5OL3xDJLgJlIrAyhnyDKOaOH+l2NGK1pGHk+VuJ95iUR6nFj4eiZFt5g36bUD0vUT4bK gWYsIMxJhMoRmtURQGRNNXA3D+plvu0Bm9LAKwMPz4hB4W8lECJDWgBIF3JAftUqAz46XgGJsNt/ mSFGlhROR6a6oOPTZsLQGQzYMCDjbwKsKfoutuIBEODF84MdRg/90kcXxnTwnNjDvdQsy6I44bsl rYHNC/eoojjBkbOFxlY0I2xlRroe11HEgwA8pZzGrh+gdC9ARXhOE9/F/F/IDB7St4Ku+4bVUPxZ 6sx07KvIQUtV8L728Zf8C1NdN7AJdnzcc8JydDE7VBzpVgeL7XyCVJUjfii7e1CgEF9POBbhYQcU np2HvZdSc49RYTpjN8TRwkYzZL0U6A6ZiaIGGECrZOdG4Et43fmYpZO44JaxR+Opztxs6+BGCTLv AYgTZOJPgG0McnhnOJW28m0PVuDSfKBr0I1OmLlQEcpA38FaegI26sjhm2VnkzxBxu+MbKXP8ZsZ gGtxPIPQ9f7bCmxkzOFbCzocgnlbSlt3n8jeuhZyybQfVPZ0PVuVEpgqW6kyJjjYxOYTnPRhR6hA t2UZRsGNc0TGEmK+NWSGBNE4BB1fgidM1ALJkqnlN9shdpEpy8m21hFQSjbydUM9XyuXSGfrQAo9 ludIcaxIhu31ZwRvtgWVjmgMFv4il7D/uZ+yrfJN4TzMe06O3tjgUlp5igNiGQhddLcCUOR4N+fW zLct1xhXEEbIFKM98T28UgxBozmtDMVICXpW0BPqhaj7SYUjQqYCAHGEqEcciFENkkHgWHCznYAn dreu5DmHZ8uAbfq29kM90w8Dd4d+fCC7JN4SC5xjh9z39OXF9xxSpPj+UIJv9L/Mia5tC4PvDuhw WBm8Ibi5XKvc2+vSyrvVAr4R4gBjuTVbJt4sHdxga2z31CeeFxs3ogITW6btjIAp3BwxtsPE9QxR A84ZcX18m8njRfhb+0zQ76r9CZGURqwJBUjsAL52wKM6Fyk90D1kA8XpyHwHeoLORobg4RFlBmw7 BHQfWQk5HRGOQMd3ZIDoTgMxlq2zG2DA5RlHtvZ7wJCgRx8MSZzb83Ni256Y4CnUwXtsh++mALE4 klVYtlYGYIjx8bCL8U7dJSFaGkqSZFPkP5V+gmr0sKmKQ2Q7Aw7EQ3RIcGRLyeUMtiR38Owzy3sU jiJ0mNTknNj8oss84aaoA44Em7Ac8JAlWgDYEt2SiOnlBPlGmCawHgFjpg49sRQsl4ljo8SCsRuW pFC8H6Ss5rcCytWB8p1Q8GyWMhKsAuI65NiR9oSgwp/lH9PFxanIzGtPRly/YX+Me36v8sjUqy6v j71i+MXwjmB69FkkIzPOBrvm9fKPl89fn195cZBbFPiUBOC7DsmHg2l65g7l9AxZa5+x2caxtlUf lizEAtO7OUplC1VOOYNhuJ7KPi/vC+z1jgD7ph0PB62Ni+M+rw1yegJ/eXr66algf2FWehxtOkqK TkuoOSvxw4DGBiMpSyP1tmuy4j5/xGwbeVLcF7KWPGuGvrjkI907oXrbyOFHboFtSZCNoGNTg39C +buVylrF8mVeUdFkSm55iXo9EFCuGE8JWqMRnljtVdIxr/ZFp82L46HTkjqWTVc0+iA5NWWf3yul 5BR7vS7FhZTyGxieeB8lfqdXlhWVD31LSvePuZrKOQX3QalKvJKSDUo96UuRX7lnR0vax8eOv+RQ 0ypSkhnzSvMGICGfyL7TBlN/LeoT0ZK9z2taMOnT1HraZdo2V3SvzNFc67Uyr5uL1uPQJCBfcCr8 0SqtsyBoDwLanat9mbck87QBCuBxFzj2T6+nHDyM6KKgIqzbKja4cp1eggcDnfioxSAHapeLSaW3 YFWAf7fmgNmLcrwBa1R9TlTnsi9msSvR677QCV1xVElNJ2aELHZIDf6H2AySOkwiGg3S5jVrjrrX a9PmPSkfa5vcb5nsFK6wTaJ4p43QET8nMmxNj40+TRi0TDhxB46pCTzSXptQEtGsP7x2HPQeZmln 2gjpmjQlWsnZCmH0wGTsp7cnzSvgtTQnOI1UdCdwImkVbNxpUVnUes59TiqDxGYBUxdyahToXLfl GTel4PVFXUVwiQX+ZgktFG9KC3Gj2BXp+k/NI2SrVFai279mC6Mmb5iwpXlu6EfgbO+IO8UScHem fUUskUi4dAdtbGypr+Z3Jcaqdy2Kqum1kTIUbEqppKe8a/RqzzR7lZ8eM9B0DUlDmRQHxxJn7PEb V6jKVpsXVdp6nqf4c8D0Ra4wwqM6VKfl4XlNhbRFPUdNzOLh6JKpnvYSNkDNcEkf7IS4qDugHbrC 47FhChdu12ikv7xUlEsilbs5pYXNuRPg08NSlaibUwOthFfOitwG6rlsCz3uhEihro2X8RJOOlhG CR1PsqRkiJ4QqWsm09N8rPPr5IPBfLpZff34/PL6+vz95e3XB++Y6cmV3P6QWpYfCFulwKULLSge 2QP4DiwzcKXD5WdheajCE1Re81rZmh63wZ4wrmKf077cKhMsHbwHjjmE99xbHAXxRmO7H7Y1YQsi PGgD/4SeDIu+XSfI28dPeKP+8/3t9RXzR8M7NIoHxzG6axxgfJ3USBILPdsf8ZjuC0fL/rFNZC5O 6Q3UeIWwZsmaao/QK/kZ80q95PszQgfjcpWcA3nfpZWRPErM1+rr1K5pehBsY98jaN/DiJ5DjihN x/EDxa2+5UzHuk2reMAUG4UN9iA1Xm5YgNEm4JisuCkI6WUf7Ask65cLUQTkQIDqYkiNmoJPNA7f qhQ+Nprh7LnOqTX7pKCt60YDDviRZwIHNjPhVR8yupme5QeeC5ClnA06MJqNZm+szb4ifuopfp4U tGzhLmOwoGaXLRA3HbZgkw20rUB0jyD0pLdXsw4E66ieO7+xd36z3fm0TFzXbPSFzLq6UaEuIVEE 7sGNjyahBL+fKDYEIL19WmE+xWeYmssZkCGGEneJaPlUyVoW1MIz1F36+vzxYTpE5II/1ZqEO3ZQ H0kD+Yo+XgKkr9I5y5qpg/++4y3YN2yfmN99efnB1I2PO3jdnNLi7s9fP+/25T2syyPN7r49/8/8 Bvr59ePt7s+Xu+8vL19evvxflsuLktLp5fUHtw7/9vb+cvf1+19vakUmPr3cE9n0AYHwwEGcsqWZ CHx1bPWhMydMenIgexw8sI2BojfLYEEzJeqEjLHfSY9DNMs6Z2fH1FjGMvrpXP1/xp5ku3Fc11/J uW/TvbivLXle9EKmZJs3GhhRsp3e6OSl3FU5XVWpl0qd0/33lyApiQMo1yYDAJHgBIIgCDB+rMIK Q0+Y5EmbhuZpT1SVmXN0N7H38PQ4xIg25gkJkxBMjTdpxdTu2t0qtlO/SU0y8fU6mPT0y9PHl68f jSRWtiROyQaNaymRYMew5oCAUuakXlOwEyawR3gH6hb/fYMgS3F+EYf3yEYdK954ZbVmeE0F88Ks SFkIkbPDwSBl25p27n4GMFnxxDfdIUkPWYN+mkJW+bpCUzONRBjDhRRuKRq0QOrJZ+LsMACRxwcE rPvO1rQBoXgPa+NAgzZCThumH+PeHT7/uGo1945jR0NZUKWcclzwoM/4VYORvBEraZrB8aHxNJ04 CfqJsnyyiSODxMMD2WkKWlw2RUhNFxQx0tjYm2cq8eHTh4/X99/SH0+f//0GMa++vH643r1d///H y9tVHc0UyfBE6F3uE9evT//3+frBO69BReKwRtkxq1G3z4FqGHZvyOJhyrpwHccIbV5TQ9ihgnKe gVFrP3EGHKqQrIqze2gVwAtemmaeJO3hnZAPNz715cqIKngRwFhBkS2MvoILYOXjP19dXq9mGDDq WjsGokEv+Z6SLT2dWuL9SKJFhVc4zC85q1DtqOV8HbtbtGi9fWE3Qvswb+EdVpEh15g+0RAhGCsh oeIkugv2TU9V388j0yXUwKkrRhRFjtY7CANzPtImO2aebqKw4GutQj1n2kSE9hETZ6TQEbSn0RpC sQkUkhUsC+pzimTfpOJkYSeBMNAnodtjRlCDhLLkAW0orVFwJiaibxtzkJ17WOvZ3UTx3BOcI3I5 x72zzGkllC701thq0zlQB23bWxXAdsWSsmNh7dAiDNR0n6OxlE0KiC7ecYJ3ZUGarlWdhSDhAiNQ cVHx9ToOKX8G0WaBrvquuLTBAS6TU+EZSxWK5fF8NkdRVUNXG/MNnYF7IEl7wTFCoIHNFUVyRtjm ssRxyT4kUgDVsSRNs5CJYhBMWV0nEIgtt4KimSSPxa4KCckG92e0lv8uqyGK3zQj53OgvyvWeAas HlWUtPS1WeNDgmYeNogucAchVNtAGWfKj7spna7vI946AfYxqocGf4xkkLQsXW/2s/X8ZmGXGwKv V3uGrdG2k6N7ZFbQlSe2BDDGnP0Al6RtY/ucKw5OPAvbvPPsUDWBS3qJd80x/Q5CHtdk5Z17yKPM VBPSLNL+lty28cOGEnANkQ0D1x8vv4+EdsWedvuEN5BX++BonJxy8UtF/LYbHVqIQtUsSXaiuzpR OdJM5qtzUgul0jPhgBUpaCPlQoOSZqY9vTStc9jVwR/NkJAAfRR0jnjK/pAddXFEMxi1xe94GV18 AxenBP6YL9FI4ybJYmXmjZU9RMv7TnQ3BKy3Eo2D7V1SMFp6p7KkKbzpB9fKITcYOWMu4Apml9Nm ySHPkNIuLdhv/GCAsKTYp3++vzw/fb7Ln/4Rp0l0TbGjdSNeVkwVSzKKB1UHLFyedaddizlJNcnx VAGVWewAVKr27rG/7ZpQuOczRzGUCr9m2Owa75wuL/7AIcjeQPUL1b7FxlVpoKPMMgfLhAfDjQ4a h0SjDRQA2XgyHq7Aip1r1iCGAfzPzvY9msb2ti3IzKHiQ3ODzjlLmOKYXd9evn26volOGa/f3COw tuqHryr1LUX46HioO9fuNBi+p4ze/kcj2tF+IDrZ2hEexckvAWBz1zxfIgY5CRWfS0u/UwYw7m1R u5S4XWDhhZIQx2vMq9sYSRUNxKlOXvXMsKOtTrl1wr0XgELFNe9vD8zVgA69LQt3EKi24rRxumbv m/n7WeZCM9gX3a8x0n1X7Vzpv+9Kt559lyGgzAPxdsfdlbzv6lJspy6wkAHhBnO/hXOX475rExLp jGReQVaQcAWzXJcVaLwRscAN8cS++nOPm6W1Fevb2/X59cu31+/XD3fPr1//fPn44+0JdT0AH5ng dX1qZlnSkxGaigLR9meNe/faHLEOB7A3YAc90oh0RTP+yC5rSxmPe++ZQkcM1Hbz84HLUCHT5pXw /NFd1oCK5u4q6CKAGYRvQqF7NJKqcNJylYZkCyzXrnB3FuUuiQKxcetRxBWpB9ePSQHT3SFk0QWP MOMSwJBKtye1oW48MjTQhawBciPwM23M+6SiMDhn55pnD+JggQB5ullv1j7YSbElPu12eWVG+h9A fXT9jeGaB68g2gS9T4HvtMI50AOM1I/Mjpit3I0K8htPf4MSJ5xnrJJCF5aA4+mRULdqCRS7X7PH jfcjDZ9jw2DgbVcDQPRRU91KFRzCIosvA4UaNKbQkqjqkpjKIMBUTDFuAz2nAsktcwFz4gG641mN JK0ffCSzzYM9OEVv6eWgQzY7W/nowU7p6dHlTkBkbkRRussnoKS8KOEU7uH7QGcur+j7c1ngEX6Z QegAemp389nMLaTlwaFrgbGVWJwzu6D+Yrw1vTlkvW15cZpNHpDJeuQPwUmqA72HZlPjLN/qbAjl Iit4Q60VriG2baO4fnl9+4e/vzz/5Z/Ahk/aUtrE6oy3hTngnNWVJ0n4APFquOkvN9SIdiw4Mtpu 4NKzTyYAwGBd77g/PhkYcXJTIFWO2r4l3a6Gw34JxhOxdsgxKQ/S5Uw2S1D4HSY/S8r5LF5uE4ej pKZ2uHAFPcezCDvuKw4gar/52HWELl0oqWezaBFFCwee5dEyns1n9nyXKJk5C7eVjXjc6jbig8xD Kik7hNcA3uIpzwAtHbXsV+qqedVOzIjuod1h2oJJUsu7CvtrRpLtZFMCDreKYzbfLtxuBaAZX0wD lzPTjawHLi8XzzN4wMURBpwjwJVf32Y58z+3E4eNHbB0WdNQ2XoEtZr746AylkEAiSbwbmAgQwNM SKybbW0Aej2aCq09XvDZZunydy4cSJ0d2lybAW1mINQemvlQ9VczX27d7i65P3PFQfiyo5guohyM SbJamllLFTQny23kTQpxNl6vV0t3mGRCua1bBqyz5d8eP1WD57lWJWXlPo52BfE+o3we7fN5tMUt IyZNjHrIqnVK4rWY1bu8GbzeRpGoQrF+fvn61y/Rr1I/rg87iRel/fgK+SKRhwd3v4wvN3411UA1 iGDixDU6xdAjJ+iFheqO/CLmh9OvkFzB6x4ObvmPgZS7akipGJFWL+gJMsZX0WwZ7EHK5u7wJySr u8TKz6smwGFM//356fsnmXmzeX17/jS1DyVNFG99qZ9wIZeXuAeNJICsi0JET8n1WeRLBjWlt8H9 oIbMw+4yrpvNMnKB/FDMI3nxOMyr5u3l40e/jdqp3939e19/J4mYhavExn6sGq8ZPV6cI+8nBldT FQ12NWGRHMUhotlZrgIWHnkQZ+FVHgK8+kSc9E+0wd4vW3QHR7+3W6qfdtiTWXb9y7d38C76fveu +n9cv+X1/c+Xz+/iL3XOvfsFhun96U0cg3/FR0ne1nDIdx9qaSKGy9WbeiRLSuoLsx4rZHOanW51 A5PP78twd4I56fagN2iHg78H53RHczEgZhVJFD0KZTKhuczg6DnG9A/3n/768Q16U2Y8/P7ten3+ ZASrFmfR+9aMlKUA2hxj7t8D5rFsjoKtsuHWjZqPZ2h4IZuMVXkerqRNWVOHsLuSh+tPM9Lk2P22 R5ZdmlANqSgihLvPHhkJ1587tQfIAm96HSJ2b+d3sbDNhdXhFoC927QqBSZE/zUVP0u6S8yUkyNM bm1CIk8g1XSd+Ng0dRpImUewgL9YcqDlASVK0lQv9xvowVSM0vGaheCW4DZQlAfiljs02GAaJHVT 4ywBQpwgbSnm4kX5J1u1qBudqA7lLRUjFXigJ1C7dm+8yutnz2NJ5KWcMaHOEmpZNPXnflsVoiuq U9aVVUP3hlVc4xzfTw3lWb4Hi5+1pDVObHUs2EL58SPfc3l4cMj0pHdaO4jW9uK5E4ADgf1YPF0s 1puZd9DScGu+FKJMTigFdwmkc45NtLqf28mvzQD2LKmlBxuDNOUmGLKWa+TvMwdcV3K4ljZYmRXA NsgtM7zC7uAlXI/717/GFujWC60Y8rgiTTAJrA3PQEjzCPJt36xxGqGH49PeVirgfzGXqOh/3IFO EvQPkAIFdoWVZZbWD0IblzF/hMwRvWBsMhCAp89JakPN3VD9D+eh1gOeUpZ4wB2kJ7X7TGNkFlyM b11F4fTHCO5IAW/1M+wdrk0NOTy4GKIs1TfiBn+K27F88b+U1Vhp0pOBVk1u2M9Otge0onE6RsLK zCODV0suzGNIQiEABtcvpvWFm38PAClmvr/++X53/Ofb9e3fp7uPP67f363H31ok3CIdqz/U2SPu 9SFEQpZatlcFCV4uDGilGUvRRf/Iuvvd7/FssZkgE6cgk3LmkBaUE2POuvzsqhKTRxpre/ZoYC9u XDjnpy4tGVIJ5QmWytcmknfw7trq29tsN1HsgUv51cqySI2lpbarm4UAh7BJVgSNjPnqFXwq7jeW yU3DN/FyiQI77hdyr35b6YCNLvc7QEK77JK4jukWvoSXzG0TStbYSPUJxR2qPN1TWzYbArwWtQxy FBvDIsvzpKwuyGvPKmeku1TR2uieYyKUAGJq0D0EsjWLCZZZPVBAXkGTeoRp82B/ciefX4d7BZXc T8j9+vrn9e369fl69+H6/eWjqdRQYk1wUR5nKnzdGOXt54o0yzjy1GA2L+7FurQdzI0GKCvGBvPZ tKm2i80S7YJazMgNijnSlWWDNVCcmBkFLQQLIOjSepzgoJZBVLQINF3gFlhQU5vEjmpp4HZFtNng twkGFUlJtp7d6F4g2sZ49xIez2ZCy3MlW4+HhLb7PLvg4S8dQicTsIE9ZIVQ6W+1Rvkx3eizuGA8 ssJKAlhHgp3+NrlQ+H3ISntZPFQ1fbBBOY9m8SYRSz5P6SHQqgt4hExXOSRrCBTBzpjqZhBUlzJx 97YedyJ4REtzaRUs9g0xyHRL19Hmgq+mPb0I/cnVx2SHStcYdN8DrMyksKNCeJ9rBpmm8jLeHG3z gaw8offgwI8FqpV4UsQQZT09Me/T4K2uxnaQqNse2x7aHZImQwrs7qsSu6g3uoSK8wfxSx1yhXtF HmvMAtxjS441DK5N8PHVeI7pqlJoipW0gwCNLLQgj1TItBU5zdE7D5dwO1HKcnujrwSRE5XVQa5v s7DebsgpnoVLWcXo+5s6Aw/0I7XShzftzmYMWQ4Vb8xTb3EhepO2BkE+WEUXcI90JI164YoWY3ku qBhOXz9ev748yzR1/q2E0Haykgq2Dv3liWlBGXEqH5Bt37Gx8RLP4u3SrbAedonWk1VtbhVxiZyr dRu5mU8V0JB2GKU+ThXWh8iA9y+mxz5sqL4E00XiKlhx/fDy1Fz/ggrGsTEFMMQkdaJsmugmXs9Q uWfTOAcEGyWkNxO8TlHQ4nCD4j/sAHkAH0ObjSYr9geyx/VshLjgaLRWn/L0M3WfspI4BeLUqzWa SMyhWW8D/QEoxXuQH0miOvVn2AFilv1EZ0hSkhThwZIUY3eFSVRnTbfgZ0dTEgs14iebu8USQFk0 61UcmtGAAofdcPskxZHup5onaXyOA6ShmQCokZdgTVvNze2+2UTz2zqboFrd7MFNZOfQ8pD+6gvR bvA8jg7VNqCMOFQ3F95maT4d91B60CZPqZbUNQSzme7Vz3z/PyjTyeWA3VRaVU+XOxZb8CapxU8y j0T3C5X3Vo8xKr4gR1Q7lwnlDyknaGc9WAGAJG2ynIsqzTmhwOsQIyplPfQBI7xPbxbiZKDj6cUO BjSga1ZgBvCEPXQHQjpxkDf8vgBaFB6YCnDCOO9UU1zoambnAKK67MUs2uJKjCaADzHVYeBtdbGr y1GoojWTLohuU1BLlxyg28hK8DnC51iamxHtFpb70FTRCuAag5qOIADNfagoVw3B1lbQRzbQtBwj 2u0IXdp64ZamEVs8qexY4G0CPHeRWQc2hY0CNs4osRaF96VtzFXG9WSzU3oQ2LEFXByhAxk9CDjA sJ8kiVEtWRAcdAHGWUYDYwQo5Prs4vCp8j2AoznCi/G57BNdlfm9RgQ5LETpHocnmmYVXt6ACpQo pq3q2s3CzAmm57i14gAox8yDKqYtMIxk09bi4KAH04A/rDiHTAgWoq9S8TE2YSheIPBxFRR9K6do 9OA7JAaBHDq/Jy6SLdM8z4c+i02PSD7W4UQ900tjFYUSpPT4eBofyIGmOy5ymDmEOQk4u46L1StL gf3Shp6PQiUOFHZnsYJ2DALqin0tpaff7Z32uHc22nvYmy4Ec/yR5s+9Hj9Ro13RoEJ6Fk39yPWG NXSIjN4zPierxeAfbV8s8CU7wQtdDKeCiXVzwdwUfjGFXN74eBmvHPzQ4J5iYbGHtH0gjCerSupi NckrKJlcWcBNw4nGCrjyPBrnkop4Os2cIorxzgfcYo7f+Mi7gD09ZRisY7X5REkajMomyyGBz54d kgmUGcvGQ1qZA1mdBoZGojiBxLmhZg8U8wRpmH67Y01uCRR/VeQ+cEIZiBiEXBB/rtALCI9sE6ir x28DWe8UQ6SdXm8N7ZLUWfsA719SBduSHwowYSGlq7fe3YkYfgNGjX88lg+F4bd1PHNGS/uR0Ahz YgUaCPu8YCBg9HBEU5jzx8TAaBgYnhVdu1GO1sZpjL/+eINLRNdyKf2Iu8p4RaYgrK529grgNenv HTRQ2/tdX+Teaj/AR1cp9cRPITDPLXpQ75aQT8/izLHzvxwI9k1T1DMhFcIk9MJAHIdql48YV37V 1TkPflOnidt8MSAL6pciwEsqhifMngqzEcafGhjWCQId+XuCArLuQNz8piHBJiW82MLm4DRLz4B0 dwEmYAWbayRnfB1FF7/ZxYUHayrFJK4z/xuQjAcZ9kaMefBrzdBwanfEAOCEhJjHmJTUeLmqhDLg z3PGjdWW1Lq3OAbrVosdtfYnseHpVcTZZoYfogTNaV2AVRseBeIkTQHOdRQP5amwgTifffuURhK4 2JTXyU2BTHi45uxqhozcOK7N/dQ8U/X/Bw43wRbwo+4lUqD+xz26aFpjMPp4IxVvDBk6EDeF9aQg G0YiEJFMcwrOQElD0WCL/US7mBmoNnNYikVtGUAGKGq50Vj7zYPijsLT6Ueh6zST/ckbiPwSmA5E 9HM0KR+Gq5mbFIIXPGBwT+DE4pUxlSFAKAy2WA8T5jtnIxqEb0LzXWUaeESXFBak9/jpimNrLsQi EUJ4DoKvPovprD8aeBOM3UvWAIHJu7zJhNy169LsOH5prMqTeg8ySyXb7Fl2bHxgmKOBcYLNkaUk xIySSOJj83W4WGqkSB8cFuXGLw75B4cHqQEGipf82aVLn1bBs6WqKSASa1pqFPX1y+v79dvb67Ov T9QZJAyyb+RHWEdsF1g9m06sFeLG+gYazbUnjJ4/SLWKnW9fvn9EOGGibwwm4F/pIuzCTE9+BRkr t8DKCGwnpnIxAJjAcvX2YJycIwEvMG8bRTB4/o6dYTV6mBNVW6YQtbFX/sRq+/rh/PJ21XkCTDf7 nrZXR9UHFbn7hf/z/f365a76ekc+vXz7FR5oPL/8+fKMBbIA7YgVXSqUXVr6Tv69hZ6/Eixrpwoc QZLyhJ6uNVpe3SbcilnXh6uApUjLvR3jocfhjDl0WfZzdMVQFyresJaqLlCeVHYPDMqWjBYFnotC 9htGdgPBy8pOu6hxLE7kR/h+oGgmGfb5MveTbSSlnJ38ysfzfe0N+u7t9enD8+sXvM39sUEmZLQk V0VUBIBQknLAq4Q7yFyRkrXYmYsE5UOlsbiw3/Zv1+v356fP17uH1zf6gDP70FJCuqw8UNMfASxc PK/OFsQ6rrAkibEXcQNvtzhQjxT/t7iElg5skAdGTnFg9hqdJn1azI7xylU+LuJ89PffeD/os9ND cTDkpwaWLDMLR4qRxWcynPtd/vJ+VZXvfrx8hgeXg3jxX/vSxgxAJv+VLRKApq7yXE8gXfPP16Dj d4w3l0iIEL3t2nuS2L8S5uxTYoXVCdkfbKi0WJ5r0wSg9xXnAnuETo8k0I2OEP0bAqwNsnUPP54+ i7nvLkJHV4EHDQ9onH91kygUAXj7lVpRJdWGJrbuDo2wqNB8Z5glJCjPTcVDguCWEgGx1AG6+2a/ YwJ1iAP4Rj7IyrzCWMw8GHevcJGNRcLPpOQ8LHm1Dlijqx4dFHOpennPaoiQb2UkA0+oHjTKRgnc JOv1Fr31N/CL0HeBy7CBYo3f6hpFoHb9Eb10GyGhEQpdLQNsop5vJj4KfIg5fRpo66JsBK9xcOKB C4hnnuF1L9a3+jZ0GzUS4B4fBgF2O2ygySzAW4a5vBn4BB2gxc4AD2esQ71HoLRSUg09lt3QvaSO oewYgd1NGoviWXeq8ua/lF1bc9u4kv4rrnnardqp4UXU5eE8UCQlMeYtBKUweWH5xDqJqmw5aztn Z/bXbzcAkmiwqcy+JFZ340LcutEAvpahh8pjlRGPXC/kc0KkpIYFrZcuL2UM9XZye3m6XG1dOUxz jju8fv5bFvaw5cxR5ezq5GNfsv55t38BweuLqbI0q9uXJ42M15WFetI8toYpVCU17qgRaZpYL6YI WmkiPPGoIaYkvtcTVRhxKoHkGAqhjlfI90wQs9CNps+AJNTu0AzE0YZmkMHmNvjojpO+1TGLSet2 ySmhUaIJo69IUUacrmRlq8p0kVKRYfTHO0NLJm0TjWE4kz/fv75c+wBvk+ZRwl0YRx3C6BOvl2Lt RLhZzFxx0CIz4FCaizC3vnmcPdIlHgrPWC9Yhkb/sWtQNUXAHwhrAaWL8QwYXxhOcq6b9Wblh0zO Ig8CFhtJ83tAbSYpsGAtQEhjj28+MC3KmoPKSM0DkhTf3FpPXUdaF21Zcmw+BqR0ex9icBHHDbYb x9wu7H6X7qQUJWvED+YxbirhD/FPgl0wppmIylIFriaDiGdsVEBI9HF6ebejktBpZ0XGKstJNPU1 fP16fjq/vjyf3+lCEqfCXXrm482etDFJbeavvAmBYlD2xNQzhuI2Dz0zhhD8XjiT35M0SCOZb/MI poIKr8NT7TwMjpVT6qzX05xGKpWPQ3JrKQ59+qwLxl4ds2/bFMdoR0kw45Hu2kysN0sv3HE0+kUG XVCX5H0rYu6W3n0bfbh3HddYc/LI90wAKtjCgH0VTAi66HFSazL/vg651tsZIK0XAW+YAW8TBO4N Hnubr41gVJhVbaOlR694iihEzEP20lfo++bAE8392nfJg1AkbcPAWtZ6lxCdQWpWXR+eXr5hSLbH y7fL+8MT4raAKrLnWCefMWNo6YasxmG8cjZuzdu3wHQ97mUmMiigO1C8JTcCkbEhcxt+T5JuuBun wFisliTp0llaSYHSpTuwa/BBephlCRdyjshZKwboyqX1e925Vin8cxxkbCaiG/6OOLDWa+6uOjA2 Juwi/l5srFw3M6h5YbxZsDfgYQ2VrzhDCoKvPY8hG3pAug1DE65aORLDPAxib5JVW3lOO5cVMHEx o0nQCygfBNqpxrO0CJ81ubP8OCu8mSKT4pRkZYVYF00SkbAs/VUmWhs8Ys1bL5gt7JCCtcTt1w/t yjXGdFqEXtva2ffnJ3xtwTJexbSxsyrCl6UTos9knjWRt1hxe0PJIbCVSNgsJ6nZpydgCrqOR0xB JLlzgZIUcz3L8xYziyzw/CU/U/CR+9Llvi2PKrD5zJNAICw8spwgacOn1g/M8OGNv3RoO5vMYLVC 6B+ryfOk6L64alDfOIgQsAyxPZ5XHr5/IaUW4RGWFsOswVsiVGS0sFOrQiPnNFelUQQkuJGMnqpu /7ku7QE27IGm3zPKfNl72WxzaKROvjEkxDn9UCGnA4bZnsKpqpPXUGL317yZqkTinbwJ/XeEZiom LwjtK1I1eZktctYuaaKe6nPbmJ65EI4JtKvIruf66wnRWeNT+qnsWih8Wqtgd+mKJRvkS/IhL/MF g6KtNuaVWkVb+ybIsKYt1+tJiUIh4vLXo5SA7yY3BHLYr84NCOA3WbQIFrSxGhhFzoIsXs2nbOH4 DqLMsRkhvgGwrS487ZauYw/yU1phJCIwiWdHsb502E74vVF2ywAzTbTd68v1/S65PprnNrBvqhMw DDNyRjNNoU9rfzxd/nWxTgrCeO2zltchjxZeQPIdM1A5PPx4+Ap1RgCTX1qQKzeggCi/TKzK+H5+ lkGkxPn69mJVvclC2JgeOoznV/JbSyWTfCkZoWHjlCzXZEOHv+3NmKRZ25YoEmuXV1Bp+NFeRYZ1 LfadjoYgUDRrx4IVTusUdcK+msE7JzIsKoeohE/u2wvf+rbTl/WmJV1jt7ls9MPlURPuYNzdRS/P zy9X0y/KC5hjNRe6F4SugTqZBGHEkSFd3B832jx1j0FUfUlDNYxigD2Uoy74Wq6OUeBwJGfK04xJ ssaqPs8jGwSLp7td+Ub1kIfR/6BmLD9zAmdJTnWA4rPnJMigD3+AsvA4WwYZC7Jvgd/EXxIEGw9B fkUyoVoEv7aKDBx+0xcsvUVt75+C5Xpp/57KbJa0yYG2ohtnSeG3gcFq6dqiy5kqqt0cEV05M0sL 8Db87IflzmejIcJqu3ao86UqG4SL57wvYrHwSNf3Jj4vD2a5azkx0FJfzgQQyJeeP8cK28Cdse+D NX1CAwYzIlvw5vZiY74+1+aTGR1lIPVTw9T4QHbWHqLo8xof+EGwohofaCvfndKW1FOi9LnVjiOe 562pOSxajz+fn//SZ0D2okV4CgH99fzfP8/Xr3/dib+u79/Pb5f/RfD4OBZ/VFkGIsaF/v35en59 eH95/SO+vL2/Xv75E4FFzUVho0ItWPcvZ9LJnKvvD2/n3zMQOz/eZS8vP+7+A8r9z7t/DfV6M+pl lrWDXaxjzj0grFyz9P9v3n26X7QJWSa//fX68vb15ccZuqrXE0ON0OHrrEklkeT6DMma4NJXvOTV axi3tfDYk2/JWgTEbti7y8lv246QNMuO2LWh8GCL7M1sDKuj7wQyp3kPe6O2YX7YpvxZa9rsfc/e hlvjfdrGSvWfH57evxv6uae+vt/VD+/nu/zlenm3rbNdslg4M84syZt5gRy2vuOyLlDN8syhx9bC YJoVV9X++Xx5vLz/xQyj3PPNPU98aKij/IC7LIe7ewsczzH94odGeObGTf2mg0HTiLI7NEczmUhX ymM8WnxAsc+t+q+1v0yDG8G6hSErns8Pbz9fz89n2BX8hJaytgE4DxYzbhrNnbE6JM8EZtQkalSn 1uRImcmRjpNjmBqlWK8cZ0qxzeWBznv47/N2SXxupy6N8gXMfIenWjaeyaEWHnBghi7lDCUHhCbD zqtncMZiJvJlLNo5Omt89rwb+XWpH5kz58bAMDPAzuwIxqhJHQ8YVcyLy7fv79wC/SHuhHXsFMZH dBbOjLgMZzo33DIwWhzjEDWsYrEhByOSQhAcQrHyPdMo2B7cFVm74bc5XCOwSty1SwkW+GYOFeFs vAgDjQQk6XIZkE/fV15YOez5tWLBFzqOeaj7USxhqQgzYycz7EVEBirKXc9xzEBckuKaEJUfROh6 JuhVXdVOQE28Pr/5wFlNTQM6naDzFpEZBDBsYcU3e0lTjE1HUYagsI26lVUDHWvkW0FdZVAwskS6 rol5jr8t7IDm3vfZwQST43hKhdkeA4lOs5Fs6e4mEv7C5XYTkmOeOffN2EAnBEujypKwtgn0aAhJ qxVvrgNvEfjcPu8oAnftkWihp6jIFvwRo2L5Rmuckly6w2yKeXHulC0JEMUX6DbPc4iBSNcFdUH3 4dv1/K5OI40VY1wB7hHehF8ckDVz5njvbHj3vT5Pz8O98QzdINr6xGTNHBqHe1jS7HiMfuCxjhi9 GMv8pJU2Waf7WtxiY5gni90Pq0MeBeR6jsXg/Esmm//IXqrOYQo508wV3ZoslEd00ucwDw8h/CcC nzgE2fGgRsrPp/fLj6fzn/TSOjqUjsRxRQS18fP16XJlBtmgAxm+FOgjN939fvf2/nB9hF3g9UxL lwE/62PV8Hdn+geo+u3ivMgtARl4YmQNFeerp3XwFWxiGWvr4frt5xP8/ePl7YI7walmlopl0VWl oNP111mQzdmPl3ewHi7j7RzTS+LyijwOPHN1jAWsIuZFj7ANFlTlStKaPZuTHBOdKaoWRCciwfVd SghsguvQ+dxUGW44bm6arG9n2wX6iNrbWV5tXOcX2zGaWu3iX89vaKyxK+a2cpZOzl2l3eaVR81x /G2b35JGrw5lB1jtif6IK2Ep03F/VLFOrzSqsF1N3V9lLsHHkr9pdTSNBgmuMl8lHMeECJYzPnhk +ZwXSy+oVU0jCRlU1sZWHFv/Bwv2ow+V5yyNPL5UIRiQywmBltQT+0J6/4rd66Oxfb1cv7GDQfgb GwHRVMYknR5aL39ennH/iPP+8fKmDmemSwbakNTcS+Owlg94upMxo/Ot65nAFpUKuzSe/+7i1WrB WsGi3hFQqHbjm7tr+E2iDaK4MdfRjvEdj9gogZ857aACh3a9+cn6QezbyxPiIf7yiMsTG+Ju8oTb IykPr1xv5qUUz/n5Bzrx6CQ3l2snBI2TUHRjdPRu1uytM7AW8q45JHVeqovxZPpk7cZZujOuGMnk z6dz2L8Yo1n+XpHfrmv+Bk3mWAYtUDzuWSy6edx1sCT6jmmVYVyZMVXhh9KaZllInMRMIVyJuMDU ZeB1hyyKo2lZitlEW7u84bLSbJk3ENA1G59S0uK2SZ3RtxaSOn04Sfg9hMdMSUm1IdjtSNMAEpR4 SLenhpLSfG8TWndCoVeCNBG0K/e+S3IlfpKKH2qS1fC381LI27Nff58k+Tb8PMuXgZK5qaOY6shF RNaH65tVdl0yBak5GywKZeRNH5qbfH6YisqijpjWJrWdDO6iaRPuSAh5iFTUxbkF+YIcGSx5HdiZ VS0fZRV5BuA9GI38LRkpF4XcWbtkaZAPBZZhMvSdIWsy28hrkmiBeEla5q2jKostKt4Uskm1LdSk NoFAMg0khSdDvlTe+Jn5VPkyxU7QpEkUVrMtB+xDzYO6SPanjNYLCBjmkxJPKQKq21+lQIb+0Z+7 1x/vvn6//DCiV/Vapv6o+8Hwx3W7lL2WFsaIsAFJTPEPEhwmZFP0/Q9zPMJ0lfV2rGdDJfhrY1qg /hK6E6neINBjQRZiaKGti0YApDE102KNG9jaeDpk4txbX9aXflirL+DMy/rjgFMGbRAnNOhjLmsg moRFPpLsolE7W03T908x36jMt2lBogOXZbHHm4NVdAATy7SgMZSarn2/37X7fCi2CqN7fGtl7uIx QitwyqgJjUGnQj3g8DIeaRNe2BxW3HV+zW2Fa17CVFSJDWAibmpyr+8oVem7GbK+EzWtF0ZUmq0W 3qidJlGKaP9pNtm9R3eMipqFMPm492qarZTKNF0eHSpYn8K65d1bWgr1x2zm6h6pRNruwno7LQQv id7I/RZUtpIYXpfbHSAZlXUTVHLUXc+j2FaHz5Pn1USShpTStFRHLKNUG5ZRkzUOIiEOQSZsRj9R p1UepvA+O3IXuZQUwgaaaTWiYB8PBQOfcGcEVGqpXhipbdjh8534+c83+Yh0XJMxAlINSxKwx08w iF2egkqOCRvJvf2CD+LKhuy/kD10NgpwKgdkZPQlMyHmhTiLWFU+SRQWKlBulKQnYnYAU92RhUwm ZMQ84j9DAkqyaQJH0n3KkJNgvUWOx3C6fZv1PNIemut6oWTzWnoi58Pim84YQ4Mw4t//TTHZCCir QzvNtLKVQLcayVNDrmAl2ZCp2FcylpIsjkkNe+uZoTFAQWJDdXzZXSFut2MhPB2zkdsJylwknmhI 3x0NjPlRq+uuP4uMTY2TWNa19SzYZMe3RrcSEbA61JN6DdwwO3FrKMrg7koFI9Jjmg6EtAWlM/Tp TB5q2ZjOCbXo8PQVS0ediYbFZNZhPCdQgUXJzKPeRmLqr7Rfd6pbD+EkrTE/FazBzKIFKOA3fxXI 17rZEayluptUTxkH/eCYMiafmp+S7bGDfKFax8bUMyZ3LVGdJ6UpdlS57pCYLqVt2HnrAnbJgrV7 icy0PZHFjYW88u1RPhW4UaQEc2RmJ9KPOw6Lpue2YibZIc55wMVeQA1dMS+kTBw0MeOZOKNyJsEG tbr98WFVHcoiwbgLMOg5VYtiZZRkZaOLo80ubVWu4TWc3kcMeHFjmVEmDwxxqzslnQAKj9Rp50s6 roMHMcMQRSW6XZI3JfGxWonTiP0MxZQj79ZnyHLEXENgjI4bDaHA1bEpaO3qUILjMS2sHg8lhRzf /EUxKTbAKchf7Yyjx5SUS5Y9SmcFOTuASkQivbEQU9lYyVqNMACiMFp2YDafq2TGXQhiehcYVwpK /1dycg7+LckbC3QPMnvcTYbFwLql3lUJchWf1/CDoT2dFybLn2FxTTpuvw/R3CDAa/noHHJ9WNCh taZr3Six0BKzWaWHhbNi7FPpNFLbnsnUlN4hd7PoKo/DK0eRONS2u502ztfudDoSkTBfBgtmiTVE Pqw8N+k+pV/GWktvYaQ291TjwhaqSqvE6gYE0nA983BGGQe4bdaO1y7J8+gWf9Jsg/tXmiXlHHOa r35uNWC5jyc9ZFdlNBQi4FjuOM3KTQgP+IFbqWGTdn7FkFTytOhZXTudutEQmybOoyUYaZVGLu5r cyP5sL2UQGH6Cdjj68vl0ci5iOsyNXx+mtBt0yJGyGETxY7yTNgPK5UC8RD/+O2fl+vj+fW/vv+P /uPf10f112/z5cFAy3YaUdd4iaYqbpxTpdviFKdsLM84NLxCxUmhwpk/pwc7iix9Zinv0xglyqhs uH5W4TK7ZHcUyTTvfv+cIMYtV2sqBkVM80Cc9LnS0VyaKbrAkV7EZcenVLbEDqs1TSsf7Yo45Go8 6Ju+XJuuPoLkh7sp+QmTLpErHIZ2N3prWH6tElQS9faiz208beyBWGWiG50pipOABt/bMHxaSD8c nuTSsxFCeabFa/jnRsFyx1mcatqq6lb5p7v314ev8lDdXgcUmLlxHTHHCAxgyG1D3mwfJRA30jh3 QkZ8zPPPlCTKYx0lPSIpyzuAGmu2Sdiw3F1Th5EJPSSX2OZA/Naa1u0bzpMwsEVzmGbUga3AZlbN QLcPAsyxbX/dfdrkfbHaLTjeDYffXb6ve5chW6Qt1IUzF5AlpHiFq571jHPCkgeBI38ooRe0HgsO fNRf8x+hlZx1X28qB4v5Yu46/CCUh9GhLT2mIts6jfdkkuhq7+ok+ZJoPlsFXcMKdYoG45urQ53s 05IcAJU7kzOXLt5lk8YBWhfuOFtqYBdpKfTgqsKoK3xyJ5l0QF7Nd4EMKZB19ljqxQR93iPSrkgk SFZXlDG3KKFIHkovh0YtmzLUW9UpXWGyUJYgQWgkZZsgVhglliZma5MMT1PhTw750CQP+uuYNSl0 cDs+AjCuYbKw4Ed8xL9fbTyu7TRXuAuHQAggfQbQDlk6eA13FXRS5QpUWWUoMpFaIPvwW8IOzpQn sjTf0ujzSNKguvzZhrwrCn8XiXmPwKSijTLPWef5LWZxi/lxhinrW2LIS99emwcZBp3TOOo4oijX I3YIiRLvz6MTIub1qxTA+AEzmYHOj83utXAT1QPLy9P5Thn4ZLydQryf1oCWEwjyJPi1SGBcBBPP OWkbrzOtZU3o2rBpyHFRz6hKkcLgjbj+72VEEh3rtPlspfc71hMHnEVHLV5N4gubSPXFzeUttev4 iR+2MfGE4O+pBh6bLN9GoD7IwVwqcI9hVXogg3DEH8FqAYnuZCMzG7mq1ues+EmhH37ZSh9utxCy 7QbCFE3YpBjZxxgb7aR0pOgYG92Jex6CAh+Ppem6bs0a25nVXMgWZJQFKNsElvzaVBAGp06qMK0p 61NYF3YJ8zfk9jvh8SMUTCVBp0lP6UrP3EAP5AFJttN+faL7eyls5PnyZE1R/91n5d4uQzHNKm2b YUhaFNLcNk8OVh2wSk1ZW6I+4ulDAUwZTGZSgDV6FDEU0AJkeRzzS3ZoWqQ7bjgWaTa09WhbeDIl I/6lLBLrq7FG5h6b//6kxUFLVz5F6bYq9F1l5plmSYdk63IvSCdFVH8GA5834oT8UrNZB9LQbmZu mrU9pmBwFAhIWITNsWZ9WztRlA20oplFrEisbpYcOTJJoeFsEmviyp9g4zXS1S0V6C6ksMtVDWQt iJMvZSGvFd8aNorY1ImJdb/LYV1xbYJnpYoaM+zIsSl3YkGGhKLRUQLtQAiRtVdWAWtm1gPopiz8 bI3SkQpDPE5rtCzgP3at4WTD7FMIO+FdmWUldxXHSIMOqXam7AIHZWuHPeIk8wTarqxI12vMo6/f zUA70OfjQm84OhQZFzE6jKW+ZLezOmdVSvx7XeZ/xKdYWjWMUZOKcoOnvGwnHONd3wF95nyG6q1K Kf7Yhc0fSYv/Fo1V5DAZGqtTcwEp+QqcBmkjdZzsQtgsgNkYg0KCneXCX3H8tMRATiJp/vHb5e1l vQ42v7u/mbNyFD02Ox4uTH4LX7eisca7JExWHEmtP7G5I8+22EbT9FZzKufx2/nn48vdv7hmlvaP WTtJuKd+BknD60zm7JZEbFcwmEEjmfiVKjrXIc3iOjF2CvdJXZhF9d5V/bPJq8lPTl8oRm8V94Mj yXdxF9UJidCh/httpd4dPm0QY5ilIpJaBsMpJjnbpUnzqazvTSmje+3uRl3iWb99+7dtgUkq/0oC WeITe4RQ/19lx7bcto77lUyfdmdyzsRu4iYPeaAl2matWyTZubxo3MRtPG3ijOPsSffrFyApiRfQ zb40NQBRJEXiRgDM87rJHJc1rjZRsTHIzUVcUBex9ZSx1a8YOm7PvQJ+9gAU1akDKDJnWmIl34EF qjuZTUwVVYJETMD0x3nvkOZA8a2dht0kbEzmWExLWX8X5HtujBe74v50B4HDJJjvpK37ZaztRVaa hyLqdzO1j7s1NGTxaPRNATp9aVVyj3gxc9ijBh20Clsae4qMZoUlh0UrU+xCBAhmKBlB+MmWQCHj UxbRGQ+SfFFE8ATVI+HvZQlzdJIeNqSA6KUugMHcut2Pu5e747rOAoh03Cg1wEHg5rI+HhCCBrck 7XtAEqsCRBFzPhsL6dOZWXsBfrRCyJJSBroVcw2IOfvBDvPlsxVxbOO+UEWvLJLzs5Pg4+dnVNaW Q3IW6Nf5Wbhf52Q8q0MyCDU8GgYxn4OY0yDm7EA3RzSztomoKHWL5OLzKPB2qxSq80xolBdmjT27 K19O3bGAiofLqqGK2lnPDoYHFgIgqYRppGFVJITdn/adAxo8DPWRyp4y8cHBhRZ5ix/RHflCgy9C rxn8qYOD08BEOHtknovzpiRgCxuWsggPRVnmgyMOBmxEwcFuXJQ5gSlzVguyrdtSJAnV2pRxGg5m 5NwHC+gVy2J3/iQqWwhSPTGHSfYOzPO5qGZuo67WrlFxYh2Tws+gIF5kAhe4Sa5BTYZXHiXijtWy KqoOSqCs/ry5tnJjLP+xqjO6vn/bYXbw9gVLHxhqui3Z8BcYq1cLjl5s2yMKak0lQCUF4x/ISjD7 TS+R15T2mfC4hXcDhN9NPGtyaFCOjZJRSCN9FiJSNIbC06oYccormbxQl8KUqYZn2oFMqGa0zk1g BPzMxNi6l8p9rLmZlCmBLph5epxUKV6nUYANgHchxeXl6Ozs86hFz9iSwz9lzDOYL/TeoMkuVaGI WQaQR3QABQZmkoydS5ekzzeSNCmsshlPClrNaAcCCw/2zQ0xRI1pxqC+4J0TdmyAS6UtBTrQwSPm 8gqDjxGzZRT0snrE0hUKKxyjEvBAZcEvT4LElYhrNoaZrWawwuvq8uIQ6RAWoto08OuOXw7PRj55 qr4HCceD6Gy6KOh5lBTojhFJHbh+yCFmRcGzWDkYk8C9de0TdZ7mt+QZYUsBrTFYMyXR+xYlZ4rs vUXRKpwfeZurrgcItC+a2t8OITCNCtSJiuxmkrO4EJSXtyPBsj/UB2QTTIESFKuQFl8OZkFSUazC RDeclYnl7ZWOaolGLwdPmkmOgS5ZnlHH7wFq0/X/p5YlFjgJyOmEPk4yjLwsxlb6QZEv6oC9rzsY KqPoMOePdm2KlI554UsyEE+71whu1otnjwY3D/kSj7RdWx+jDhQ7hkXx6dfq+QEL3x7jPw/bf56P f6+eVvBr9fCyeT5+XX1fwyObh+PN8379A0X58ev61+b57f349WkFz+23T9vf2+PVy8tq97TdHX97 +f5Jyf75eve8/nX0uNo9rGWtlF4H0PcLA/3vo83zBmsobv67siv0ggSskb0i88nt7DmJwrwtlFPd cO1DEo8YY24CtK0tGyGXaO54mTdoRqOwijGIxtqzBJr0YgaG16LDs9OVUnd1p7afN8BTpJ/JPIWo brPIDaaSsJSnkSmuFfTG5KcKVFy5kJKJeAQjjPKlYfGjdoUqtnKm736/7LdH99vd+mi7O3pc/3qR pZwtYvhQU2ZGR1ngoQ/nLCaBPmk1j0QxM/MjHYT/iJYVPtAnLc2qCT2MJOy8GV7Hgz1hoc7Pi8Kn npsRN20LmGblk4I5waZEuxpuO78UakFHddgPdm5X56xWU00ng+F5ukg8RLZIaKDfdfmH+PqLegaa fbvsirdvvzb3f/1c/z66lyvwx2718vjbW3hlxbymYv/rczOKq4ORhDHRIo9KClylxPAW5ZIPz84G F+1Q2Nv+EWuU3a/264cj/izHg2Xi/tnsH4/Y6+v2fiNR8Wq/8gYYRan/GQhYNAP9kA1Pijy5tUuE dttrKqqBWem0HQW/Et72hyHPGHDWZTuKsaye/rR9MI/22neP/dmNJmMfZgcFdVBKv+66MSYeSUrq iFMj8wn1SAGdDD9zQyx2sBTt6+vbZT0Lz3EMRn698L8Oxyt/26mcrV4fQzOZMn8qZwrojujGGZGL X6a2VtBW3Vu/7v33ltHnIfEREexBb25IDjtO2JwP/a+u4P78QuP14CQWE399k+0HZz2NTwkYQSdg TcusYX+kZRpbxbfbvTEzb//ugcOzEQU+GxACbMY++8CUgGH4wjj3BdJ1odpV8njz8mgVVeu2d0Ws EYA2gfDx7uvk1xNRzQ7RRCzlSSKoWNSOAt067tFBjzuj9j3AqVuVWi7O/SUzkX+DvI9gbWWh8tfd 6fdXTH2dTwSx7DS8H536DNunF6w4aGm0Xc8niX2mq7nWXe7Bzk8pWZ3cUeFwPXLmL+C7qu4uZy9B 598+HWVvT9/Wu/bGC6qnLKtEExWUFhSXY3kh34LGBHiSwrGKSn8wSaLa110Q4QG/irrmWIOgtFxS hk7TUIpni6B1wQ4bVC47itIO2SLQsI6X1MG2S6p13mBTPJOKVz7GBJWaMsENTbaN/zRV9F+bb7sV GCS77dt+80wIF6xFz4hdJWvUKybdlkuh1mRPdWBtApHajUZLIRIa1elPf+hLT3i4OxQfQXgrTkCF RJ/a4BDJobEExVI/0ANaGRIF5IlEpafE8GeU9gMWXZpy9FhLHzcmSlvmXossFuNE01SLsU12c3Zy 0US81O5xroPBe4JiHlXnGKi3RCy2QVF8aX1hASwaF/iw4bISU3QwF1wFS8oAT+2g71Y5XsXwXWrR r0ffMRt08+NZVbu8f1zf/wQT28gnkyEuTV1i+GzcHisY7/Pw1eWnTw6W39QlM6fDe96jUP7Z05ML 00GbZzErb4nO9G5C1Rxsr2ieiKo7B6Gj4D4wEe3bxyLDV8vIyslldwNFiFEof0BhV3PTsGYM5hmw /ZIKTscgalYCbTa1qkewNui16w8oOZgZZMxlW6EJ9J8swsOFUtZZMJeNSZLwLIDNsCJVLcwghBY1 EVkM/5QwtdAFY6vlZWzua5iolIPhmo6hjz1YHSeZFd66slKRcLMiqjotdKKwuacjMOVAmFmgwcim 8PXhqBH1orGfslVy+GknFtsY2Ot8fEsdJloEp8SjrLxmNe1QVRRj8tATcCNLvYrsX8bBNLA43/KI DBPVNTWk+9Znx7Du4jy1J0KjQMGSpWrsQtYIxbw7F36HTBdkq62/3Sk54kBBnSNaRijVMmhtJDXo cjSc7h9oeQS5BFP0N3cIdn83N+aFghom0/wLn1Yw82tqIDOPJntYPYOd4yGwko3f7jj66sHsT9fu MeK0ssQr1kFRylO7XF0PxfbM7TWOZtYPmQpcyyvtzVBIGZi+ZIkTS86qKo8EcIElh3GWzDodlXlR Zm43gqzYtww7BhAsxiNPFM2mS+gM4vD0tqmb0anFoRADQ0lYiQcoM15a9ox8GF9X8XpRSGIr9aDH o7sX0ZO89JgTTRWZxWc7EsTCIiuIziAqy7MWIc+lbWyHKvI8sVEl96h1ZHuL6Y8/cLKwelIwGaed 6kMiq5omamUZL70yOXySW34k/H0oWCJL7JDAbvXWeSosjpiUCzcEIkrumpqZF0iVV6hZGv1JC2Fd MRWL1PoNPyax8TWw9gTmB4PMNBNI8qz2w0ERakfhI9n5Ox05rpEDOnxMYkfvgQsHJPbLO3kbkMRh MZkEX+11h4GwztxOmQSpyERz+j5yRgt9OfEaG5y8D4INVYsMh+fNWjYYvg+HXlvAMQajd7IGvO6A efEUlldIzB1eTZ3tUAEDsDYDHgWawUP5+CubKgWyu6/AUensA7pWO5bQl93mef9TlfN/Wr+ax3Z2 Ks5cXrtCjEpj8YzM1MPkWZ4skyBTkOLGPLOOVOWFJsmnCcZgdKcpX4IUVwvB68vTbgNom8Jr4dQ8 GcWTeGRjszJvAjsVw0raMcQYlW0xl9uMwX4NxlVZeO9GVjCzxjmaV7wsgY5OYwl+gM6ztPm1/mu/ edIK/askvVfwnR9pNQERxlW64uBkaMwGxi8VILuwKkxKh2mUnMXS7wBUxGhnHGtXY8oQfFyTG+mJ Bv6MMWSpqFJWmxLWxcjuYbalPdkqD1FGB1xzNsdQMJQ7tN3z0YmR0yi9Xpv7dg/E629vP37gMax4 ft3v3vAmP2MKUzYVMl/ELHFtALtzZeWluQTuQVGpetB0C7pWdIUxcBlI397cNLIx3Zlpo9bpSPSO CE/tJF2K+eYH2gkEd8gwMSni59PYknr4m4ouHFcmQ9IH6xIK22uRxdZgTDi5ChVBNRMTOjZD4WOx lIfzB0gWGSzoaBaMB2t7ktPZzgrNwf4LTdI8QgpUtEViXzf1oQVnfzkVHeN/Lszn8U5udLhB167F rpEv8psar7onIx9Uu0jmqjw2ovVC9kfd9jvy64w8RZbIIhdVnjmujf4FmLob7BqINOAYxBbQCFLz CpBiIMifXqRuFKvciWixdtymjcNSrDMrgMHGAw8DFtaWfghRORM98GRYwqiNJxehXj1gcyTANN03 /AmOASNS41DOqsHo5OQkQNlF00wmwdYwPbapIpMd6BHI0J4FymxDLoDaG2sUhhDKqEnKzJBNLKGj 01pyXKfxZepD5ImnrVd3qHJMAIspmPRTYtH17w2uIxh+Xt7K4CN/asD0QJPVk5czMZ05lmL3OeWc YH7tBBg1OZc+UvNdXK2w7YC7y0x7+KrSmOSVlULoMRBvyc3w7gPvxBjpj/Lty+vxEV5f/vaixO5s 9fzDzMpkWOkYJH5uGaAWWIfFDmwk7kTMi+sWIUY+oTHLa9gpVlhoPql9ZDeKLlzYJJTvCCiBNHEX vGtMD76smWEtz5pVlDV5fQUaDug5cW7p5YcnT0XQgyrz8Ib6C8na1YYJpttJrD4MMmF9XnUbbEa8 xl5j+B3mnOsryJSnGGM+ekn2r9eXzTPGgcBont726/c1/Ge9v//777//3a8EFf2JTU5xUXrGZlHC QjbqIVjgkl2rBjLg9Y4okXAcWHBTlmAELmp+wz3GXsGw7IBSvY1p8utrhQE2nF/bEff6TdeVlUKr oLKHjoSVQbi88AAq7ntw5oJl3E2lsSMXqzinNrIkycUhkj7AfHDqvUiAJEtYCXYWX7StDf0BWZ3X MdHSpwGTw3nhc0/9adUJqxbbtN4n5wt2MQbuhqy1/lMQTu4qmgSf743j/2MVt29V0wf8sJUQ1gh9 eG/79jBp8sg40qziPMZYUumn9mdsrrSC4LrWeNCgQORWXQ0yxV1+KoXzYbVfHaGmeY9HQZY1rz+L OKg9FX/AV6Q1LFEqn0apUz03RmUHlHZWo99PXgIr3Ahei0sGxuH2Iyq5jiGvPFkFC9riojZriQx/ prloDAcyqHZ4Lw4FDz+BJWmsp3rrGp/DRUHb3oDlV2RRofYyRGs87kyAzFGmc0kYze0OY2AURLd1 ToUoZHmhumfIWLXwI5tX4llkf429BvIlenKR3uLj8Ad2a91U1wLtfrf9ApTzFJYCWMQSBUZDZgbf ee1pgCFHeu9beG4rhtfhBFJTZFoXesGdWqZyDa1297Qk1qxPxNI7Xt3ejXN6vwxGc8kO6LBxu33T T1evX/fIoFBBiLb/We9WP9ZmB+aLjM4y1NsPnU7QM5F9Vc4Xy3pLaTKiuXwiI8LDTZvtZrxWNRs/ 1rYuX0L1cMJE4ho9FlIZkVK6/rllIo1NtpGyOW/zEN23Y76jVkbDnZigLPrA+ymnjupBGrUdCLzF bsjwqvoJWrYdANp/lC/1Fi7sK6bAGMWj7VqpVTKyi1yeh9ai4rFvr3vDpdzzKhPev1gKwVRUFb41 zqMFvJkM+FXScizUErJ0V8eP/T+efUvMb5kCAA== --===============8077519654652772254==--