From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: multipart/mixed; boundary="===============0639716199728192149==" MIME-Version: 1.0 From: kernel test robot To: kbuild-all@lists.01.org Subject: kernel/sched/core.c:5370:37: warning: cast between incompatible function types from 'long int (*)(void)' to 'int (*)(void)' Date: Wed, 31 Mar 2021 14:15:41 +0800 Message-ID: <202103311434.dpBaRaX7-lkp@intel.com> List-Id: --===============0639716199728192149== Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git = master head: 5e46d1b78a03d52306f21f77a4e4a144b6d31486 commit: 826bfeb37bb4302ee6042f330c4c0c757152bdb8 preempt/dynamic: Support d= ynamic preempt with preempt=3D boot option date: 6 weeks ago config: x86_64-randconfig-r011-20210331 (attached as .config) compiler: gcc-9 (Debian 9.3.0-22) 9.3.0 reproduce (this is a W=3D1 build): # https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.gi= t/commit/?id=3D826bfeb37bb4302ee6042f330c4c0c757152bdb8 git remote add linus https://git.kernel.org/pub/scm/linux/kernel/gi= t/torvalds/linux.git git fetch --no-tags linus master git checkout 826bfeb37bb4302ee6042f330c4c0c757152bdb8 # save the attached .config to linux build tree make W=3D1 ARCH=3Dx86_64 = If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All warnings (new ones prefixed by >>): kernel/sched/core.c: In function 'schedule_tail': kernel/sched/core.c:4252:13: warning: variable 'rq' set but not used [-W= unused-but-set-variable] 4252 | struct rq *rq; | ^~ In file included from include/linux/err.h:5, from include/linux/kthread.h:5, from include/trace/events/sched.h:8, from kernel/sched/core.c:10: kernel/sched/core.c: In function 'setup_preempt_mode': >> kernel/sched/core.c:5370:37: warning: cast between incompatible function= types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __= static_call_return0); | ^ include/linux/compiler.h:58:52: note: in definition of macro '__trace_if= _var' 58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond= ) : __trace_if_value(cond)) | ^~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__com= piletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_comp= iletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __CO= UNTER__) | ^~~~~~~~~~~~~~~~~~~ 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:2: note: in expansion of macro 'BUILD_BUG_O= N_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BU= G_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_= type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5370:3: note: in expansion of macro 'static_call_upd= ate' 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __= static_call_return0); | ^~~~~~~~~~~~~~~~~~ >> kernel/sched/core.c:5370:37: warning: cast between incompatible function= types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __= static_call_return0); | ^ include/linux/compiler.h:58:61: note: in definition of macro '__trace_if= _var' 58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond= ) : __trace_if_value(cond)) | ^~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__com= piletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_comp= iletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __CO= UNTER__) | ^~~~~~~~~~~~~~~~~~~ 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:2: note: in expansion of macro 'BUILD_BUG_O= N_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BU= G_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_= type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5370:3: note: in expansion of macro 'static_call_upd= ate' 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __= static_call_return0); | ^~~~~~~~~~~~~~~~~~ >> kernel/sched/core.c:5370:37: warning: cast between incompatible function= types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __= static_call_return0); | ^ include/linux/compiler.h:69:3: note: in definition of macro '__trace_if_= value' 69 | (cond) ? \ | ^~~~ include/linux/compiler.h:56:28: note: in expansion of macro '__trace_if_= var' 56 | #define if(cond, ...) if ( __trace_if_var( !!(cond , ## __VA_ARG= S__) ) ) | ^~~~~~~~~~~~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__com= piletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_comp= iletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __CO= UNTER__) | ^~~~~~~~~~~~~~~~~~~ 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:2: note: in expansion of macro 'BUILD_BUG_O= N_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BU= G_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_= type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5370:3: note: in expansion of macro 'static_call_upd= ate' 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __= static_call_return0); | ^~~~~~~~~~~~~~~~~~ In file included from include/linux/tracepoint.h:22, from include/trace/events/sched.h:10, from kernel/sched/core.c:10: >> kernel/sched/core.c:5370:37: warning: cast between incompatible function= types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __= static_call_return0); | ^ include/linux/static_call.h:118:39: note: in definition of macro 'static= _call_update' 118 | STATIC_CALL_TRAMP_ADDR(name), func); \ | ^~~~ In file included from include/linux/err.h:5, from include/linux/kthread.h:5, from include/trace/events/sched.h:8, from kernel/sched/core.c:10: kernel/sched/core.c:5383:36: warning: cast between incompatible function= types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __s= tatic_call_return0); | ^ include/linux/compiler.h:58:52: note: in definition of macro '__trace_if= _var' 58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond= ) : __trace_if_value(cond)) | ^~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__com= piletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_comp= iletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __CO= UNTER__) | ^~~~~~~~~~~~~~~~~~~ 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:2: note: in expansion of macro 'BUILD_BUG_O= N_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BU= G_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_= type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5383:3: note: in expansion of macro 'static_call_upd= ate' 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __s= tatic_call_return0); | ^~~~~~~~~~~~~~~~~~ kernel/sched/core.c:5383:36: warning: cast between incompatible function= types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __s= tatic_call_return0); | ^ include/linux/compiler.h:58:61: note: in definition of macro '__trace_if= _var' 58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond= ) : __trace_if_value(cond)) | ^~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__com= piletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_comp= iletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __CO= UNTER__) | ^~~~~~~~~~~~~~~~~~~ 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:2: note: in expansion of macro 'BUILD_BUG_O= N_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BU= G_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_= type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5383:3: note: in expansion of macro 'static_call_upd= ate' 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __s= tatic_call_return0); | ^~~~~~~~~~~~~~~~~~ kernel/sched/core.c:5383:36: warning: cast between incompatible function= types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __s= tatic_call_return0); | ^ include/linux/compiler.h:69:3: note: in definition of macro '__trace_if_= value' 69 | (cond) ? \ | ^~~~ include/linux/compiler.h:56:28: note: in expansion of macro '__trace_if_= var' 56 | #define if(cond, ...) if ( __trace_if_var( !!(cond , ## __VA_ARG= S__) ) ) | ^~~~~~~~~~~~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__com= piletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_comp= iletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __CO= UNTER__) | ^~~~~~~~~~~~~~~~~~~ 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:2: note: in expansion of macro 'BUILD_BUG_O= N_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BU= G_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_= type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5383:3: note: in expansion of macro 'static_call_upd= ate' vim +5370 kernel/sched/core.c 5336 = 5337 /* 5338 * SC:cond_resched 5339 * SC:might_resched 5340 * SC:preempt_schedule 5341 * SC:preempt_schedule_notrace 5342 * SC:irqentry_exit_cond_resched 5343 * 5344 * 5345 * NONE: 5346 * cond_resched <- __cond_resched 5347 * might_resched <- RET0 5348 * preempt_schedule <- NOP 5349 * preempt_schedule_notrace <- NOP 5350 * irqentry_exit_cond_resched <- NOP 5351 * 5352 * VOLUNTARY: 5353 * cond_resched <- __cond_resched 5354 * might_resched <- __cond_resched 5355 * preempt_schedule <- NOP 5356 * preempt_schedule_notrace <- NOP 5357 * irqentry_exit_cond_resched <- NOP 5358 * 5359 * FULL: 5360 * cond_resched <- RET0 5361 * might_resched <- RET0 5362 * preempt_schedule <- preempt_schedule 5363 * preempt_schedule_notrace <- preempt_schedule_notrace 5364 * irqentry_exit_cond_resched <- irqentry_exit_cond_resched 5365 */ 5366 static int __init setup_preempt_mode(char *str) 5367 { 5368 if (!strcmp(str, "none")) { 5369 static_call_update(cond_resched, __cond_resched); > 5370 static_call_update(might_resched, (typeof(&__cond_resched)) __stat= ic_call_return0); 5371 static_call_update(preempt_schedule, (typeof(&preempt_schedule)) N= ULL); 5372 static_call_update(preempt_schedule_notrace, (typeof(&preempt_sche= dule_notrace)) NULL); 5373 static_call_update(irqentry_exit_cond_resched, (typeof(&irqentry_e= xit_cond_resched)) NULL); 5374 pr_info("Dynamic Preempt: %s\n", str); 5375 } else if (!strcmp(str, "voluntary")) { 5376 static_call_update(cond_resched, __cond_resched); 5377 static_call_update(might_resched, __cond_resched); 5378 static_call_update(preempt_schedule, (typeof(&preempt_schedule)) N= ULL); 5379 static_call_update(preempt_schedule_notrace, (typeof(&preempt_sche= dule_notrace)) NULL); 5380 static_call_update(irqentry_exit_cond_resched, (typeof(&irqentry_e= xit_cond_resched)) NULL); 5381 pr_info("Dynamic Preempt: %s\n", str); 5382 } else if (!strcmp(str, "full")) { 5383 static_call_update(cond_resched, (typeof(&__cond_resched)) __stati= c_call_return0); 5384 static_call_update(might_resched, (typeof(&__cond_resched)) __stat= ic_call_return0); 5385 static_call_update(preempt_schedule, __preempt_schedule_func); 5386 static_call_update(preempt_schedule_notrace, __preempt_schedule_no= trace_func); 5387 static_call_update(irqentry_exit_cond_resched, irqentry_exit_cond_= resched); 5388 pr_info("Dynamic Preempt: %s\n", str); 5389 } else { 5390 pr_warn("Dynamic Preempt: Unsupported preempt mode %s, default to = full\n", str); 5391 return 1; 5392 } 5393 return 0; 5394 } 5395 __setup("preempt=3D", setup_preempt_mode); 5396 = --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org --===============0639716199728192149== Content-Type: application/gzip MIME-Version: 1.0 Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="config.gz" H4sICFEIZGAAAy5jb25maWcAjDzJdty2svt8RR9nkyzs25JlPee8owWaBJtIczIA9qANjiK3fXWu LOVpuIn//lUBHACw2E4WjogqjDUXCv3zTz8v2OvL47ebl7vbm/v774uvx4fj083L8fPiy9398X8X ab2oar3gqdDvALm4e3j9+19/f7w0lxeLD+/Ozt4tF5vj08PxfpE8Pny5+/oKne8eH376+aekrjKx NklitlwqUVdG872+evP19vbtb4tf0uMfdzcPi9/evX+3fHt+/qv7643XTSizTpKr733Tehzq6rfl ++WyBxTp0H7+/sPyfLkcYUnBqvUAHrt4fZbenAmrTCGqzTir12iUZlokASxnyjBVmnWtaxIgKujK PVBdKS3bRNdSja1CfjK7WnrzrlpRpFqU3Gi2KrhRtdQjVOeSsxQGz2r4B1AUdoVT/3mxthS8Xzwf X17/HOmwkvWGVwbIoMrGm7gS2vBqa5iEUxGl0Ffvz2GUYbVlI2B2zZVe3D0vHh5fcOARoWWNMDms hcsJUn/WdcKK/rDfvKGaDWv947N7N4oV2sPP2ZabDZcVL8z6Wnh78CErgJzToOK6ZDRkfz3Xo54D XNCAa6VTgAzH462XPD5/1acQcO3E0frrn3apT494cQqMGyEmTHnG2kJbtvFo0zfntdIVK/nVm18e Hh+Ovw4I6qC2ovFEp2vA/ye68Jff1ErsTfmp5S0nV7hjOsnNBN5zrKyVMiUva3kwTGuW5P7oreKF WJHjshaUHDGipS+TMKfFwBWzoujFDSR38fz6x/P355fjt1Hc1rziUiRWsBtZrzwN4INUXu98TpIp tCqjdkZyxas01BBpXTJRhW1KlBSSyQWXuOgDPXHJtIRjho2AGIIuorFwEXILSg9EtKxTHs6U1TLh aaeLRLX2qNswqTgi+Wfvj5zyVbvOVEiI48PnxeOX6EhHTV4nG1W3MKdjgbT2ZrT08VEsh36nOm9Z IVKmuSmY0iY5JAVBHKt5tyOtI7Adj295pdVJIKpdliYw0Wm0EijG0t9bEq+slWkbXHKkdJyoJE1r lyuVtQORHTmJYzlY3307Pj1TTJxfmwaWUKfW6A10rGqEiLQg5a+u0M4bLVmycUzhWZMQ5jiIGMTO 4PfMxTpHbuw2QbLNZB+eTpGcl42GcStap/QI27poK83kgVhUh+MdbdcpqaHPpBmt3QQ1PYB6tKdp jx7I8i998/yfxQusfXED+3h+uXl5Xtzc3j6+PrzcPXwdibEVUls6ssROGJ0tOCabCEzsgRgE+SyU a8v79CwrlaI6SzjoWMCgfQLkMHSVFHWISgTKXonBeKRCoaeTksT9BydlT1Qm7UJNOVnD+RuATSni GocFwafhe+B6yhKoYAQ7ZtSEO7djdMJLgCZNbcqpdhSSCIADw8EWBfplpc9fCKk4KGPF18mqEFaP DIcXHkroZa1Ede4tU2zcH9MWS3e/2Xl9nv4rahw0A6MmMn11vhyPWlQavGeW8Qjn7H2gz1pwjZ2z m+SwF6sge1FRt/8+fn69Pz4tvhxvXl6fjs+2udshAQ0sg2qbBhxoZaq2ZGbFICpIAotlsXas0gDU dva2KlljdLEyWdGqfOLcw57Ozj9GIwzzxNBkLeu2UT6rgY+SUDLqUN0Z+PgZE9J4MFL2QLxnUMLR G5GqeHVGpr6H3DVmwObXXE7aU74VCQ/UuwOAqM6qhn52LrNT8FWTzS/dug7jctDfBH8DVNLY1iKl VageQadVlEZCLzTEBR9R0rhwag63n5vr4BvOPNk0NRAfjRW4VcH5OK7GUMduhDwA8DgyBVsE9QR+ 2RyRecEoC7UqNkgW6/tI33fEb1bCwM4F8jx3mfbB1Dh6Oo1HRlAYRUGDHzxZeB19XwTfXYTUr7iu 0X6GGgcErAb7WYprjh6C5ZZaliCyIbtFaAr+oMLP1NSyySGG3zHpqcwh8gi+Qfkn3Bpvp4BjjytR zQZWVDCNS/I20mTjhzMg43cJ5k0gVwXcsOa6RF+sczIpe2OZYeKEZrCZ1HdanY/nXCPfwqHajb9N VQo/0vbOnRcZ0CLk2WjDFNMx8PSzNlhgC25e9Amy483U1D6+EuuKFZnHF3YvWaD+rKecUSpN5aBK PUUsPA4UtWll5MSwdCtgzd25UnI+hnxINeueZKnZeTkHmHHFpBS+YtzgaIdSTVtMQL+h1R4dCrMW Wx7w0pToo4Hq/SVE+90PcnCtGKWZVMJ4MhwQFEoBoQjZaNoyDYfpthxNj2Zv3DissUp6hukFXPEg 5LO62rYSpwwj8TTl3ixOxmB6E8dWthFWZraljVlDHj1bBskM6xl0acnm+PTl8enbzcPtccH/e3wA n5GBz5Cg1wjhwugiktO69ZOTd57HP5xmXO22dLO4sCEKZnqOLtrVYOeCZBwDussNbToKtpoZK9A7 RU3nP7A/kFeuec9i82joFKCXaSSooppSCyEaZjbAIw4EWuVtloGz1zCYcUhEkIFXnYkicNesbraG VvnECHOfPfLlxcoXk73NXgffvql02Vk0AClPQJo8Oapb3bTaWGOkr94c779cXrz9++Pl28sLP625 AfPde4KektMQ9DqnfgIryzYStRKdT1mhf+7SA1fnH08hsD3mbUmEnm36gWbGCdBguLPLOBERGAuv cVBhxlIkMEJDEoMVYiUx65Ki80IoFoxKcaA9BWPgOmEOnlsrT2AAg8DEplkDs+hIoSiunc/pIl/J PQfGBk09yCokGEpiXihv/WuAAM9yLInm1iNWXFYuawamWYlVES9ZtarhcOgzYKvn7dGxwuQteArF akS5ruEcwFV/7yW6bWrSdvbtjAKvR+UsrXemzjI4h6vl35+/wH+3y+E/On5pbdLSI2QGHgZnsjgk mAv07W2X0zBNflAC6GxKdxvRS+/axXQFaL1CXV1EYRQskTvZQMrxxOUirQZvnh5vj8/Pj0+Ll+9/ uqDfi/2iwwg0S9kQagTlPuNMt5K7oCFUCftz1oR5LmwtG5vKJIZb10WaCT8wlFyDXxPc9uAQjrHB uZRFPDrfa+AC5CzCvwowUa4KUzSKMheIwMpxlDE2G7wglZlyFaRe+jZnZ2ZGHfihS6hDDFq0VFRT l8B+GQQZgxKg3KoDSBD4XuCsr1vu5zrhkBnmpqYtcbiHq8q3qE+KFTCN2fYsMx4Xr6irErC70aQu Z9y0mMkEXix055WOjsU2p8xRv7JpnizG6DMYw4i/w/nlNboSdi3E6CyR1bDQMVew+UiyRtmohAag X0ZfKYHtIi32oKqbNjxuS84KHUunh13u5tJHKc7mYVolkUCUzT7J15ENxjz3NmwBayXKtrQSlIGO KQ5Xlxc+guUNiNpK5VlpAYrRCroJ4jvE35b7iQrwcsA2r4mRJC94QhEHFwIi4aTRC1i7Zua70X1j flj7mbq+OQEXkLVyCrjOWb33b3nyhjte85DTMpDlNQNmEzW4EVQy3Rotha4amK0VX8PgZzQQb5wm oM4ZnADGBlh1gaY9vHOxfIGXvKZTrD5L1USj5BI8LBfMd9fVNj+AV2IRY4SZgK4Jc4sFX7OEyo10 ODHp+uaAdH0j3mypHPT8FCSq34FFwnadQ/wF292GVsyLDL49Pty9PD4FeX0v7ui0fFuFQdUUQ7Km OAVPMP0+M4I1FPWuS0Z0jvPMIgPZ6UJS8JLagoXXG46kTYH/cD8tIj56ngA4CSBiwTXi0BTTZQQE lBmbgSpOMWVBlsbSx9cGnQUWacwwH6xDMsMpqZBARLNeoaun4q5Jw1wtiNIioQwynjFYTJCnRB78 K6MIANre+s2rwyBlkZ9ovQ/XgxFu5ACe6W4VWW+8MTcQZxRQ6ZkN8psrzxkpV6AoFb01x1vTlqP7 eLz5vFxO3Ud7Lpj+hAiiVpgWkG0z5RIUaDSPZb+oEdF1j1UCXkDjtcHOU/2lloHFx290JIWG4EDO +lAQ3tAX/3gQ00A26KsgTJoFtqWYczidPHZ77Txc3OuGHyZs5XC12ltKocf+A3dwRKU8HgIvLLOx +1rvgyRbJsg582tztlxSLt21Of+w9IeAlvchajQKPcwVDDP4anzPPdtgPzHCowI/B2xaucbswSHu pfzE8tDkLp492yuZyk3a+pVRQzgDki4xcDrrGN5Pw2POAuWSchP7/hD5rivofx7IizNUsVYNzFqM sq+r4kAebIw5e8+dlKmNokEMC9o5rFORHUyR6hN5aRtVF6C4GrwrC5bcN5KXuKcCuglhWZqaXvv6 MKcIe5HKQZ0UbXyR1+GopoCopEGDpztPnMDSeQN2ZS17m+as9uNfx6cFGMSbr8dvx4cXu1iWNGLx +CcWOHoRaBfLe5meLrgfb87GYKkDqY1obP6UYpzSqILz4E4G2lB2bTvdZcc23Ba5eBzstXa1fWcj AwbQdeJ3i2aeCxABlBTeoe4+OccCtEgmEsHHXPUk+9FFlXigHmzy1TO2lTHYQ11v2iYaDEiX6y5j j12aNIkGAUbWYCLd2qxnpKYpOItpd7r2He2g2XR3OMHgTSLd+uKlNyIevier3yb51tRbLqVIOZUO QhxQWl29lE8ZC2IUB1nIimmw24doqFWrtW+TbeMW5q6jtozFWJqlk+lT4B7aplpS9BHVPIpoSkHt YNACbmaU07YBGU35ZA0BdO40Jsl0t8AEiVLTcTjA4W/NQF/GRO+0Dri7YRTjqLyakom+i3dztAri cdBnOq+nByx52mKRHSbQd0yiqS+o8Gbkf9ZwT4rC9u7yL2IhAMwTKG00dRffHw/8HXJlg6nAupEQ Zs56JaA4+nh21Iyh59GXRy2yp+P/vR4fbr8vnm9v7l3kNJozTAzI8HLJLxkieg8Di8/3x3isuKYt GMt1GGzZDw2EHXz1+tw3LH4BdlscX27f/epFf8CBLtjwFDC0laX78EIf24J5kLNlYHMRPalW50uQ gk+tCG+Hem9eMRD9gFDYlJYM4/CZCKbycs7WVzyobOVHjTObcxu/e7h5+r7g317vb3qDOc6NKZoh jpzhkr2f33a3E/G3TRW0lxfOxyq5X4bXVxgPPcdlT5Zm15bdPX376+bpuEif7v4bXA3y1LPu8IGu uX+UmZClFU5wSqI4ocNISxFGoNDgrvdpZKPw0UHJkhy9NXDn0DMH2rukZzD3ziTZejrWmBuq63XB hzVOhEwfvz7dLL70m/9sN+/XVs0g9ODJsQWqZ7P1sgGYE22BVNdR+gD1/Hb/4ew8aFI5OzOViNvO P1zGrRBRgmW+ih5A3Dzd/vvu5XiL/uXbz8c/Yb0opxP/zTn/YcrFRQphW58fBS6zZnU44dpdUFK2 x55BDx+H6ltQH09V4cbdvRDD/Q4RiinYigdpavcsxYaUGPFns481OkQbIlCIHdrk7sfuYnTq2sqK G9YyJWjfI4cMs9tYW6hFZVZqx+KXGgJOFS8diZu6DTnzBi9WKEDd0O3dMPjYJaOqeLK2clE4uF2g QFwuL+BIixZUyowlIXbEHFzRCIjKFB0GsW7rlrgCVUA7e9XgCuaJWBa0mcboq6vSmiIo3idzZoBd 3qqcHLpbuXs15G64zS4Xmnelov5YePmohls9Wy7uesRDqhLDxe4JT0wDcABAqjHUwbu9jlPQ2MR4 rmKEJA++SZrtmO/MCrbjyu0iWCn2wJ0jWNnlREi2zA9Yq5UVaFg4+KCYJy5FIbgBfTIMn2xNoru6 tD2oQYj5+6oS2R1RmH4YqRYI/QkoUUlUlq1ZM8xLd14yhqQkGAuIKZSOu5w0uBLe7vomXkynEjrm wsg9wuj6uTuBGVhat0H4M+5T8QQt+QlQVwMQaEYHOVnhZQ+/AE6Jhp7cSY9K9B+04znU1eSQrHwJ DVa9I7q9Mo05I5m+oTgFtnf7miXxDn5Y7O/UMVnxH0hTjdzaxnVarrmMm3sdWWFyGs0F1i8Q7DCL R0zluBDgWIEVJwBssYQFYqYHPARJM1CdWf2oD5N9pH02nSegBbx4DkAtJh7QpGF1JEoYoXktyOaP g+KUce6gWCe2q3uhaZMQ9hrrf4hxveKduUF8FGKoDmzRsS4xXqZj1+7t1NRWwskIl3MbypxGjC76 CJV4N+H785Vw15vUwSG5TcTbVNtoBDWYWt2/YpS7vS+gs6C4u6M72Z0CjevFgkoIbbrMcGgWB+cI LHjgAY3ZUzAmfnEgebXkFWJO75d6UvVu3jxk8jDZ2aTJO6WJpM3VU4eZva5wEsS5r5h0vnlSb9/+ cfN8/Lz4jyuc/PPp8ctdHNcjWkeoU0dg0XpXmnW1G30p4ImZgi3js3JM5oiKLCX8QRTRDwWatsQy Z19ubHmvwpLR8Y15p1F8qnccZa8kDJbjziXmEautTmH0vtipEZRMhlfXxewlgMUU61NgFGDJ1cnJ kPg7cMeUQuMzPNUworRsQgUfFYgIqPFDuaoLNVXF9tXVkAgeH6YVUSZyiA6rs3GQtnJcD6oeLDCe 5USJjLlpXaP/C1EzIcL29XFqh4mS7jGK3FEIyL0Y1WPmt2BNg6fD0hSP09gTonRTX25tVjzD//X1 3iSuuwjaSRjcd2vHOwkrb/zv4+3ry80f90f7ew8LWwTw4gXHK1FlpUYL52VAiiyMjO2i0H0datPR Ik7eh3VjqUQKX2d1zcAkSThk5xAPIjm3WLuT8vjt8en7ohwTctOLmlO34eNVesmqllEQChn8MNDl nAJtXTZocnM/wYjDH3yWvG7Dxwa4YqHqofDCf0Xm3YNRhdjuEsxegLm6nbEEE01wFPlaD0xylIHA E/RvyIbuGOyaXsH3A+QHe3kHIUdcee2q5uouE+kFIV74NWZBFFWk1jOYPVn3ajqVVxfL3y5pKZ6v WwwhxFQzPuz4pIzyXVmxYwdKr5HYpXuKQgbgeC0ZZk+CGuRNcEuXQABT2Qo8qmoteNVXsrikcmjK VNiIpdLq6n+CM/P8aGKq66aug9zU9aqlbj6u32dBWdW1mj7r6Nus13KiXtFWJfdZJc/pTPu3BdMw atCTjS1ID4MKV8W6jcK7Xq8r9xYdupisYGtKsTdxcQfQzFb3xW+iR3+nbeZ/YsXmbPDax7IEZrzJ rHGwJxvK+Epsg/LSR96DRp1XmiPP6d5WVMeXvx6f/gMOlKdaxz3CGXMym1gJz1XGL7AAAfPatlQw 2tvQBX1m+0yW1gSSUHyZCWSge6YgWfjbC6QDItyWx7uKxr3fwx9xIIcDBBBjfJ0I1h4LGKnSZ0Bq Kp877bdJ86SJJsNmWyU1NxkiSCZpOO5bNDO/NuOAazTWvGz3VK2oxTC6raoox3yoQN/XG8FpariO W03fJCI0q9tTsHFaegIki2H5PAw8y3mgaGbyQBY6bNdvRIaMmnTS9M3h8G3azDOwxZBs9wMMhAJd MG9Esy3ODn+uB26jrEyPk7QrP3zrzWYPv3pz+/rH3e2bcPQy/RD5/APXbS9DNt1edryOISNdp2aR 3AtdrJM06Uzcgru/PEXay5O0vSSIG66hFM3lPDTiWR+khJ7sGtrMpaTO3oKrFNxYg8Xy+tDwSW/H aSeWipqmKbof/ZqRBItoT38ervj60hS7H81n0fKS0Y8IHJmb4vRAZQO8Myfa+EMzmIYt2cyrxR4H 3EabBQIjWTbRj5f4yC7JS0JXzQkgqJc0mVkn1mIlMwpXpjQVgEz0oTFNV5EW5zMzrKRI17OXh1Y1 qOB5U9dEDrYtWGU+Ls/PPpHglCcVp81YUST0exGmWUHTbn/+gR6KNfQT0yav56a/LOpdwyqaPpxz 3NMH+ifL8DzmfxEjTahXsWmFd0IQUOFD6W8eMYB8DKOKLTlY3fBqq3ZiUuHYHz/hV/jrtD8jOGsH ymbG+LnfmaCnzNW8B+RWCg7uLEbxHp/roR6fw/ok9fwEVaJoi9/9VgfiNFLQv0Tn4SQFU+r/Obua 5rZxJv1XfNraPaRGpCSbOuQAgZCEmCBpApIoX1iexDPjWr9xyvHsO/vvFw1QJAA2pNQePBOhGx/E Z3ej+wHHdlVzeLagMp46HzVg/eBJKH04/MS/oRdbbz6ef34EZkbTunu1Zfi0M+usqfS5WJVchV5s vQg9KT4guOKyM2hENCSP9UtkGawj7usb3UFNbDfadPcUU6SPvGGFvbwfK95sYZklU0esM+H78/O3 nzcfbze/P+vvBFPMNzDD3OgTxDCMxpZzCmg9oJbsIKjYRu+6LtSbe466GEPfrzzdF34bC4KBd/AG aVVPfVSd3uQRrBlW77oYGGC5wfuzlvp4Cp3EXBl4g9OwE/S8FUEYMaju49fqhaGbV7j2T7BTVHaz 6lOY2imtbZ+3lfBaaYSHMEOYP//Py1fEt8kyc+mYCKa/9LGyhnUsPC3aUMD7DMtgXX20kOhfcRii sQPHDjxdoGNMCn706Ia+dk25MVfpLQIpE6hE1sIrxqQ4zsleWYZmnIWlbg8+Czw2sDb9EvOIYxNl 1No7Lj4Yp0CJiapAMX5/Ya9cWBTG8VXtsZMRSGArhM1hhObxcvIKPyqApmdJnEbwPd5UGXo1md6A W0O9cCbBMCFPZCgNDZwW4v0NHL80MJaRNSn8Bz+Je69g8IQMd1BI+/r2/eP97RVQyr4Ny7BfnD9f /vx+BC86YKRv+h/y7x8/3t4/XE+8S2zWCP72uy735RXIz9FiLnDZ3f7p2zMEAhry2GiAVpyUdZ13 cJjFe2DoHfb924+3l+8fnlEJNpcyNz486OnrZRyK+vnvl4+vf+H97S+BYy8iKUaj5cdLG6chJS7e Vk0F5cSfjJBibvc6yrF9CkqwdvH+Mz59fXr/dvP7+8u3P5+9hp8gchifp/ntXbrCRegsna1w+b4h NQ9EkdGP8uVrf2TcVOF1yt7eVO9Y4d0weckQc7fzgIIPStS+x/g5TYtZ+xKFXVSkzElRubfVdWOr GVxvDZrhufcGn9TXNz0/38c2b45mDLwbsXOSMRbngE7onGWtashQCXzI0Owxn/Hhst+LtH7kO1+Y enWfT/6pP23f9kFgs9hPB/9q7CzmmXtWlxpR/+BW3sJDXWJghyZifLAMYKvui9FaFDgCYZuz6B4q 2d3vAWJcBYAGpgRirjT7cozPJlKMzX9mYueSzpLSCFpgIqQiWMtAPuwLAFRZ84Ir7t7TN2zrXQDY 3x13cTH7NH2M80niMZkkCeGCkJ0LbB6mBeo5n4MsPqVQ6vjfg3OpcW0yE3TjYwHoGcpKygbEOt+J YbqEh8iEb0Yo9HYXsYMgIRxh183iyNGVFmzpRD86j0CJQpYIHydd/zQDK6cH59P7xws0++bH0/vP YA+HbKS5A8CNiM4NHOegxwmXw6M71mANGB7nctIhWd9auDM0zgafPyXRAoyLtHEBctHNpmxwtQM3 O+6YTT/YfPFe/1Of3AByaqHF1PvT9582gOGmePpfT6iHmqoqgBtVuamVwyWunkZW7Z/0d0PEb00l ftu8Pv3Uh95fLz+cw9Pt1A33v+wLyxkNlh+k6yUYIqD3+cHKYgzEVTlpKZDLCu4/IwMGDGuInIfb LntNOimgcOjx2aEZt6wSTKGoz8BifeLKe60052rXJf6XBNT0InUx7QWeIGlBKVqyxD7QhHfrM+pC HxGRy+laA4o+VrE3Bc7kveJFMHeJCBKqIIGspY3BGaGH49PJSqxPP36AiaRPNMYEw/X0FUKFgzlX ge7dQp+CiThYp+B44O3jTuIkfsilnQO8Mx/RwGUpmPNOiEuAoTUj+znFyNsakE7ARSEYAD0sd7dt gwLxAJ3TXWu718vG5DptIjAFpofus9kiLNbjkHSdws11xJoILCVTH8+vUXKxWMy2bZQcaD8epReL J2kdKavyJKr9ZB+wAAaHRm8G+PliCikI4NuiZ9a1CWbBpZ9f//gEAv7Ty/fnbze6zP6cwxQHU6Og y2US7+Ri0hxvcgRUd7tQebjMACxDVQqQCMB65vq69FQt1cgeGS9Js16lfPn535+q758ofGvM+AM1 5hXdzh2rqvEFLrV0Jj4ni2mq+rwYO/d6v1kTrJbf/UohJQivMttcyYCCJsJ7PRAcc2y4wrNNQddd ot1CEULawvm0ne5u5Nj1rbEn49O/f9NH8pNWAV/NJ938YTe1UesNp4kpP2cQLxWuiykfjdkpBg7R 8gja15kD9pvIzDJ0B7h4mpk0ABg4kQjEy8+vyOjBf+zjI9OS9CBUGHTa2Cdc3lcl3fHJsRaQrehw 6cr7UibjUOlv3CHreq3OM8p6RFKqZ/efej475o4wP6MUbbdOB5vCjggRu8IMedcRrAysHcPVAqwn 09qi1t948x/2/+mN3k1v/mV9elChzbD5s/zBvCF1FtCGKq4X7BayXwfCoE7ojoUDoBXsWoZhzdY9 LEU68zsIqOAGiQfTnjm2xZ6FFRuIwSDSuUID2APsiJqCdNxjQowWFZuEabelD9BR9ncQndBTDmBL pprM+9vH29e3VxdzuKx70Au7Tx4Ewwx2XvqwJh3trS9OC1+yagDrQ86Lwyx1A0ryZbpsu7x2Yy6d xF7bHfX8vRAn0Fhxa9JaQPhf5I6XlCoigCi+EWbbx0ulcjVP5WKWIP2tFdyikgDcB4hQnPo+9Dut XRfYzkfqXK6yWUrcuxQui3Q1m83DlHQ2ppz7UmnKcokQ1rvk7s5DPjpTTJ2rGS4i7QS9nS9xS1wu k9sMJ8mYQOGaSOM+hC3gJ7edzDcMAwwB3+tOK6QeFlR9qEnJMXaa+tgp9reeM7qRpOnSxPSX3U5Z DdLoZCu16R1RqaMR9YkW9GWSLEh7m90tvdskS1nNaXuLzRlL1uJ5l612NfO/r6cylsxmC3wP9hvv mDzWd8lsMpH7cPp/nn7e8O8/P97//pfBAf/519O7Fo4+QF+Hcm5eYVP/plfwyw/4pys0KFDL0Lb8 P8rFtgXfqkXAXcZg2dXe3csZtQyXWAaq/rvCoFqc42CNtgcREYq0JHd8wLMyusOvzc0kJgWFKNyY rHWe5zEtZaDvpQeaviNa0dNqCkfHxtuNvctMng+ChQRXiV46niwHIEJEgnsEYxkc8/NeBtAZ9jk6 xthNMl8tbv5z8/L+fNR//+Xd25yz84aB2RHtpjMRLDAn9IsvVuP0N6F6LlSArWbst5j1TWubFq44 eFclfIliXZV5TKgypxVKgc/Y7kmD+waxBwNHccGHWLGYIkco+Frh87+Okg5tjALKS+QGea3Xyj7H TVjbiFeZbp8ML7XG7wJdroq4Mag93kCd3h3MyJgnFiO5D0xhkr913DDu5I63VVmICq9Mi2eBp9hZ q/14f/n9b3igVtp7OeIE6Hnq+vnS9BezDIcGxMNbH3BnHhz0Gas3ljn1bTKsmEdOZWPWmNPlHe6z NjJk+IXdQZ+oDBch1KneVShsjtNSkpNaMU+m65OMvWvD0ZgXt4At8xcgU8k8iTmNnzMVhII25aMC ykLrg+g1gJdVMT+0iVAWyB/OfZc5uBSKzO4WKsijG7LkkXy0LZFnSZJ0wfR1BkznnePCWT+YpaCx xQ1wSu0Wvd9ym6S3o1L5N8fkIQKR5OZrKP6JMJUrH41MFTEvzwK3ZwEBX+pAiQ3PtXmyb6rG/06T 0pXrLEMRQp3M9k1NfyGuF/g6W1MBGysuFa/LFu8MGpt3im+rEl/yUBi+Xi3+YKhHuhkxBdP/YBog 361LzHbv5IEMwYNZ+kjAHH68TAe+9/pV7fYl3F2X8MAD7kfnshyus6wjtmOXp4nwFPxhH/oqIF+x Y4X0vQT7pE7hc3wg40M7kPE5NpIPmKXBbRlvGt82QWW2+ufKfKdaKvW+JtwWkSwmfNNbYLTt4Ek5 XH4q0dAtp8DcP0ps1EyBwh67uXrHxLGiIo08XqQHP/S/mpYHkHHMU+LWLL3advbYGxqnpM3+C1fS ewG038w34vAlya5sYxZbDS15tydHF4jRIfEsXbYtTupR0MehxmGXIXkW8s0i2tgWd3HV6ZHlyttY lvAMGymLaO34TvpFXBlrQZoD89/jEAcR85mW91u8fnl/wl4ydCvStZCy8qaVKNpFF3EL17Rl3Iil qfJ4kbw5XmkPp40/Ce5lli0i78Nr0jLRxeKxOffyUWeNqbtBpVVoj9fdcreYX1kDJqdkAp/r4tR4 iKPwO5lFxmrDSFFeqa4kqq9s3IxsEq7ryGyepVc2WP1PeObaEz5lGplphxYN1vGLa6qyEvjGUPpt 51ouhEDwUsvbAGDZhdLKtIRsvpohOxZpY3JOydL7qE2kz12H+hbS8oM+e70zxb4Aj2t8Tsbq3vtm QLq9cn7ZaGLdF1teBpZeYlAx0U85MXCD2/Ar4nLNSgloTZ7Fq7p6pj4U1dZ/IOqhIPO2xUWVhyIq ROoyW1Z2MfIDes3lNmQPVi7hyWkPFEyZsUC+Rlwd3Cb3Pq25nS2urJqGgRbmHe9ZMl9FYuyApCp8 STVZcru6VpmeB0SiK6qBmKsGJUkitGThObBLOMNCNQ/JyVxcQpdQFVp91n/+K1iReBGdDrCt9JoK J3lB/P2HrtLZHLsJ8XJ5a0P/XEWeXtCkZHVlQKWQFNlXpKCrhEach1nNaRKrU5e3SpKIUgTExbWd WVYUvNVa3BojlTl8vC5QQi+CXxjefenvKnV9EnpCx4RTvTnjsj/ErZWRs4ejzzE5jTiVVS19rIj8 SLu22AoU2N3Jq9hur7xt1aZcyeXn4B2ttbQCsbcyEt2rApPGtMyDfybon10DsMX46ampB0BH4yh+ iFPskT8GSAw2pTsuYxNuYJhfMyHY+zC38P6GjLQ8vo32PEWh+/rqALW8CWwU/XoCQlrj7qqbPI88 wMLrOo6tINfhuypjpbtTLMYNhOn+qcCJobWmEnOBGsIiJlSnxjrytDmuLu7luo+0NDcEbocBSaus +GAA8V7rWBF7HZBrtiUy9GV26I0qsmSJ99tIxzc+oIN8nEXOf6Drv5hIBmRe7/B96li4jy/Ar9Gq K+yRi9GUZ3TVPy8EgGnqciITooUKFxnDJTlmOIR6NlogpOCpr5DUSO5pP7sK7ifxyd1wKfyocKTQ UZPEiEzLtNE+ddUihNwQP/LSow3iEUaUHCe4sQ1uuorwP55yVypyScaYzMoSC0RqyIni6+IYu7gS oF7g9rHeitJFYkbss59dXDuBC0DJMZdI2BicyNdRXJc5cvf5/cffH9ErVl7We/d9M/jZFSyXYdpm AzhXhReoYykWue3eh5kyFEFUw9ueMvjrv8KbEC/wAPgfT56jTp8JHgLVnz4prE+HYON9G6VK2jCt RrSfk1m6uMxz+nx3m/ksX6oTUjU7oIkWLszp5JhDqc1wz07rykbEjZaIPk1vYdjB6ZDr5TLLxjYE lBVGUffrHEl/UMnMf5zMI91hQoLDkSa3M6TUvAdxaG6zJUIu7vHGgGsm2hTjIw7QBhEAi4FRUXK7 SDBHF5clWyRY79kZirVXZPN0HiHMMYIg7d18iQ2EoBJLrZskTRBCyY7Kt7oMJADaACMavqMMbL1+ d6lLzu809zjuSDOkqo7kSE4YaV/io6lE2qlqT3c6BSG3kRkJprLOf9vu3Enq3rydgy73MdH81BtD iiR1pKgllr4++QEgAwEsGvr/EYFt5NOKCqkjb10iXFq5C1wwRyZ6ugQaOzSMb9i6qvC7gpHNIPsh 0cETRlbAWUhRn+Sx/QwEE9/E49RlRpujsTYD0wYQ9vrr7wnxIGKDOXSYR5Cs4aSYtkbrqgUzzYm2 ZU3FcnW3CEukJ1KTMBH6JnT/9CnwF61qYEK/4SDbtiWTOsPNsP/gYQIFFUb5tBiNNGw44QB3zJHA zikdKYme+hhh7q2UMT2P3GKMDJgkPZBptW4IUt92k2Lt2zauxOkldwKl7OG9VuE69w40I1MTqtAP kzxnRw4Xr5ear4RvHRzLNhbgy11zJE3Dq4vlC7I1lzBI6w0actWsY6Q18e+IRirg1175rCPP9Q+k 6McdK3d7gs8FuZwlmGFu4ADZao+OU1u7KP9ecrfZxCi9lDptSt02V+blRnJyG7nMM6vEAM1hm1pP hm3GSpFj65xEiBzQ0r0fUO3Ss6wW2e2sxakkv8vuVpdovsOqT/fmpEcCrbUTqF+Fx7fXkhdvKW9i Ja33aTJL5lfKMVzpKlYIKJBVyTpOy2w5wzHTPP5TRpUgCWqBnzJuk2QWrfqklKwn95FRzkUQlYVx BGeFy5KT1WyO6eMeE2zfTYVXsiOiljseawNjgQnTpW1JARhT5ti80gbW0rm9QkeIo1cAQtxWVc4j 03mnd1P/4VaXyguup0nE+8Xhk7fydHeLe6p4LdmXj9dGld2rTZqkd5HeDC4dfBp+WePyHAlcOx2z GRqyMeWMrmWtUiRJNksiVKq33NhgCSGTZBGhsWIDT2XwOsZgfuA0XrKWR2apuL9zX6vzNkRWGiCT SI/nqtuoZTu7xenm3w2EJV2g6wM7QoV47/l82XZKRnp62O6wQcpVdte28WEyBtlK1JXk/lPVIZNd ilfnjzHSkjKA7YuyziNRRQEbj0BoTRqp9s0a8yULGc1Ci/dILij0dxKZoKZJzYWJZhjy0Fw4aQQE t5KiOxcU/axtpSpcoQs5vwAEBCbZT3qqqC6OdooJvyHX4wncInj07LBDAhjFi2Ug10f5zRL9tcEm 8hTTmSYLjKs0mcfaqYfanDHXZo7mS2ez9sKBajkiW5MlRjbunthxHh2YRnQo2ol30vCC+a86+9SJ IoZxqSQ1L7XiZSixud6MfbOISjCyzW4jwK9ej9Tydjm7u77nPDJ1m6bXJLpHo9jgnd9UO9GLfPPI 0fEgPQ8/r2RecsW9u8fe0sNlzHuDL/Bgs93T+zeDFcV/q27A3O0Fgzbu6YXEuwYc5mfHs9kiDRP1 f8PIWEugKkvpXRK5/zcsNQUTE9LdllzwtbVmBdkagrnJWVrv/e9ZwfrKZCq89+b7DA31ufsrCcdQ 7fFbk6ybYR901pYI5gdBnlO6Ui6XGZJeLNyvHJKZ2Ceze1zaG5g2IpsFLP1VLDYFhigt7ELERoH9 9fT+9PUDsOzCIGKlvMdtD7E3HVZZVyvfd8EGbppkJFNhoNEBpAvw0D6fw+Ke31+eXqfh6laKt497 UDeEoydkqR+UOyR2OasbZqCXHHAhhC+I4HZJye1yOSPdgeikMoIs5fJvwMaCPT/lMlEbcxVptPtG i9dKFwHVJbCWNLH2R+72XBZh5GrMeuZylU23N4hYC4zawHORgg0saEWsVazMUZ82rwOOeieIfU9+ vPo9jUoz1F3bZSpqGZkMgg8zsnz7/gnSdCFmaprY2mnEps0Mn154gCQBITrsA8PQx0nA4QsOTqJT ZtgXX9BXk3oiGMH5A5LLEs7FXuprSWnZRvw7zhzJLZd37YWxWFNxO29bpCE95Vda0h8CXxSB+M7I g9ce61W2iDGtJzd17BTTxI3UvVhDDchXjcRf+TDDzctNwdqwxT4jLOHHZL5EapR1GPE6IPZ4221Y IlVNcTbO+6QS0H8Ah9M9LY3npQpFA3qiBclRhGdRtcT6fxThBUALnoaATxdx8D+V1Fy8biOv8KDY yGW3ywtHmR0uA5X7DKyb2j8nhaywsttGIC/K6rESaPV78BXzD1QD0qhl6xI7L3aHMx4mMqhwoT+B ZhxPbfCGKRVWah98O9mJeC24lgbLvHDdZ01qDn+Meq8LGgIgCHU5UZ5t3FIALcLesmLmZFOqcTaz NxIb/4lYIEs+KVRKjsVUGdqRwOMG7j2ObQdgcleuNX137J/nRZLMoyNatPPe9xupga/SSCDew8dD 8pos5on7FSPpwLGQPZfeY9tPKC14igXhknUNQbXefOwd98DB5+ZrXMAbVpJ7WQ/ww/DwxcKzs42p C1fYok268BWY+vycALrpRNvkrP8jQUFk4XE25nlR6pR7wVBnoYOH4aUZfQl9V7PgV9c/vziO1jnx jCiOjRgpt3TH4P4Ipo6j5VH9V+OTzE02fFyGhgGbOmWDu9XADc8l6ZOCl0HktEsv94dKRaLsga+U qIZPt1ilTmVOKnWv5yDhoADuvqna07TNUs3nj7UL+xJSAvsjK2j/TuvQ7pYXxSmGUjvVbRxVuh+O Zi+VeWXNQjNPXclSiniQedAptOamfyutbWy9dzEh1aiVAK3lJ4cwlCZtp1k9ryudKIzjl8V6+vv1 4+XH6/M/+ougXQbRD4H06LNNMOAmDIWii/kM8yM6c9SUrJYLbx/zSf9crOD/GLuS5shtZP1XdJyJ GD9zKZLgwQduVWKLYFEEa5EuFXKrbCumu9WvJc+z//1DAlywJKg5tKIrv8SW2BJgIpMLZBWnzbno GlxBWW2tWs/RwTicJ3XRZc1uny+BLyCT+ZAMHowX0Y0L5g2jQP/j9e39A5/xMvvaj0L8I96Mx7ih 5IyfV3BaJpEjXpmEwU/BGn6hHW6zLJYL6yJBBZkjrpEEqUP14mBX12fsu58c4MPlVJiDqRU3bO6K ytdmfDTjYQOFxUnNoih1dwXH4xC/mxrhNMYvDAE29msT48ubtWzAomBfZYiyClqrI/Lt77f369eb X8Gj9uiZ9B9f+QD88vfN9euv1+fn6/PNzyPXT/xACi5L/6lnWUBECl1XBzJXvOtdK9wrmS50DJg1 +J5rsGE+Iw2WPHvgam3tCDRnZOd4hwhsFa2O7hHhcG4J0F1FOzWerFiYhf2gWWu+fs0tcmTGamp4 TgGqfPxhdXn1F99pvvEjFef5WS4kT89P39/dC0hZ78Fk6oDerAuGpg30pvT7fD9sD4+Plz3Xh3Vs yMCk8EgNat0+jE6sRPn79z/kgjrWURl4+qga12az9aPhIhrAcLptdC20xqwzws7ooDkkjVEEDhbd /gNnFtgCPmBxaQ/qzq+kCx1XAx127BujBCxaJR63R/fPzn+uvNdohw44bHWf0z5/eZEO4WydADLl yj68K74T2ipej4lHXNEuA0lBxnVmLvN3iCzw9P76w95Ph47X6PXzv9H68Gb4ESEXodLZk0mEFLsZ 3yyB9bwzPOT7K092veHDms+3Z+Ewn09CUfDb/2hvlaz6zM2rW7jvUNpbt1Q1uAcG/j/lomAMJ7EA yrEERtWYJSZliejnxokIZjNxYNNp0QUh84iuepqojbCzH3lnmz6t0zbCDzR9/3Csq5M2Jke0eWjP lpmtwWOclOf2Nly/brK7CqkNPyAY9t9zdbK23beQbKXEoiozCNx0hwi0ao9VP2iB7Ueoau5u4eoV rVJFaT2w/NDvbGxX0bqtx3RWjeui+qC6nzLWuUQB1G1dNcjYaKpT7agRO7R9zSrRMzY61Lu5OOnA ms/Zt6e3m+8v3z6///iCPexzsVhDD05NGTKM2CZp/MgBhC4gVcY+rDTyU4BOEA6BIZzQ6DM48gOV 4zI60jUS1f29/nxLzlPT/ljkwB4YGlldgIU8oukpgHg5YrZPAhYPJbzlICcdKH99+v6da3dCm0FU BNkYWna4si3g8uSKsCpg+DTkRudFDNGCdM4atZaQTctJzJKzJRFatY9+kLiSsXpvpzmeSYQr8QK2 FS9DUpftaBCjR7XH5Cx3KL4J/DSi8NV0tSe2iW98VzJkNJDEjbrOUxMY+qhHPQGf6hZ8Xupj+nJi flxsiNre1fbMJw5Bvf71ne+qmtI3hqgwXl2pVD1wkTKyPbv7gR44myQuD8KzkdlIHYvRMxQY+lBr hLckSswMh64uAjIaxSp6nSECOSm35bpo8pJXwKeno1FI0T+wQXyQO1YGBNt5FJlETasXJPPUIohN RxJLROZ6OzYTTF5IbAlNACR2dsNwamLtRleOLErSdKNNJFs2c4w9S2bWAua8ppBiHVwvp2WD+Y66 X5k7IgwlvF/38auSiamSXAFuQCS4+rIIA9NLhRL/D5MA2KchEhhTIaiAjy8/3v/kWqqx4Ghy2+36 apcN+94cAVxfPnRq76C5TWlETDJRqP/T/72MBzL69PZudNbJn+I/wwPBPTZkFpaSBZtUGTY6QgIc 8U/a1cECOc7zCwPb1WqDkZaoLWRfnv5zNRsnDpQX8IOJBkGeGJjxkWEGoGG6xT7KQbSmq4CI8ZVn 6jMkjUO3M9QTY1e0Godqf6YCxIucuYbYYqpz+O7EmN2czkFciSPPMbpmjoR4eHsS4jsaWqnmkzri J8jgGQeJor+LCL59xdBHMHN8367RPuKq9LUwuyrb7YmiXoC6MpOM9jkzKwuISM/ngvIhhe+xJA0i M42IqGjQxrTqI5zlKz0/Be3gAp1v8l6M6bBT6uIUeKpOP9GhY9QX0iqdaLqBhqwVJRgCLCnL0aip YyM4qiaS7tR6M5GVaX4fJC4HXnOV4EkLNmcmBni7kGjbqYEEDoRvOgsytcR+LzUhXNfhHRWGWCfW rIOSViQkRo2HJgaNI8CV2InFsVQvmQt5o5kPYRxhXa5UzN9ESWI3GJTJJE5DFOG6CpakC2L9HdaE 8K7e+BHe1RoP6iVL5QgipGAAEvV8qwARLxcHiO7IT4VSslYPRvNwk2BppVKY4l89puG3yw67Cr4D BukG19FmztE0ZpWpHyIvdLnOldXqh3TjOOTNrS7TNHVYek88p7opsIEo1tZFxuLn5ViXJmm8QZY3 AtLa7+mda06Y/ekYzCWvh8Pu0Gs+Yi0Q2xZnpjLZ+Bs0OSBkNSn1vcDH0wKEaSY6R+xOjDue13hQ B3Qqh58kjgLSYOMyC594Bt78/4ZnvRKcIw7wSnAIPTvqHMqsnQEWJkjMn4wVSay6spiBMwSsasHE imvRDVabOwJOwFdbe+d7H/JsM+pHt3KjXxcdLcGXaL/DA2MswYq6pmLUZfk4tTvH/RAvDF1VlYhc hnOHDt+SxajvvwX3UUGXVdPw1Y8iyHTotsqqozsuDdzUeRRq4nOVeYslFvc/wRbX7xamKEwiTEGZ OVhxSxEBbQd+0jkM2aB/qZzgXRP5xGHSO3MEHqNoYq6dYSZnCh7YNbqtb2M/RANb1TnNUMsrhaGr zmhSfoS1FGCkp6LVYQaf/mCG2LWGazib+qnYoCsDnz29H6wOQIgYzXUaO0+5a6IDTUKJ49GUxpUi q4sEkC4Bgx0/QmYDAIHvqssmCHCLZYVjgyx+AojRESChtfUY1LkA3RMAib14bcsSLH5qV0kAMcGB FOl5Tg/9JESkDGHEYnxPFVCIeaLVOPAxJSCHM0GNJ8VVbb3mDgVuZiq6kCsGazVtzn21g03JFsFQ xNEGkUzVbgM/p8WsTtnl9glfbta0nYbGITKkaBKi44kmuFKoMGAfExQYGRQNJfjopWS96gSfSpSs 1wGdzBSdyTRFpZNGQYiqiAJy6Og6z7ocu4IkYbw+qIBng367mTjaoZB3aTWTN5RWHm0x8HmKnwVU niRZWwc4R0I8RH4ApB4ydtuuoIn5pGRq1pZEKTZXOt1j0ZwAJ4O6G8ROfTr4YCTnVXPpttgHYmX3 vBTbbYeUXbesO/BjfsdQtA+jANOWOEC8GBFX3Xcs2nhYEtbExA/RFbyhQeTF+IW7tokla4cazhES H9l3xg0CW5nE8o9VlyOB51rnOYLtmnKFJXgNws1mg+dGYkLQNbHjDV4bzR2Nk3gz9MhIO1d8v0PX qvtowz75HsnWtnB+2N94fJvHMuBYFMbJ+iHvUJSpt6pyAUfgoVU8l13lr6oYjw1vHSJNlg+sRsi3 A67McGB1s+N4+JcjYbG+eK7ZkM5HC1pxXWJ9265o4W9Wd0bOEfgeug1yKIZL1rUmUlZsEooM5wlJ 0WEg0TxM19Z1fjiJYvHsjtI9ojAIPEDULAGEMQIMA0MnHz+7cTUJW10LPyAl8dE5lpUsIcHqVQkX IUHXwDYLPESlBDq+YXAkDIL1YTMUCXbbOsO3tMCCBg+08z18ugKyNnwEAyocjmwcRt0qy0ctol2E OrqaGMB1e9EdxvOXlZ7DMYlxk+mZZ/ADx0fhhYUE4TrLiYRJEq6fyIGH+LhDVZUn9fGHyQpHgBzb BYBocoKOjG5JB218tDjEKtPwPQn1laHzxO0OLYBP0NutC6kEhBmp23MNXrb8F/dLw53n+6iHMtAQ dceVIwn8OTfGy0eLhw3ZUDOHt9GJqaJVv6ta8DYwPveDq6Hs4ULZL57JbNwOT+RTXwvvd5ehr3Vb 3IljfAR22e2PvFpVdznVDLc9xlJss7rnO1CGu15DEoCTCenV0K6sniFWWWclEb48a3fiD14QVpGy Om776l7pXatLDk02yJdQo6vo9+sXsND98fXpC2oNL+JEiw4smoxi0QG41nXp7uDrJu2wgSWzYPvi Ug5sYlDzWYY8Zw033vmDCgELls/8IXk1L6ttxe1qZriIllzUD8FIPiOX/RB2olhPQGag3Z+yh/0B ++g988inweKd3KVqYaqUSBHgqlnYZvPclrk3w8KqchoSp6f3z388v/5+0/24vr98vb7++X6ze+WN /vaqfnyZE3d9NeYM4xIpXGfgi1Pzy9ePmNr9vkNlYvB1GR4TCuNXp/GYv95gy2P6sqDut8OcJ1Kc vNhGOllajSPAcpGDYo9enKrIIogyG8AJHDYPZegTO7/Huu7B5AIpqTlDZmoBY1DS1daesKyys3AL gVU6K+4PEKscr3dWHqXnZ7MqWVNTeMdnptMYEt/znQxVXlz4SXbjKFl8UyCVWS7rIHwN1x8dbg54 ptt66IoAFdJS+KHfT81CCq/zhBcii55JNGO9OoW28EFVr10dh55XsdzZ6LqCc4IT5c1aAUniB9tV 3AneduvykKaUDmkwfrQwxSEuu/zQFEB7NLtmBGLvfNZz4LpwpFPgrDVZ9dpImOSJbKG2e99T2ONc 7QalG2/UpPHpBXEqSRKbmFpECKP3aNSSD76q48fAEJmDbZ16oTWj+QqZeD5x1BE8lGSBPyaabEd/ +vXp7fq8LI3F049nbUUEl2HFanfzDI13hJNZpivzMSHnWLJWWg6OKPeM1bnhVQf1L54XNFPZFbL+ S8SuEbaqOPeMq2UuAEPDJApcOglBk44QhBC7FBSzONPYjJcQEjMt2paH6L/9+e0zPLayo0NNfb4t La0DaPBJ3XH2g7gH0tgc/SQnUmdDQBLP8JkAiHB176ne9gRVsdrWq3HuAu/sdjC/nYM0gMbrqM1s jq2lk1SXs3zI2HwdMxN1Jz4zmeD3UjOO2iotqPqiDEQsTNnOZklCvwhWqm2as0803epipuKX/yNs hNtSQWkfr0u08CHA5krdZoOvaZ8YCq63sbrQ7tmAyvOwfA4oGUl9/f6Q9XfoY+OZuekK82GMhjH0 0cxyTjGDfKh0eCp/WkXhHFCbYpJs4NxMHN4/aKPgc73CXtg6rj7mZ3xXUrlWOO5ZHOAWdwB/ytpH vkDt8XjuwGG+jwCasI/U76MXMnYLP6OaUaWcr6bl4UidrA6N2c3pZOMe3dLCErtmndEgssoa7Rjt nFLstlOgQxyqZrcTLTUbMp0CzOyPdVf1wkGJsy38YIPFrgRIMUOdt2tJMT3yz3TnXBJF2c8vVFSY Fpot6ItoiNBvuYCyqkD2CVZvkviMbk2MRo77U4HePRA+TrDvHFl+jjzPyjPLQ38ku6r4wAr1Sgpo mvNuQ5SAN12Yrgw/sOIlxAnz3BuKu9IQvZo1/HiAX211LPY9h+msNDfFrwFHj7xGK5dHSxY1taY1 0Aluwzc1ynguNedGYmunE/TUYXKoMKxthpyFLz/6E4nh1Gy80Nnh43MrdOidGj9IwrWh0tAwsmeA PDY4G+J+Uil0oL5+3LdrmsqJko29yHJq6K/rTsASees5m6/M1tTKKWlf7eB2UX0WNZOkuooB2/pc cWHsm0Gacs1VXVjA69pBPONr2QF3kLAww72ouBad2bFS+W6zk6MPg8zdywBjD//OuLBlxUAIakal 8JRRmBKsBqMijddgGhhNucfXQ5uV6yXwvuUD7klJX6008tJS6eNJd0UR3fBTx2Js5dZYAtV1v4H4 eMbbrI3CKFrvBd05z0KvWZOGnqPKYIARJD5muLkwwV6Q+FjeAgnwrMVDj/U+ABaXMMFwIyKYeZzO EycxnsGkcK3mAEyRuj9oEIk3qTNzEsfYTqHzaEqYAUWBE1K1Kw0ynqgYGAlcsugIidZlCUqdj3Yy IEHoyJhjEa4H6EwfycpQKRcE3mRvInTK2Mqhgh0J8WI8GUDEDaU4pD8sXYB7iDUDTnhWGyi4IDTE UTP3Whj6jHU5uEXpaiO6FHhXQlMMGxnEBqmU/UgGYaHHwLE0s4B2mUNL1bmY45ZF4YooSeL1acia HVxUo4IH0yI/DtHJAipUEOLdLLW8AB0dtrZoYsQxk7AXTziT766yqS5qqFD4VrOf9SUMkfoOPv6a LK9zxdlJbx5dOEGLN9zUvXJBkHdbQbnwY3Slr/rF6L+3xz6jC/RYF2rUth7cjNa8gnSv+jOve3hG ov2uDevgkeSI2cBRWlTSF5mSAFyjq4GI6n50o2/kjPgvXcC+KvtsCLVc2NBXGX3UgjT3kzcNq8x6 t++75rCT9dOatDtkrcMFIB8WA09R4yYSXJLNft/Bq2+82nNkT5ME3qFbRmt4V6fDarV5/ud8f76U x1JjGtRYhoV1CgZKux/qba1mDtSu1vpTxEQXQI+p8WOKC18aRcj2T8rpa04JSqHpFxxqdJuEqMmg AM3ouEA0L6hF5pXj85kIKHVoWEWAz8nSZ3XLbrNyfzLZtHYgbdAAPmDBs/xK+rzsj8JFKauaqpg/ gtDr88vTdNR5//u76p55FGFG4S55qYGGyvill+HoYijrXQ3OSdwcfQZ+MRwgK3sXNHkNcuHiGboq uNkpj9VkRRSfX38gIduPdVntL5pv3FE6e/HMTnNbXh7z5YStFaplPjrieL6+bpqXb3/+dfP6Hc6d b2apx02jbBYLTXfFptChsyve2aoXKgln5dE8okpAHk9p3Qplo92pq7HkGA6t2kZREK1owP/pchHI 9tRqDttFHvlhC2YkCPVIs6bZF6rAMMFo3TR7x7XEZvYMdIi73/jKfX+AoSLlJT8Nfrk+vV1hKokx 8sfTu3DvdxVOAZ/tKvTX//3z+vZ+k8kr7+rc8TWUVi0f+Ko3FmfVBVP58vvL+9OXm+GoNGme7jCo wB04ZqhwhPBjgz4Auc7Puzvr+KrAfvFjFYKol3CJL7qb6cnKCtwi81UNzKf43sHYpdGtHIDr0FSY r4mxmUhD1LXG/Ew3wAfUS1V1veoWX3YTLJHLFJZ2LNdfPz99VZzJa+upHKxFkzFM2RBB6Rg/NagN AiKNYg/bC0T5w9GL1a96IpeGqJrlnPElr9p7jM4JlZmHBLo68836SKgcCoZr6gtPNewpw/IF9+id Ht1rAT9VYEXzaTXnT03geVFelFjudzx3PZCzgkFsPezWYGGhWY9WmvZpEvpehmHtiXioBPfHSH2p pwHhxglc0DRdVgRqrDsNSUL1KZABqQfkBWLVxnN0L2tTXhZqS24yoe1mXM7n3JE3YOv9C38iDx3E EnJVW4D4na7JhfkNMnnISjHoA0+dx48CgrbhPvUiJ1A4kNAhajAxRocSR3w/xAuChYPgAj60XNVn eMuHGLV+Vxj2WtBiFTh0WuhOBTqSKEQH77HwwgBtNT+WqWEsFuBc9zJuRz1g8GNhxFQSyvAJU2/H 9ZqvgUbdHvsw3pirLhf2qcqtSrEg0G8KZa4cGjS7CWmB++3py+vvsDmBczQrJolM2h17jgZ2niPg 9NCpc0nFw8jituSwM6kYT7FnPYDRUJO82ydagE6VetHOuxoiQ064kwnBepcpMKEivp+flz1+RYzZ wSPq7FSpk15rSGcEHQGwxuFyDkIfvcIfdVUae/qnDZV+yRqGH6Y1Lt531tgpP2i10I1UcY8EU+me yXUOsb9pYUOZ8XFGSSIUFswazORBsuWQl6iL/gQc6HDxfAQozmiLBHk8/tkoTbU9aymdHwaPWLOO XeI5Hg6rLA4jjoll15GOYTcdE0O7P/Kl8DLObQMUFykBKvRh4LoQZocwcey5xp/5SDduU0/dhnS6 dcU1wV0xHDdRgCDlKfA9pPJFLTysXAZHA46R4TfF4skeuQ6MXcXO8qmK27ZmmUt+R4QG7dRfUqpI iH21mhnaB1ZVaNJDHKMf+tWmqOvhLKQqDkJ0WlWFH+OfKuaxxTV+/Dp74mhoFUSOb/rzxDg3vu+z 7SpTPzQBOZ9xG4m5S485u3tYEcJj6Ye6DgeIGOSX/FDuKtxeamEqHfdWjDJZgx6zSoT0eVAEFwgb WOw7e0E00Xl11OqQMV8/kimnv3/BCvyPJ20r+ufaRlRREKi5EUmqYyMaQXOzwHi0+wUNETfkMrrs 62/vIh7F8/W3l2/X55sfT88vr3idxRCue9Ypl6hAu82K/6fsypobx5H0+/4KPe30xG5Hizc1G/MA kZTEFq8iKJmuF4bbpe52rI8K2zXbtb9+kQBJ4UjQtS8OOb8kzkTiSmQeW8U30HgSxvbP4y4ZPwXm J2zTaYD1kFAsOaRQtbzg9y9PT2ANwbfttjMqmJF9x2jg7qxv65Pbps0oZbvTtoQgLOZhkKudFV/p yEEYp5dMiTb6gRVH0lKc9OT6gZdIbz51Qj+ke7vYLgi0NtXDYKE5qeqhTLszRm/xU7yukQvtF9fz TmEvTU2RTcguG5IkX1hoi2cv2KfiPUxCc7e1r6xkts7obt33FpR6PiO0Ffp6iMiDMRYkwd81QkPr TYCUEw6MkZYSB1Bl8gsFI09Y242xcWRHe9AlMFKYYlMrwY+Sr4mpnZWXZgfmrE4mES7BEl3PyWmj x2nqsZl0knb3fP/w+Hj3+h0xfReH811HuEN68Qiy5a7Hx4F89+395ee3y+Pl/p0po9++r/5GGEUQ zJT/Jp+zierAvZRqWyX2B99ArX253L+At+n/XH19fWG67Q3Cs0AUlaeHv7RHZ5OmICfc/HbEUxL5 HqKmGbCJfWwxMOPOZhOZqikjoe8ERtdxumvssEraeMq96jgeqOetjQ1OQgNPdmd1pRaeS4wci7Pn rkmeuJ4xjZxY6T3fOP6/KeMoMjIAqrcxxK5xI1o2RgPQurodtt1uENj1VekPdaAI45HSmVGfESgh YRAr0QEU9uvthzUJkp7h5RqyR+QAboB65QhRL7RXPPax7acALJdxgmfbxY7RzIwYhGZ6jBxih2AC PdK15qJslDa21mQVQA0j5uaNHMeQR0E2hR3Mpdj4sdGhuubc3QSOj0zpjBwYGXewO1sbgtrduLHs JGmiboQDYJMaYlQHkYFz03ua3zxJpEBS7xRBNlUOb6toYa7r3SD2ldANmrxKGV6eF7NB91USHhuD mct4ZLSzIKPcnu/h8uxtsOPEKx6opoUKYL28nrg2XrzBziJG/BjHiDgeaDx58lFadm5FqWUfnpgG +tfl6fL8voLYg4aaODVp6K89h5iVEJCuKZQszeSv09gvgoWtgL++MhUIRsFTCcxODqPAPeAz+HJi YnuQtqv3b89sYtbqCOsZcCAlOv0aPV3jF8uCh7f7C5u3ny8vEEX08vhVSk+fNw808lA3L6MKCtxo g4w73J56Op0cyrzJ09GvzLR+sZdKFOvu6fJ6x1J7ZpOMbQOXJJQt6wpdkg55EBgqIy9ZcxlKh1MN tQ3UwJjAgRqhKWyMEcmonrNBGorRLZbvgqE+r12CHmNMuBv6RnZADYxqADVGeU3NwqgRlm4Q+sYR cn0GT5Jm5YAbfQshwciJPNA32JnPBEeu7KlppkauoUMYNfTRkkXLJYvQysfo7F2fN+HC2hJgcypk 1Eh1oTjRHS+22MOOcxoNQ0t8mHFQdptybTG9lDg87Cr7ijuYvmdAg9sWzni3XuMfdo6zmON57Ri9 ysnYgh4AB3W0PSqZdu2tm8Qz2r2q62rtTJCealDWhf3Cpk1JUpqr/vbXwK+MotPgGBJktuF0u0Zl sJ8le3MhHhyDLdnpZKbxjEOlLs6OypIa151crRaMhnmWmSbuIEafOE/zduSZq4z0ZhOZihWooaFC GTVeR8M5KeXyKoXipdo93r39ab0/ShsnDJBlDTxFQq3GZzj0QzljNRsx5Ta5OUdO06uOqRvryRhK tOu3t/eXp4f/vcChJJ+TjY0454dovo387l7GYJsau7Iy0dBYmXoMUHncZqQrP9DQ0E0su6tWwIwE UWj7koOWL8vOVZ/Ba1hoqQnHPCumuTzVUAdVXjLTp85RbrhkrOeWGDYsUMzPVcy3YmVfsA8DuoRG ptmiQBPfp/Ha1hiwIJR9F5pd7lgqs0vWijY2MHcBsxRnzNHyZeZrl7Fqsmz5hT6qlKsbxy2FS1lL Y3UnslmvLZWiuesEFkHNu43jWQS1ZfoRMbidO89bO+3uI4krndRhDedbmobjW1Yx5RkiplBkTfN2 4QeYu9eX53f2ydsU75g/X3x7Z3vfu9cvq5/e7t7Zsvvh/fL31e8S61gMOHqk3XYdb6TF5EhUXaUK 4nm9Wf+FEPUrY0YMHWet+EC90rEhyq0V2WDotQtj1usp9YSfUqx+9zxC83+s3i+vbEP1/voAd0CW mqZtf1RTnxRj4qapVoNcHVu8LFUc+5GLEefiMdLP1NrsSmMkvevjHgtnVH6bwjPrPMe42v1csJ7y sPOlK6p3b3BwlPPNqSddOejmJAhrTBBcU2R4n2MiszZaPWb7cbMr1tqjmokZd/EP6DmjTr/RkxqH deoYJReQaHmzACyjXucn5jgQnxslFWTb3bnoT715mJTpEt9RNglpfGwIGFWBkLfECbFWjBxZHLvV Tz8yOmgTx5FePqD1Ru1dw3hEEA3R5HKGbkTG8aiNuoLtPmMHq5KvlaLqO1Mu2fAItOEJ4u8FWldP FjdbnJwY5AjIKLUxqBtT6EQNtJHFjSK0gmUJqnS9MNKbO3XZzKQ/NwCq7+ivELghgbfGiEaHjWQ4 cLJ0GleMWlWEkQGYjdepLHnJqJ+tMgfDN9aFXTSXi4qBrhCFJoqmTElHWZ7Vy+v7nyvCNkUP93fP vxxfXi93z6vuOgZ+SfiskXZna8mYfLlrNUIhkOs20F0Ga6jyqI/fCydsm6LrxWKfdp6nW0eN1ACl hkQnu4oR4Dze1ppiJqc4cF2MNiiX0RL97BdIws6sVnKa/rhe2ehdyQZJjKszd02VLNSZ9N//X/l2 CfiRwmZr35tjoE+2fFKCq5fnx+/jiuuXpijUVJXjx+uMAhZ1a117ShDftokNZ5ZMjz+mnejqd7Zt 5wsHY73ibfrbX3UhLKrtAQ21NoOaBDBao3cCp2mtA2/9fV38OFH/WhC1wQjbU88o7J7G+8JaWkD1 GZB0W7bs0zUWUwBhGBhLyrxnG+bAZoPENw2uIWzc7Ewr/aFuT9TTBhmhSd25hv3ZISuySrFQEIs7 YSUDXnRff7+7v6x+yqpg7brO3+X3PshxzKS91xs8PoKYi10VUzcKxn6Ap9+9vDy+rd7huupfl8eX r6vny/9Yl8ensrwddsiLNdPGgCe+f737+ufD/Zv0Um4uMdljj5TOezKQVr7gFgT+UGnfnPgjpesp DwPpTd4lh6ytMauAtFVe3Kdg7NEwHdbzAI2avzyVjQdeLLHgYVeYZsUODDMkkWDYsaTQ/40yzc7f sPxL2oFxfl3U+9uhzXZUL+OOv8yb/VNbCwmW2QPbKKazoZStuI16dwu0fVYO9AA2NVhhz6X6P2Vt PE/dcLszXsKtmGbSjsekr8AxXXJgy6BQTQ3oNC8cOXbKRK/6hp84beJ+AQyUe8GlAol5vy2Vt2DT lZtEVpu2JWm20PKkTJk0WuGqPp0zYsfzjWOxYoam36Mx6zh0LA1hOZc3+53F4Bm6uSR4jDoAT2mh J0eoxeCTYeWe7F2bfTDDP/WFFdvWyQE7WQesIVVWXGfct6+Pd99Xzd3z5VHpLQ2RU9i2eSoHv5tT vSJK4lcNvH19+PLHRZNbYbCe9+xHHykmoQqaKvHt7WnLH2ddRc75WW/2kYw7X5f4krxls9DwKStR O3Pe4Y578lS3HFxOtnXPz70t3xXZniS3+ldduiBbreNarKGFsNhFPLdjlJzJ3qbIsl68Ywc/F0zx UqzH6zaHN7X8aSq42j5qXEUOD+qrlBucituF17uny+q3b7//zrRGql8y7NjUW6YQX1FunN0WnWzR pHgm27v7/358+OPPd7ZMLZJ0elqOTI0MFW9TR58XSFuAq4Yi3x86hVEu35Xj2KVugF04XVlmn20G InzWGGTdu9UVubosQorCg7culoQ7GblRHPdfQUrYrE0sSadNHKOXPRqPvAi/QqbHTakNkEDmUqLC QdlH7Rt68ntVDdqgSBMHAVogwwfy9Ztz4K6jAltaXZm2aejI7x6kurRJn1SVrNU+ENspjUNa5vJn xtJvYqT1qZID1MC/AzwgV+25VTpELmCCnsthdJVUqpRHdGhVUpOUBmHIitQk5lmykQ08gJ6WJKv2 bNib6dDs03XISfSW3JR5mqtEJtHCmr3e7WDFpqK/ssY3KUNeNTxKw1nFWIPAslDufCCXec82kjX6 mn2qIkP1z0byAP5k8gr3pjnx8ea1JG9zFcCLxhbuCVtr0396rprq5JSkLtKBWLwA89zbOhnQZ5SA nsE1LAUJyatOa0njxchMnD6zZpp0xXAmRZ4aK3BVQga63552hnScwP69RYQGtlAW7rGHtC9Anobs zGY0HNNqrFufc6KZKSm0mCK8KdkmgqVoqWzZNeSsl4H7ADo5YaCa/3D+5uTjEeK4ROU6P0mdOLZE /+MlhiPuBTgP/MAShwtwmh8WZIz1ct5bApnPMHdaVdqZTnFsCw8/wu4y7C3AN64d+9x5nmUlBvi2 iyN8EcclnaydtSVGJsBlbvO9zRVSf7vPLEGyK+7X3Y3tvcLgsF8oWtfv7FmnpC3IQovueSQ9K1yQ 28XPRfK4ndWcvB0Wydvxsrb46hL63I5lyaG2BZOrwM15mu8tsVpm2OLe+sqQ/vphCvZum5Kwc7A5 zFkf7XIx4gsJVNTxInvnCXwhA+psPPuIAdjy0BPgXRnb4hcy9JBSuyYB0K5C2ILCiRz7SOf4glBx H/dxb2+XicFehGPd7h13oQxFXdiFs+hDP/Qz+1KCralo19aWgMtiKUMsDxQBrko3sCurJukPliiA sDrLm45tgO14mXn2ejN0Y8+Zo4H9a5qFdmkGNyzJOd8utFvXspJX9nZhO+rYXVClI/7BFMadS9fU rh3OvevaK3lb7rAoN4f0Z27brgQR42OBCIFEd9LzV/+mfcIW0/xF5kDzz9k/3bUfq8me6HZBQMok x17qim5ItPUNy2SKaLe0G6iTeZFvItNJr4lA7At9FcTp1jUYR8sUvkQ/ZFDymc1cketsyn4Te0HE 4yZ9kBz7pu2C0A84sy1llqn314IMC642q+rctlEgXSnig6iNsU1KHi4td+lwc8hpJxzlact2mu8r OOMGNkPG6EsyvkmDu7Ld6+Xydn/3eFklzWm2fBpvX66s4zNl5JN/SE8rxsrtaMFWkS0iIoBQkuNA +QmRCZ7WiW2Ze6yxeXp0SQY4R5Pm+sZjhDJRGjRhtk/b5fj5opIEVPVDrj5BfdRMLHnZ82qelKeD i10lJwHicMhD1wH//Egr5uUeJfIPVQ+hOooHkpS5GtIyLQPHiSd95zVy8A5YyEfgWk4oZ8NEng28 vObqsK0gzCpZbv0x0o64SSrY/hCLs6ky28a2QHkI1R0cnabFLZvkq/3ANvULMxJ8WnZHtrtIzhQN Sjwy0Xo3FxLLH3Bt2kA4RmWJIGJD37T1NkOERHCwrMH3CuYhVWasav74etFNgszPljJ50g1kmw/J IUuOy601F3a5qngdRC9J7WjlsU0rwLElt11L8uKHa7hta5LeZAX6hdC8Xflw//rCn4S/vjzDmR8j sYUURIMTryvlM+5JCfz4V3pNx9CeQiUYhR5R/k4c7glK0nW2yNDqJ3y8LnRN3+2aPdHz/dwPXYrd 183Dy2UTI/y+Og7lQoaGtJ5XBptoEFwLM3dKTsOpywtE6gFjGyDXjqh+YRU0ko2kVaS3IuECMuaF LHTICd4Df1DJyHFi6+cMGw6YG2+DC6/w0XecGKX7+oHwSA8CHy3N0cc98skM6mPyKxJ4MWafKzEE aGmKJAhlK5sJ2KZuHKoRF2aoG6gtmOu0mB0DChoSaHJSLygWNk1XnqWWERy+WQ0BBDYgxADfLXxE 7jkQIEI6Arh4CBDtNAHZd4QzT7Rcdd/Fa+67IVpx342Ms9YZcazBjmS2vo8tL3QlLs+RDaxkwHcs +Xs+FiDkygCeLbA0e3ct3m4aifKtzFL7pUp0wokKt1HD5EdFwzIaOViLM7rrI/KR0dhzEEkDuouM SUHHxWkPXgORPPIKPPwcvbUXYq1QEraXW1uCpSlMbMO3sLsVPMEa1V8cQ31JKBwbNzLLL/KOUH0z YR9I3MxG0xtbBhtEeESxMYCW8cYJh5skNRwQYjyjC3qsCmzH74Sx7S5j4ojijZnDCNhmQA5vbAFD ZS4lQJcGLKTurUNbdDOZi1WPoMlzZCH9wFm79uPAmcn964NCMOFHR1NbsGkMGTFtx9RTjAsLnGVg IxboeFpw9oHTY2QqEfQxb6O+bQehzBm4VNsuctCCMPJCuk7wQbp03xXqK8QZyfclSWljR3CNNaNt tlfiulwZ4LnqQNhfLVCHxjGdAhhouxtX6x8teKcTDzMNWroeGkxV5gjXSF+OgE3CGewHi0qR7dwV v8gy3bwUFUg+UGK7zwaOjlA3CJDSciC0AFGIzGociBCBYIAa1lIGIgftKw6h78ElDrbGxcoBnrlU BxgztCObOFpaOUi+r5CUr6CtF2cWiz9gk8/tsTrIMD5crix4Awo4TXoHdRgx81GPuG6UoWlQsYRb /Jyx4LsU7irMw1xeTRw3Zay8RpHpWPtzOpoXIOirXYkhctDFJCCoy3uZAdPlnI6sUICOr1sBQYN8 Kwzo0oY7WFveAQBLvLTBZQyK7yuVbpNoiNK1tl+izSwfdPQGWzhxOqJjgB7hJd1EyNQN9DhAS08J OHxaKNtnfoKzCZUXKPKSLwqQxRYPJYgIhQgxiNJDrAUqcmJrfrToAAWLY7cSdiB4qrGL7iUFtNRZ XUNCtuIhSHMUDViAsjaFE962xtIXLOeRA71uU8+ktCTEDJ7YInADjxbdV1z85Slm3wpknRUu7Szs 3Kdtjp0wM+rQ5POzhCmN7Qtja15f3l/u4Q2V7vUS0jtutXglZX2iysOWDxLT2ZRwTbDUtVQGTgO1 yiivGMy0nt8vj6ucHqwp8kNfxmBPF09ivmiVs5SapD4k+VDkXce6PqvSnFRqkxkBtbjv7CkggdJ9 RcZvsLGDb+5VvmjyYWsGumA/KyMYu4STNmG1JnQ4aOFn1DJpxmbCa3hVn8BFbZXdTJEFDZlUXZJB TyMRl4Rn6h05Fd3QZC3NKXazBFw7llVe5R0Eq2/zzKitakWJDjTeLZ2tGRkC1yDpKemKnBphdwBO c0q20J/9eM90OGFu+cY+o7zT9hkEkt6afc3jxJ1ow4SDNUFBbv/pqkOqUkbmy9v7Krm+ckuxcZmE Uc92T3p/Dj3IIk5Nt/tE3pjMANLtEx1uqTN8DX5lG90DqylnaEE4ta3rDtpz6Iym53jXgbTxh1SW fLNrsXXqjhZ4QSzlrPuT66wPjVnWnDaOE/YmsGMCAnetBlCjda7nAugFrpGiKc1xGhmsMk6LmG2E lzjaGB57biKdSZ4zEm5ZYETxAjp3pwy2MOhEJN5trJLHu7c3fP4giVEpboCMmkgDepNqHdSVs9P3 qu6yf6xE5Jq6hccvXy5f4fnlCqwVEpqvfvv2vtoWR9BUA01XT3ffJ5uGu8e3l9Vvl9Xz5fLl8uW/ WLYXJaXD5fErv2d/gqCCD8+/v0xfQkXzp7s/Hp7/sIVJK9MkttjcMjhvuG2+tYuStKK2CEUl74i0 TfRWFEBtVaIc3xOIS4B+mp6YUmvrwuzY5vHunTXE02r/+O2yKu6+X15nlzi800vCGunLRfLKxbs1 r4e6KjQf++lN4pkUPpEhZKiPoe0BEBWxtiDn+dEaCX26onpQyjkhY5yKspHGnIluEluYu+QArjsz LfTaRGXbS6NHZ2yhV2eekhrjasZGSyxLEqDWIj3YniA6WLFGfl4qo3kRPtFVnNOWlL2nQL6gV3Bl MkfXVXWgMK5nFKolibEtN87IpLuWkyCStwmsDHCwPXqaPxsJ3WbFMceeSMi1OHjy3YqE3BzyLjtk xBggIw7H8kzdJlmR6eYHSDYNm8CMmGITOAaVKG2h9Ea+rGyyPVrWXZfmrBFrFDzntG5RJG/IJ0uZ UEs5uSxM6MyFlwYOXY4XN3Zc1YOLCgYetgWXhYq0Za6v+qc63eD008mS4TG7pQ2phia1BX1UGW3J FKhlnMxRb8HAxYw7OeLl/7H2ZMuN47r+ih9nqu7csSXLy6M222priyg5Tr+oMo4mcXVi5zpOnc75 +guQWkgKSnpOnZfuGIC4EwRILG5eFgYZdEimAiGdnugoYfO5MR7ELaYDuH0xOJWxvYt6+pVApaFh js2BviR5MNOixfaJbly70FPk1RjgWKixkUiWuulibw3UzOzVl0yJBX6W2bdBBpuXDWs0DfVd5CS0 ZaJEldMOIco+d/zsG53LXGY8twMDLjLbDA14FAex/wUbwhLcwSL2zI+BC31Rxi3o604S9w6bZrBY MSHd+uXZzQ2yg0XqzRer8dyk12njNdeeXKoeTB5hfhTMepwGgMZQak/bK/L+otwxf62XEvrrJE9u B2y4OMWgCtCwfPdu7s56e8i94972Qwe/190JyVoSngGg7NI+T7xr6OQMijZoP1TiLY4uoxXodDbL MQ7Juj/JAejVzm49xClDTRfLMzt2/V3gZHauH0JBcmtnWaCD1bglQqNkIOBwzWgV7PMi04SBgKGP 8Erj+3dAp82j/50P1F5bfagaw/+GNdlrFzQbFrj4h2mNTRoznalGC3wQMLcojLEvYgEMipZ2wuBI kRd0+vTxdjzcPwstgF7R6UaJhRDXScj2rh9QsYS4WoK6wo64x0IB0dQ9hqQLxIH2KGWTKk8tlBJJ tgeIYGbDAZvePulgbmxBhT0tPeDv6rVPja0V0DIuotIpViv0SpUcgItP5NtunqrL8fWpusDIdBdH 6jQ1lxZCwpebkfVhzaVBT3Xf2waZ4oOrlbt+QQgz9RtkLLrHAx0P39xokyzOLCLPssyZRiIRwGFj GPNeuTUY3VIGy+Y0i0H9vVwnWzpEDd/Ea2M8tKdEIChxI6QuZHLCFM4VOOgqk7Ag19jLqr5UUUCY WF5jFs3K6ZGS0MTRudNKc5sWsPr2hriBhj9X/bth7O36/uGxuo5eLxWm6zi/VQ8Yxevv4+P75V7L f4dlfffVxxk+/Xo6K3UO8s3w5JWxO3R0iS246vGhVRG7KNsM72xyFLkLesuAFPKhYfOERxSf5k+6 QD/rCJznrFO9OoR1nv5aYRwp2v9JlSIz9ECtwMxkTiut7K/nuiknv0vV9G0cUOZuStUqkIXL5BUJ v0rXXWsQ3a5ffLrxTMb0HEd63SkD3rSgOJwgYJjJcyLCn7TLO/94rf5wRTzl1+fqZ3X506ukXyP2 r+P18CS9SSllRsW+TAMTj/WxZRr6gP7T0vVm2c/X6nK6v1aj6PxQUcb0ohkY7y3M9ateqikDJSrr A06qOuKcdrIAgtVPcfh60GEjOVoszxtY2KoDClD0BBgpEaHIRfjl6wmWoiWVRBDzNuozSAvUfW4I ClxxxJqRigjzVURUiOzY26gZNng3g1VUMvpWH/HrJPRW+FA53K4MNKtN6dIyDJK4znwgCgNid4EN hcBfwxSFY5KaFSILtnHV/hbQ0WAG89/rLLqp5v4W18dAae6NvlRA4L3pDVrCNoFjD/hIIUUkBz7p JmHvx3Ju+MiPGOil2z5EVfmi6uV8+WDX4+EHta3aj4oY7wCgm6yI+vKbXMrw4u2XypdINDC9DdG3 KHCzJC7NBe3x3BJmIJJRg9biuznqhgXfhPH1s4Pwt1AeaUuenA5aruBfystWIomKEG8FQlkR42gn Q70qRj11c4v6SrzuQi0CBTUJ/MMmZhU5BJzCTqkocRzFQ36NtaZwoNHrowgP9klJM9njggPR5Eb1 P+Hg1LWXFnn1xtF1YCul9NRcTqcE0NKrDFNLySdSj72/S8rIDkINwVti7ekWWvue2UGfakZen3K0 Hh5NfHMb9WrL/DUG+Uyoa2CxODyQ4Psz0rh/Tg2SVYm3e9eeWeN579s8dK0lbQgppg4juC3nxNKw fuqz7McrY+J0T5ndcuWPjn89H08/fpuIpNvZ2uF4qPb9hJE62Wt1wHjKKAXWa3z0G9r05JsgXke/ d4ebGApU+CO9BeHeTeXrkAaayXf4HIgerhooDtz5wukvgjyA/ha1MUuPtYksQZg8Mj9fQERR92g7 Dvnl+PionNGySYXOXRpLCy2MmYJLgElskrzf3Bof5ZQ4rZBsfJA+HO25RaFoo8ENr/6G1B0IgaoQ 2aBy7IKcugpT6Ii936Aa+5rOoOT4esUI7W+jqxjkblHF1fXvI0pytXw++g3n4np/AfFdX1HtmGd2 zAIRYmugpzbMCq1pK3SpHQe0aKGQgWauBR+mC0PX1XhgULjq2OHwiYyxwAlCGOtmmGCH3f94f8Wh eDs/V6O316o6PCl+uDRF1+4A/o1B/IippeV7tlsC+0KzJeZmhXSIclTPRCzLXbwCUAGRO5nOFpNF jWmrRhw/O4mavciuzba6sjpYP/KbhNv1rstEaNjI7sf+xAhvIuyHUo0IlMLfNe049kO1EZqvOkoY GT5tr71Iejev7fYANlOuNmt4YudDdztpuNfvfWpM7cn8/S6+iVJQfZQKeWjNDVZYRusopxBSN26x CleLylhDlYGtCWnpdMOK0lNNcNiqTLXWt+PvPh+r01WRdGx2F4MMPNRjgGoRuNsZA22+sw0FsFOs JAO+pjVYOl6KSkraLYdKCp74WKkDfpdRsvPLOAGJ9U5baohtgoMPrF4kAWacsl6xHApNYLkfDSAb q6Ym8rDaOWnwiv3wQ0ShBhEt0AOHdIBHTOplOzQyCLIbaWAA4WEE8RahlGYPOA8jDs5iN2G0BTuv D/QXwqZBoQEuSl7a4udZocrqCIxWM9LGGnGbXVOd/BVu8yamIvEhotVBFBCUi+iTceel9J7ecTsU /bvaDPVwOb+d/76ONh+v1eWP3ejxvQKFqnfvsrlL/UwK0Sh+txJFW1cNdzCKkh7jvM3G+3mdTRXr zL8TDx4qoPSZbKme27AhJXkMGI7vKdcSAjIYHqNFC0GA76/gu19uHREAapgMpFmZcqyRRgFz+1Ez a6STyEFma6DKbmpgamd6XJEaEzCbWkE6Ga73XyLD+FW/Qsnv6b8mWxiWVTKKs9YEW/F/72gOF5Ol QS9yQAJ5bx0HoFC9XWuDQ1Vctg+H6rm6nF+qa6PoNhH6VYygPt0/nx950oo6OwtIL1Bc79vP6OSS GvRfxz8ejpfqcOVpt+UyG37q5XPFGbwGtG46as1flSvOufvX+wOQnQ7VYJfa2uYTOfkn/J6rCUy/ LqwOg4+taZPbsI/T9al6O2rR9gdohM1qdf3X+fKD9/Tj39Xlf0bBy2v1wCt2yaZbyzqCdl3+L5ZQ r48rrBf4sro8foz4WsBVFLhyBf58YU3lweGA3tQMFsVryioQg1F9/XJ1fUXZel8Qy16ShgRrFPke e1vGPj1czscHVR7CnB0k026oJaUj90uQOufGlDoo16zEiDZOoqqURRyA8MGApVE3Z3hM8aedGPQl 5YjlKNo2hqO0yN8cxhMS9AoZimGxZfMxmQ+xOXU0nUgBl3bqtDEh2iIbEhyELKFeaBoKrhP3y1bi CnTAJHVEYO9eTemgLUtDkdm3n+IbO49PGiuyXni1FYOGVDXtBqr4s7aNlcP/N0BGDnL9rKFD+cWq yAZ0//ajulK25s0mWNts6+flKgNt+zbJtuQq14ppKlwFfuhxiwRfSa6xTV1M70QO6E24pl8nbwMQ G4jhZWkUgKbEAnMm+1TvF7PW16Hs1NJuz4I+WN5GlIJku3628VYqNWj3nxrNYZzFdOAJQ5gXraOC ar/NcHHaaZ5IT6sc2NSnKDKu59h0CzweESxyguQTfOYMZMARHyeLIeeCVfEtyEFzFC0l+tEQ5Giy LK+6FAYmcfkikq37NqkwIVYgVJcDJ0LxhZp6P2ZJxjACqayz4VXlNrU9TedXwBi73O7fhag0XPJd 2S7e3wT+UA36E5+KrF9k6reL7iFUIRrKAaNSbZJ869/BYMrp7Or4cnjfw1KjFFk6tIuLFjsQ5lhQ 4S0vD2pPNKS+AIlz2LZGudOTXQj0zslpC7zUFdo/f/wgHa/tiBXAbPRt0MBvJspLXvP65uRlttoG IW1b0FChNwW9LXFQ3SilN21qxzYPAjy85MV9wHymL7QkBe6Zdb3pxslwxZsTjBiQxHlg55STQxTu CR+yPCncDXMz34/LJrWHOj8ppRELXCZrSPVTRQTHA0Bin9tlS66t7LWqHkaMRwIc5dXh6XQG2flj dGzTKA06vbLUhzOOwS52cxE6EzYQ/c7/T+vSqypinodklfk3aBQEsgLFJAStu8k9fOuG0zODZdof uzRyh12nGpK8f/dJ0MD/Ppqq331VVgaCI8gqg41OC3RNDVK331zmFoPGAhJFvYaIGrC/yBcUcah+ 6i/TIKWWpbsBccxvS1UYmsAlbHi3tBQp2iH65Me5E1FGd3XwO0nFr6PhKQJSAwxTAphmSZ5o4K3j cTfo9nmlw98GoZsoVTaQ+lRQOt/iOP+kNmFL0S4OSeqGs9eOkz3pmymezZD3Y0YY+mVdkJAu2azg +0+ZMw1llk6R57JVQofhgnGZpFB+QFGsU78PhKHul7mxdz7sHsnSAX6g7yTI5dsi7RNiTHHQd6Ty xdOfVkgL4yEopguLxLHAUpydNJSlRCFRkVPqelIicT3Xn49nAwW4PJFp6ZIbQqrHiFImh59CYH4b zsay44r0gfZwvbllaRCHiepgIbjz8/nwY8TO75dD1TerhrL8HfCYhSHn2waoE3ottLvKoMqSFqId hE5CCbkBtLyQxC2hfKDCfzyMOHKU3j9W/AFRcpfsFIwvSNV6iB2K4rn4mNpB9e1rj6C+fng5X6vX y/lAWX1kfpTkPuZDIs844mNR6OvL2yNZXhqx5s6aLlH5st17qMij9Nw+M57fTw+3x0vVf0BraUvX 9jDNkbSFWxQ/RCgEvkxR8CYoP88DYNfuOqIpMDa/sY+3a/UySk4j9+n4+js+ah6Of8OUetq14wuc /gDGiOTy8DT3KQRapPK7nO8fDueXoQ9JvLg226d/dhHPb86X4GaokK9IxTv4/0b7oQJ6OI70T3wx h8drJbDO+/EZH87bQSKK+vWP+Fc37/fP0P3B8SHx3Sy7wqGRf7E/Ph9PP3sFNYq3eO/cuQW5fKmP 24fvX1oonQSDej1Kf+2Dovg5Wp+B8HSW+VyNAhFn14TOSWLPj+xY0ZdkMmAJPFZ1TGZ7VCjxlGRw bg0VhWYuLLW/LgiEy2Dn6/3pGZZ2XdfTkPl7lOibAvyf18P51MRO6BUjiEsbJGM15V2NWDEbTtRx D65eVtXAVkU0p0vlNFTwIIeXt7TCVdPBMT6ZWnMqvl9HYZqWRdQBmPl8tqTM4joK1ZCqhqd5bCn3 +DU8yxfLuWkTdbHIssgw2TW+8T7qFQkIty/Ryki0/NayxUZwzGTUi3Eg1wA/asceCla6DglWTSAU uG5nIWHRLjKJ0c5Uq2y7ClacSgXXNjIobhMtFH+uGPlNj5TXynCHtiSGTMKaAELqlwDuSuzUJaVx vRsQ+jGsESu8fWjKcUprgKqYcKAc+L0GqFROZE8WyqQDZEraEoKWBItVvz+ToXqQOs8e8jrybHNC J86C+c+8MRUEkmPkeGrbPfOW2k+9Cdu9+207GZOhoyPXNHTTdHs+tayBELWIVcLEAWAxlc1PAbC0 rIlmLFNDdYAk+kZ7F8ZcYS4AmhkWGco03y7MifKqvl04tpoI/T94Lm2XyXy8nGTK8poby4nyezae 6b/LQOhhdboUBb1cKqaVtheU9j7AM4DSUNwJaC8TxHaFeGFsqJDNXgmdG+auMZ3rAFkz4wCZCyPT N1VvYFTnZhMqwHPkpuZUDdrHn+rQaBxtnGfjge5Eflx+nywWauuj1JgZyxrWlhjbxXxB8ndumrWz hTtVJOu4HMPfIwKlhg6+02rpMICgVljOMePFRCqOwxjsJEuFRXAq7tW+1cLYvqn2n77Cry7n0xVE zQfqEV9C1qL76zNIasoS3kTutM483UrwLZUQG5+qF+5oy6rT21mVJe08tIHNb+qbfvoWl9P435PP iJzIn5FhT12XLeS1G9g3WtJj1zPHDRfpXsc4dCB8NjQjyDDTOVunSmz9lMk/d98XSyUJU28k+FBs jg81gD9bi4RZ8mzQBPK5F7H2qUTwZKGWsbT5rl9oH6kcpLlWII2rR602bxALDdbcvVg+2hN+y5Cs 8YzOpggoc+AQA9R0SsU1AIS1NNCCmvkyHwSomSmA2WKm/l7OtOtFtKyzZUbIpkpc5WhmmKahMDVr IjM5N53O1TTssG2hSMvS02K29h6fDFprwPPw/vLyUWtTyoU8zobQdbh3MH0JrxcgzOkv1f+9V6fD R2tj8m/0BPA89mcaho2uLq6D+N3M/fV8+dM7vl0vx7/e0aZGXkyf0omwWU/3b9UfIZBVD6PwfH4d /Qb1/D76u23Hm9QOuex/+mXz3Rc9VNbs48fl/HY4v1YwdA2PahnLeiLLIeK3Lvqs9jYz4CilZZm0 MMey6lED9ELqzbW+y5LShDObfOvJ16A4KOLHcCcEe6nun69PEvNtoJfrKBOOl6fjVemzvfKnUzX2 A6pkYzr4SY1SnE3J4iWk3CLRnveX48Px+tGfADsytLDA3iYfEGg3Hsoz1P0kYIyxLNBucmYYE/23 yhA2eSGTsGAuBEfpt6FMRa8X9ZMbbGj0uXmp7t/eL9VLBafqO4yKwhedKJgMpo1Y7RO2mMs5BhqI 2uJttJdzQgXxrgzcaGrM5E9laG8NAg6W56xenvTzk1inIYtmHtvTTGe4y8JV5/j4dCXmun64VwXY b17JTFJQtL1iPxnLYaHs0Byrb8kAwfDv1Nepx5bmWKVG2HI2cAixuWmQDXE2k7m8w/G3fK/iRvDh YqICVKc/gACINhuNzNnMoupdp4adjlVfNQGDLo/HZGa15lxnobEcK2m4FIyhpP/isIlBSbDfmI25 i7tysjQbW4Ya970uetipMc8sOUlPuINpnLpM40HAloZ4EKKUVAdxYk/oBBVJmsO0Kw1MoQ/GGKHk DLBgMjHpyUHU1KJR+dY0Sds52D7FLmCGzE0akLqjc5eZ08lUA6ixSZrRzWGSrBk1vByzUNQvBM3n lP4DmKllKpEDrcnCkMwId24cTpWUJwJiKnx650fhDMaUMuLnKNmcaxfOtMuR7zBNMCe04KQyEGGy f/94qq5CCydYy3axnMuK9na8XMqKQX25EtnrmATqnBJgwJQGfNZNy5gqnal5Ji9o6GxvrZ0i11pM zf7GrBFaFowamUWw1MZDcN0ilxwsMYxdOAhFDlPg9bl2eD6eegMuHQIEnhM0XpqjP9BK9/QAku+p 0iXbTcadKJqru8GjiNugZEWaU5QSXY4GAGgkSt86sju2Ysr1Yd0NurH1MXYCQYd7pd6fHt+f4e/X 89uRm5wTA/Ir5Ipc+nq+wsF5lE30O/3FIDevx2Ab6fcs1pR0/0Z9RTkBEKDs/DwNddFuoG1ku2G8 rrIrbpQuJ2NaelU/ETrDpXpD4YHYzE46no3lTMROlBqLsf5b3SleuAGmI7ExD/R1RSZM1ZEL3HSi C73dsKbhZDJ4fZmGwBwkdhMxayZzG/FbbR/C5DQqNc/QUpzLUO2osKZyKLdNaoxnCsv6ntogdMxI htob7E5OO6EVPbmcdWQ9beefxxeUgnGhPxzfhGdEbxK5SKEe+oGHVnVB7pc79fbPmRgDCS/TIKbs q7IVumkoyaeylZLyZb9U5h5+Wwr7BHJFAsITzhyTiZh2oWWG473OY78YiP+u64Pgq9XLK6rg6qaR 7YiW49mEsncRKPlyI49AsJxpv6XVmQPDVGUoDjHodBhUyyRRLXfIyd1FPqaooKzbZBt5+CHYtyLR 3UaDnm2Ic+Ws8gLQvNipZdxSGxwxYcp6NSJswC23Q/cMPxHFo1vwO3RxuGY3o8PT8bXvcYhO1Zld Nr6fzWGr07fbLLXdrZ7ow0nszAPu7gZ0LIs24HDi5nJkMmA6ft7YYobqM5vAOZkbsdzBX65NmWsK MkzHdsfc7iU73dyN2Ptfb9w4oOtsY3Si+FTwmHbrSAU6blRuk9jm4S71SJLwEwMOlsYijnh8S2p+ ZBosRC/AhSlKByILIZ7f9YsAmtLUqgg5cSqieAwwQ2ZECBVP6djF/6/syZbjxnV9P1/hytO9VZkp t+1knFuVB7bE7tZYWyjJ3c6LyrE7iSuxnfJyJjlffwFQlLiAis/DjNMARFFcQBCr1KmsJp7iDJPV P/RQgO6xp7wTRQg/Y1mNAKNdK/WM7B8w0T3xrFutxOGKis+RWYsjEtOAaUZDY+wYgWXO+zJVVWad 3AOgX2YlbAbfg9bFson3vAZM/MirTzeY0OL113+Gf/z77lr/61X81WPUuT1RYVxYyka3lMDjLE5A P0dm5gLRitSkojATtNkePD1cXtEB7DOJprV9uNpCu8eiltwNtp5Q8M6eiwxACtIuu+01VacSaTKJ sjg77UmIXbVKJI7NRa96P/2iUa2FH2upX2s2a28rR+sE/JNzirLB4wYs+qq2syBSaJ5ONe+EXTdZ 5RYchN+9ifXiFQJ5VvDnGV1iktFV3/I07SIFTorKdvinED5iManrXUyhg17ek0n4dv2GtGXgBjOS EH+x3asSkWxkv61UOmQ9sa7uAgU3ENrg/lQL5WT8QVDVZDt4yDpG5A7dRO0lbiD9En1cYQIsHGaK 6BHshLOjZxcG5F34+GlVwHFeJuqCUouz8wEU53C8sHlyVs2YZcKMgQ/INMAkOZqaFRrB2Za7qnWc jQiAEZyUWZmNpzDrElNwDvRboUpnNDTYC1TSwFZJZ5t9WBVtf85pEzXmyGsgaZ0yGViAatWc8JmK NbK3Z3YFo9O7olkCIF7e05kcVvxZUcFc5eKiZzLDJpdXX20P2FVD69Veh3oBN61wA2gNYpM1bbVW gg+gMlQxgdLgq+XfGBYzVgIbI8Spe/pYfdw/X98ffIZtFuwy9DJ2Bo8AZ75xmqDnhR/NYmNRuHLn jcA1ZocuqjLjI1mJJtlkeapk6fWihjOPar/hEHZ+H5O6I5GvVdY2P5OqtL/GO9bgRhH85LiFRuxE 2yofCDswlW4qn023hs20ZJcnHKOrFAR9OJNsY7GpaLfO1hiypYdpwus/ZllPgk84keN7MMEFZf2m ADJnwVUKcw1Sa5xvIfErZw2MIOh+03hJPf5erZojh9xABmZwOL15xGyB5UntpMeudk3YwKEvWJfE sSFvTkY4M4kjrpFJp3S6LO+FGOGOWg30rND1ILgR0rQfnYRWGkb6QuvcXmYeKzKQXqTn6PWb6lcy BPlHN02PgX/0cmwwFE0bKaBGFAL7aOIk5luiwZ0nAXa7kbhihX/EmaULDM3jvQTxs9ZNcnpVxJbm GNXl/B7zvpxhWMPyAuTg94vDo5PDkCxHGcFMctAODLmNnPiWQZ+M6GjnkGqTzDVzenL0gmZwEuM9 nWne/0ozOrzqKvxwjn7uCw090xXnG37fbtDiq+//Ofl69SpoN5mpjTWQYITLHF6L/vG+KGHfiGSL aQk8dmqQ3g7H37YAQ78dna6GIG/iLmOIPHl/65Gf9LxVkIpPlhFpRXeNxIIoHkWjXK5FcgHCJbce DRGepHA3AiL320xp0S6treAr+x1cBsG1Iu9RkHwrO4knSND+TxwN54W+R2TTlcqOxtS/+7W9bQAA TB9h/ZlauhWeNbn5jKyk0wFL3yaYSZwfWfNQtABHIusNz8MSYJz29OJvLRNy9hHCYrjTduqZni6H oyLVVgqM2UMxgk+kTVRdnYhIMDvhA5ZvI4P0ihOUV41PeLzA11Tja4bwBf1rtuVvaebWfFKlIibd i+DcGVHvan42SzsHJPyYeNfN4/3p6Zt3fyxe2WhMREMS8Mmxk6HXwf11zEWmuCS2IdnBnNpOIB7m KPrKU9b33COJ9/g04q7iEfE8zCPitoFHcjzTEc604JFEh+7t25mGuSAFh+Td8dtIw+/eHEYbfsfa RV2Sk3exHv914mKypsJV159G37c4esOp232ahduuaJIs89s0L4tPq6HguYNNwXu22BSxiTX4N7Hu cT67Nj5Y1gYRm/Hxu4/5wV9EJmURdPGsyk57jt2OyM5tClOugoDslkk0iERiqvlIa5qgbGXnlqMZ caoCEV5wIvxIcqGyPLftBwazFpKHKynPQnCWYCW1lEGUXdZGvtgpRG8wbafOsmbjIrp25az/NOdV Kl2ZJV6BkAGTVf3WsW05Kknt2r6/en5Ay2qQWxYPOfv1+LtX8kOHJdbiJ9NQRR6mCJ9QcMfmj6JW dUCVxs/SQeM4R4I5ftINXHGlErFbrrklY6rXhoxmrcpc1bAh4WWkAcnf5JDNtFriAlnexHIPWMrP sBEqlSV8RUdJY+sLE/ZtV1IIiBw9TNDCCppY8iUiQ2Lso1+RdAXiLepbtQUh4nInWqpeJxWWn9nI vGa15+bWOo2z7fifNwXcf+6vvl3f/3P3+tfl7eXr7/eX1z9u7l4/Xn7eQzs3168xf80XXISvP/34 /Eqvy7P9w93++8HXy4frPXlGTOvzX1OBjoObuxv0jr35z+XgSW9WPqaDgU9IzvrSK0NJKIzlxWmw krOztgRNuoL976Zxn5y5+H4YdPwzxvARfwNOGgdY/ZUxuyQPv3483R9cYR30+4eDr/vvP+xicpoY vmkt7PxKDvgohEuRssCQtDlLsnpjGyQ8RPgISvAsMCRVTnrdEcYSWjd1r+PRnohY58/qOqQ+s21W pgW81YekwM/Fmml3gLtuyRqFG4rVL9kPjvc4SsEdNL9eLY5Oiy4PEGWX88Cw6/SHmX1ShCUB3Msb PMx9VoQtrPMOLZbILjC1YIAfA6W1Ev/50/ebqz++7X8dXNES//Jw+ePrL9vZxkw9n+dXI9Nwpckk /AqZEKHftExUOtd6UzDj16lzefTmzeLdDGoYAG2Lf376io55V5dP++sDeUefiw6L/9w8fT0Qj4/3 VzeESi+fLoOdndjVBc1IA+zWp9vAySyODusqv0CnbWZ7r7NmcXQaRcA/mjLrm0YyXEB+yM7ZAdwI YJaObVTnGqF4ptv7a9umZLq6DCcoWS1DWBtusITZFdJ1zxigueLTkQ7oasU5oQzImuvijnk1CCJb JUK2UW6i8zCh+KG28OJ8x/C0FCTJtgtXBer9z82i22Ctl8jwFyL8uA0H3HHDcK4pjbfq/vGJ2bOJ So4jsS8OhfZY+C1dfKYIDfOVc1xxt2OPomUuzuQRt2Y0hlV7OQQsf4OutIvDNFvFMbGOrtl+RpfQ uEAwg+vbkwBfpBzsDfPBRQYbWOb4d24SVJECg/gdRUSJMlEcvXn7G4pj1jvUMKGNWDDfgGDYSo3k wjYmGni5puKbeLM4elkjIW+khznwcQgsGBi6FyyrNdOvdq0WbCW4Ab+tuTfTaupppfVlNqap0tuU Ct2GTEHIhnk/QL3K9SHeeoO/V6rtKmP3n0YEqnAfH1neWNUI7vEiivjdg8NJB+z15ZRHcVKdWpz7 EsSF25eg829vWoa/IHTusZSdQ4Ae9zKVw1NzG3BFf+coGswJPLdHjRjCdMSgmI74woaqnYxNLpyO zdgYGJqZYbJIrGaCLy1mh6rdVn7FT5YgtjIMOtJHF90fb8VFlMb5VL3J729/YDCCczMelwPZV4PW PHv9AD09meE++cew42RcDaBoSTWdU5d31/e3B+Xz7af9g4l453qKxc36pOauiKlaUqqSjsdsvGJP Do6veGmTcHInIgLg3xlWOpPoyu1qbqwrXy8wLXXUpuURmkv1i4hVGTHeeXR4sY9/Mh0WWbnyNQ7f bz49XD78Oni4f366uWPkyDxbDscGA1fJSXBFGbyEziWRDKIU+7gRs5jaRiHVzAIFIs11rJZiJKGg 7XR35trnoudfNd9KGhnOUeBTWBTo/WIx29Wo3Og0NddNqwVu4P275vwMRMSmzZY5wDC/X4p2c/Yg G7G47mY2sUXYMBOLeNEWYwawGJZTJExY/KzDExHpaOKms+VIPoi2Tzen7978TGaFb0ObHO92fNFc n/Dt0YvoTl7Ynunk+erF3XwhKXT095RcoteQCksI7BLJ+aTYU1fk1TpL+vUuj0ycRTHjHyGaiwJT VAMh2iLQ0yL0qMUEDp9J7fNIZWUfb77c6fitq6/7q283d1/sm7P2zEGmhpm2m9GK4r7fuMO+oG3z +cusFOpCOz+vDJPPo9w9z0opVE8+lrbnlvC8x5cZ3FuwTpclS5hYI7jSlAnaKxSF7diKUpskl2UE W8q279rM9k4wqFVWpvA/BSO0tI1tSaVSJzZIoZ9g2RVLp0aaNhjZEVljgFSSYXpjW5tjUB6Y2C06 FSVFvUs22tNHyZVHgQ6xK7wdUD2DOs/sLx3bgJUEok5ZtdqSZXOcBNgIiBgOaPHWpQhVDtDdtuvd p7xEGaQ0MTE37I4hgjxL5PLilHlUY2ISMpEItfUqN3gUMHv8q115OHF/uYWhs2WoaZpoLV2nrwqC 5Z1WhTUKEwo9VFEgcsXkj/p89qCey6UFTSUHP2GpPY9Li5prJeJaSWCOfvex96pHaQheGtjpGdAU EFdzQzsQZMKeqQEo3Nz8E7TdwFaMN4aFu5KgtWXyN9NaZNVOH9+vP2bWfrUQ+UenXOyE2H2M0FcR +AkLH246Hv9gLL+KaoBUeeXcDm0oGsJPIyh44wzK5hHLZOP8IO/TlhJf2m6gFDZzLnIT62IGXCgl LjQDs3hX01RJBvwKBE4imFDI84Bb2gF5GoSOlb3DRRHu5NUt6TN0LVw4GtbtxsNRDWBRk4najz6g AsZpqvoWLsLOwTDx4gqj5pCwK0cng4mu2WZVm1tmCKRMqg3d8GA3VLmHclYSAGqp4LgxCK0g33++ fP7+hGHmTzdfnu+fHw9uteH48mF/eYAZ1f7PuljBw1T1s9Be4IcBAl6BTjAYXGGFJYzoBlW59CzP d226qanf0xYZ6xrvkIidxadxMvJsXRaoxzm1XFkQUTMFUx0KnOMlzBDc4xXn69Csc72lrPH/YJ/o ebV0fzFsvszd0Isk/4geHdaWUB+8QlJFnTlBExjEimU/GqdWCd3DzM4/T5sq5Adr2WIUQ7VK7b1j P0Plb3tbHFhVqPryq3ER9PSnveMJhGFkusIQsxFqDIZ1/AVGVKdDE/tV3jUbLwJsJCL3kiLxMOR1 sRV26RECpbJ2KzWiI065ZuUPKzOGJ5+6ziFGeiboj4ebu6dvOkXE7f7xS+jSRLLvWT9Et0wuSxqM 3ri8bV476mOxxBxE3Xz0QPgrSvGhy2T7/mRcMRRvxLRwMvUCaziarqTSK3o97YuLUmC9+pmdY1PE CzWBvLmsQH7rpVLwAJ9vH1uA/0C8X1aNHrNhYqKDPWoeb77v/3i6uR1uIo9EeqXhD+HU6HcN+qcA Btsr7RLpFSAYsebYlXwojkXZgPjNa7YtonQr1IoXatcp8JBEZTVbuohKP1JI6XusL+wu9RrOSwxI L7gnlRQpOXwAjcVCJGaoaHQJNJsD6c42sK0xxKvImkK09gHvY6hPfVXmF+EI6uNw1ZX6EeLX/fER J6Nph6ohStlxdbOb0h78mES/7uwl8+JF8S+75M2w19P9p+cvVIU2u3t8enjGPIjW8ikEXtbh7mwX eLeAo/eWLHGY3x/+XEzjYNPpfB3RzeCGgBnYENrgefP7ROjTQ3QFhqLPtIMea6xrH8lZMJtnsAzt 5/E388DEzZeNKOEqVmYtntN6KU3+o4idf1/SCMfr7UWT4w6ADrzxVwzGdxohaXClGxuz+DbyTrlr MV10VYYjh3gSBGIumtW2dAPLCVpXGZYtZNMeTQ33+kbvvVJVsAVE7Aoyjrwm3u7CBrZsTWOjg2gx zsTpMEFMvaZoh3XYdOMP8wB282uwFOjqOMMfDRkllIsVT7UJ/UK4LJFKOuJ1sW6jjFp3JoVDjEpv 7fFotTZ4k3dLQ8znLyAKCl+KbYRhFYPIlAN/CwfQYGbGRLPPrvFkbdMFELLSgUaWcLXfSLvQjLek zou+XpPncdiVc66KIfNYpOVMtZ0IdmoErKutkKesjzpD+R0vvLn3rkF6bSyK4ehwLoZ+KxyNxaNE I3zf6wmB7kruTSFJ6Js1NjSCaCyuXpRRy2pinnC5dPQq3ov9BicmTYiqw/wU3PxrfFbmThkZDaVV 8X7hAqdP8t5xRsUwQ5l6IELEQFlUaedHoLqOzRM39mSPjU6bNVxvgeiguv/x+PoA84s//9An++by 7ouTN60WWCUWo9IrtgCrg0dBo5PT7Vcj6cLUtRMYla4dcsYWuICtWmmqVRsiHXmb1B82Ib2D6Vic 2O8lOuB7b6X6WPbSHCloj9MnwQwXNUsTftjUGYuMOvMSmqHDC5tr4Bv6DdYPbkXD8evtBxAhQZBM Xf8kWkq6cXYRzS8MHYACkuD1M4p/zMGveaKXjEUD3asCwaaUJMa3nmnbZ5Y4+GdS+tkPfQkDjsWi Dqsd4UdZ4s//PP64uUOXV/je2+en/c89/GP/dPXnn3/+r2VaQYsktUt144PLfK2qczYPj0YosdVN lDD6vPSibZ6tCHgyKt+6Vu5kICKYqpgBg+fJt1uNgZOz2tbC1tENb9o2ToC5hmqrrcuJKT5aOtLO RAyI6GFGxbpBcM9l7GkcXvKnGOQejudQl2B/tRiUTMKRFdY8fSarpRhX38ppgdMhNKl+01YAb54i kI2e479YR6ZJiv1H9dQqF2s7/YsD78vCUvDQQWLyhZlvxLshzAkWYJcyhb2lrSKMjKNFrWAX6G3+ TV8Gri+fLg/wFnCFdkiH/Q8Tk0WGcdhqPt5dpmt/SVGGqEwb9ybmTqJeTzJ6UlFS4yB1lcOjIp33 O5coGCAsRp6HqZNAimUvL3rTJpaTkrfajA4ApGBM9cjBY+sTcXA/sZ7jlAtAhPIzKRHGA/Ro4bzA zyGHQPmh4RRNJo+q873B/ebDIK8pUgRwG0/AhS65cMrYk7PStEhD3lhS1mlAOdFz55YCYx67VqLe 8DRGcbby9geD7LdZu0Gdb/MCsjRTeLyievEl5EIFrQ7ogi5A8Fq0cXskmKaKZhcp4WJbtkEj6KDm 66eToTXdtMdDFGrze280dFcS96ggRa5frJDqAxK94zAAf4ChtmhnQc2UPxVWU4M6pNnaEv9wEqNW nv3W4H3mTu2/aCBkdOneF6MoRWr4oOlwzU0RltyC47haZNH9fr29YKmFvQFmhOlfuJ7om2f4JTDS IPOumE+w5BKakzkSLbTNEGy2wA/mCIoiq4J0N9MXDvxCbwPunB+WdFOKutlU4Vo3CKO69Nadbn8J RyMsWj2MnnTm4GSgxbOlOCIYvD2wzCc9yfqyjcSwtw0Z89Lo+uqggaXUe9FaPMt6FcDMgvLhfAvz PKm5KGE5js9Ms4weTUNpgFhcODareUdW+uKGS0Z7nzcRTueYxU/mKc2bRU6WRxz2uaWmPxn/dKqJ 5sUclmUr4Pyu43dyu5f/FfGYMpQ4VCrzNpIf2OKbZF2KCQvWzCHr7H11IYozWSr7apNki+N3J2Sp RfUPv+0FFlVjE1xOWidKypsN2m/XyKOD9QeaQOL6efqWk7g8AThg8KGAHNJIofILY47rGsvaiz72 g0GMjoau5p+KtJUu15EHKOvsLl261Wj1JTVfkiU2ppwceWP4IdhddEzBFMuh9RsL9dFqONy5NWMs RMSqNlJ0cWvlSBMxaQwWRrJ8Gk+UyfWgFnNmTnqUZJoZPM1t3MFNDw4ZXwZblVnlpELDC2bYBcNZ y61OXF0pZ8ZGuLYGEo/yj7RBgnbXr23abvePT3gRRGVJgjXaL7/srdQcnaNu1fq+wTTgg9351jC5 o20Z7G2NJTEyclk2ly20GldqYNCOJbAueCL7PaVs0ceWpePZKNnuxrfNsZOzpDoP9LgNHJLV+bDx 7SxrA/U0Akg2GBLQqiwUmoi4kSBKNMyqrqAwIts+q5HAaoWS2jnm/eFPrPM0qgkVnJokU2odjoli mVwaz9KWT/eidW54jjaxzJdEUmQlGlV4/3OiiD6/nO5fsHdmDqIluonN4G2HtCiV43MWJxuMQDGL G+mC3p6wJi762o3coQltZji0P4pOXcBKkANVk7hhPlqhDoi24ox6hB7drm3gMmu1NcNtqusynuUS VvvixfGY3HkFB2mcQqEPLBmB4jTRUCXCgsgxszbPZhYufLKn+nfxg1EjTkAaAvQ8mnlHzQcTaCQ6 1m8qMhSe88wGPcuhn78TF7G1VaaKrYi42Oj1QvmjOZNC1gLzy1Ofmys55PXn+LdujUXpYAEWYXny Bzw/KVIkiBiNpr6GT+rpiB/+w3ahNELRFE5E5FgYZziaLBK4I85uYQpPiAijphGfwJlQ5EGUMmka QHjEHdHNBXCIc8O7bT3u7PEdJAXS7mv/D5u7kUEXRAIA --===============0639716199728192149==-- From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-10.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING, SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 42185C433DB for ; Wed, 31 Mar 2021 06:17:36 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 0927F619AA for ; Wed, 31 Mar 2021 06:17:36 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233737AbhCaGQ6 (ORCPT ); Wed, 31 Mar 2021 02:16:58 -0400 Received: from mga03.intel.com ([134.134.136.65]:57350 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229497AbhCaGQm (ORCPT ); Wed, 31 Mar 2021 02:16:42 -0400 IronPort-SDR: +2Oa1e9cGaEViFomYY+kjcvBhqW55FayAW85YGgflr5Hf7T8lFa3pQji5Vafg9999ureLdXjub jrkHoTqB/r7A== X-IronPort-AV: E=McAfee;i="6000,8403,9939"; a="191954517" X-IronPort-AV: E=Sophos;i="5.81,291,1610438400"; d="gz'50?scan'50,208,50";a="191954517" Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 30 Mar 2021 23:16:41 -0700 IronPort-SDR: G4x4+RvtrAAI+OtUJGeXILhROCD9Rdh/ep9Z3yg4ofFWGj1gKmPxf3HO7/BWRCpPMbTK9C2jM7 kfNA7onQgAjw== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.81,291,1610438400"; d="gz'50?scan'50,208,50";a="595786223" Received: from lkp-server01.sh.intel.com (HELO 69d8fcc516b7) ([10.239.97.150]) by orsmga005.jf.intel.com with ESMTP; 30 Mar 2021 23:16:39 -0700 Received: from kbuild by 69d8fcc516b7 with local (Exim 4.92) (envelope-from ) id 1lRU9e-0005hu-TA; Wed, 31 Mar 2021 06:16:38 +0000 Date: Wed, 31 Mar 2021 14:15:41 +0800 From: kernel test robot To: "Peter Zijlstra (Intel)" Cc: kbuild-all@lists.01.org, linux-kernel@vger.kernel.org, Ingo Molnar , Frederic Weisbecker Subject: kernel/sched/core.c:5370:37: warning: cast between incompatible function types from 'long int (*)(void)' to 'int (*)(void)' Message-ID: <202103311434.dpBaRaX7-lkp@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="82I3+IH0IqGh5yIs" Content-Disposition: inline User-Agent: Mutt/1.10.1 (2018-07-13) Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org --82I3+IH0IqGh5yIs Content-Type: text/plain; charset=us-ascii Content-Disposition: inline tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master head: 5e46d1b78a03d52306f21f77a4e4a144b6d31486 commit: 826bfeb37bb4302ee6042f330c4c0c757152bdb8 preempt/dynamic: Support dynamic preempt with preempt= boot option date: 6 weeks ago config: x86_64-randconfig-r011-20210331 (attached as .config) compiler: gcc-9 (Debian 9.3.0-22) 9.3.0 reproduce (this is a W=1 build): # https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=826bfeb37bb4302ee6042f330c4c0c757152bdb8 git remote add linus https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git git fetch --no-tags linus master git checkout 826bfeb37bb4302ee6042f330c4c0c757152bdb8 # save the attached .config to linux build tree make W=1 ARCH=x86_64 If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot All warnings (new ones prefixed by >>): kernel/sched/core.c: In function 'schedule_tail': kernel/sched/core.c:4252:13: warning: variable 'rq' set but not used [-Wunused-but-set-variable] 4252 | struct rq *rq; | ^~ In file included from include/linux/err.h:5, from include/linux/kthread.h:5, from include/trace/events/sched.h:8, from kernel/sched/core.c:10: kernel/sched/core.c: In function 'setup_preempt_mode': >> kernel/sched/core.c:5370:37: warning: cast between incompatible function types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __static_call_return0); | ^ include/linux/compiler.h:58:52: note: in definition of macro '__trace_if_var' 58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond)) | ^~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__compiletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_compiletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) | ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:39:37: note: in expansion of macro 'compiletime_assert' 39 | #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) | ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:50:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BUG_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5370:3: note: in expansion of macro 'static_call_update' 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __static_call_return0); | ^~~~~~~~~~~~~~~~~~ >> kernel/sched/core.c:5370:37: warning: cast between incompatible function types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __static_call_return0); | ^ include/linux/compiler.h:58:61: note: in definition of macro '__trace_if_var' 58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond)) | ^~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__compiletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_compiletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) | ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:39:37: note: in expansion of macro 'compiletime_assert' 39 | #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) | ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:50:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BUG_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5370:3: note: in expansion of macro 'static_call_update' 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __static_call_return0); | ^~~~~~~~~~~~~~~~~~ >> kernel/sched/core.c:5370:37: warning: cast between incompatible function types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __static_call_return0); | ^ include/linux/compiler.h:69:3: note: in definition of macro '__trace_if_value' 69 | (cond) ? \ | ^~~~ include/linux/compiler.h:56:28: note: in expansion of macro '__trace_if_var' 56 | #define if(cond, ...) if ( __trace_if_var( !!(cond , ## __VA_ARGS__) ) ) | ^~~~~~~~~~~~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__compiletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_compiletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) | ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:39:37: note: in expansion of macro 'compiletime_assert' 39 | #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) | ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:50:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BUG_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5370:3: note: in expansion of macro 'static_call_update' 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __static_call_return0); | ^~~~~~~~~~~~~~~~~~ In file included from include/linux/tracepoint.h:22, from include/trace/events/sched.h:10, from kernel/sched/core.c:10: >> kernel/sched/core.c:5370:37: warning: cast between incompatible function types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5370 | static_call_update(might_resched, (typeof(&__cond_resched)) __static_call_return0); | ^ include/linux/static_call.h:118:39: note: in definition of macro 'static_call_update' 118 | STATIC_CALL_TRAMP_ADDR(name), func); \ | ^~~~ In file included from include/linux/err.h:5, from include/linux/kthread.h:5, from include/trace/events/sched.h:8, from kernel/sched/core.c:10: kernel/sched/core.c:5383:36: warning: cast between incompatible function types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __static_call_return0); | ^ include/linux/compiler.h:58:52: note: in definition of macro '__trace_if_var' 58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond)) | ^~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__compiletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_compiletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) | ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:39:37: note: in expansion of macro 'compiletime_assert' 39 | #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) | ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:50:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BUG_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5383:3: note: in expansion of macro 'static_call_update' 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __static_call_return0); | ^~~~~~~~~~~~~~~~~~ kernel/sched/core.c:5383:36: warning: cast between incompatible function types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __static_call_return0); | ^ include/linux/compiler.h:58:61: note: in definition of macro '__trace_if_var' 58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond)) | ^~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__compiletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_compiletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) | ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:39:37: note: in expansion of macro 'compiletime_assert' 39 | #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) | ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:50:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BUG_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5383:3: note: in expansion of macro 'static_call_update' 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __static_call_return0); | ^~~~~~~~~~~~~~~~~~ kernel/sched/core.c:5383:36: warning: cast between incompatible function types from 'long int (*)(void)' to 'int (*)(void)' [-Wcast-function-type] 5383 | static_call_update(cond_resched, (typeof(&__cond_resched)) __static_call_return0); | ^ include/linux/compiler.h:69:3: note: in definition of macro '__trace_if_value' 69 | (cond) ? \ | ^~~~ include/linux/compiler.h:56:28: note: in expansion of macro '__trace_if_var' 56 | #define if(cond, ...) if ( __trace_if_var( !!(cond , ## __VA_ARGS__) ) ) | ^~~~~~~~~~~~~~ include/linux/compiler_types.h:300:3: note: in expansion of macro 'if' 300 | if (!(condition)) \ | ^~ include/linux/compiler_types.h:308:2: note: in expansion of macro '__compiletime_assert' 308 | __compiletime_assert(condition, msg, prefix, suffix) | ^~~~~~~~~~~~~~~~~~~~ include/linux/compiler_types.h:320:2: note: in expansion of macro '_compiletime_assert' 320 | _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) | ^~~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:39:37: note: in expansion of macro 'compiletime_assert' 39 | #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg) | ^~~~~~~~~~~~~~~~~~ include/linux/build_bug.h:50:2: note: in expansion of macro 'BUILD_BUG_ON_MSG' 50 | BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition) | ^~~~~~~~~~~~~~~~ include/linux/static_call.h:116:2: note: in expansion of macro 'BUILD_BUG_ON' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~~ include/linux/static_call.h:116:16: note: in expansion of macro '__same_type' 116 | BUILD_BUG_ON(!__same_type(*(func), STATIC_CALL_TRAMP(name))); \ | ^~~~~~~~~~~ kernel/sched/core.c:5383:3: note: in expansion of macro 'static_call_update' vim +5370 kernel/sched/core.c 5336 5337 /* 5338 * SC:cond_resched 5339 * SC:might_resched 5340 * SC:preempt_schedule 5341 * SC:preempt_schedule_notrace 5342 * SC:irqentry_exit_cond_resched 5343 * 5344 * 5345 * NONE: 5346 * cond_resched <- __cond_resched 5347 * might_resched <- RET0 5348 * preempt_schedule <- NOP 5349 * preempt_schedule_notrace <- NOP 5350 * irqentry_exit_cond_resched <- NOP 5351 * 5352 * VOLUNTARY: 5353 * cond_resched <- __cond_resched 5354 * might_resched <- __cond_resched 5355 * preempt_schedule <- NOP 5356 * preempt_schedule_notrace <- NOP 5357 * irqentry_exit_cond_resched <- NOP 5358 * 5359 * FULL: 5360 * cond_resched <- RET0 5361 * might_resched <- RET0 5362 * preempt_schedule <- preempt_schedule 5363 * preempt_schedule_notrace <- preempt_schedule_notrace 5364 * irqentry_exit_cond_resched <- irqentry_exit_cond_resched 5365 */ 5366 static int __init setup_preempt_mode(char *str) 5367 { 5368 if (!strcmp(str, "none")) { 5369 static_call_update(cond_resched, __cond_resched); > 5370 static_call_update(might_resched, (typeof(&__cond_resched)) __static_call_return0); 5371 static_call_update(preempt_schedule, (typeof(&preempt_schedule)) NULL); 5372 static_call_update(preempt_schedule_notrace, (typeof(&preempt_schedule_notrace)) NULL); 5373 static_call_update(irqentry_exit_cond_resched, (typeof(&irqentry_exit_cond_resched)) NULL); 5374 pr_info("Dynamic Preempt: %s\n", str); 5375 } else if (!strcmp(str, "voluntary")) { 5376 static_call_update(cond_resched, __cond_resched); 5377 static_call_update(might_resched, __cond_resched); 5378 static_call_update(preempt_schedule, (typeof(&preempt_schedule)) NULL); 5379 static_call_update(preempt_schedule_notrace, (typeof(&preempt_schedule_notrace)) NULL); 5380 static_call_update(irqentry_exit_cond_resched, (typeof(&irqentry_exit_cond_resched)) NULL); 5381 pr_info("Dynamic Preempt: %s\n", str); 5382 } else if (!strcmp(str, "full")) { 5383 static_call_update(cond_resched, (typeof(&__cond_resched)) __static_call_return0); 5384 static_call_update(might_resched, (typeof(&__cond_resched)) __static_call_return0); 5385 static_call_update(preempt_schedule, __preempt_schedule_func); 5386 static_call_update(preempt_schedule_notrace, __preempt_schedule_notrace_func); 5387 static_call_update(irqentry_exit_cond_resched, irqentry_exit_cond_resched); 5388 pr_info("Dynamic Preempt: %s\n", str); 5389 } else { 5390 pr_warn("Dynamic Preempt: Unsupported preempt mode %s, default to full\n", str); 5391 return 1; 5392 } 5393 return 0; 5394 } 5395 __setup("preempt=", setup_preempt_mode); 5396 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org --82I3+IH0IqGh5yIs Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICFEIZGAAAy5jb25maWcAjDzJdty2svt8RR9nkyzs25JlPee8owWaBJtIczIA9qANjiK3 fXWuLOVpuIn//lUBHACw2E4WjogqjDUXCv3zTz8v2OvL47ebl7vbm/v774uvx4fj083L8fPi y9398X8Xab2oar3gqdDvALm4e3j9+19/f7w0lxeLD+/Ozt4tF5vj08PxfpE8Pny5+/oKne8e H376+aekrjKxNklitlwqUVdG872+evP19vbtb4tf0uMfdzcPi9/evX+3fHt+/qv7643XTSiz TpKr733Tehzq6rfl++WyBxTp0H7+/sPyfLkcYUnBqvUAHrt4fZbenAmrTCGqzTir12iUZlok ASxnyjBVmnWtaxIgKujKPVBdKS3bRNdSja1CfjK7WnrzrlpRpFqU3Gi2KrhRtdQjVOeSsxQG z2r4B1AUdoVT/3mxthS8XzwfX17/HOmwkvWGVwbIoMrGm7gS2vBqa5iEUxGl0Ffvz2GUYbVl I2B2zZVe3D0vHh5fcOARoWWNMDmshcsJUn/WdcKK/rDfvKGaDWv947N7N4oV2sPP2ZabDZcV L8z6Wnh78CErgJzToOK6ZDRkfz3Xo54DXNCAa6VTgAzH462XPD5/1acQcO3E0frrn3apT494 cQqMGyEmTHnG2kJbtvFo0zfntdIVK/nVm18eHh+Ovw4I6qC2ovFEp2vA/ye68Jff1ErsTfmp 5S0nV7hjOsnNBN5zrKyVMiUva3kwTGuW5P7oreKFWJHjshaUHDGipS+TMKfFwBWzoujFDSR3 8fz6x/P355fjt1Hc1rziUiRWsBtZrzwN4INUXu98TpIptCqjdkZyxas01BBpXTJRhW1KlBSS yQWXuOgDPXHJtIRjho2AGIIuorFwEXILSg9EtKxTHs6U1TLhaaeLRLX2qNswqTgi+Wfvj5zy VbvOVEiI48PnxeOX6EhHTV4nG1W3MKdjgbT2ZrT08VEsh36nOm9ZIVKmuSmY0iY5JAVBHKt5 tyOtI7Adj295pdVJIKpdliYw0Wm0EijG0t9bEq+slWkbXHKkdJyoJE1rlyuVtQORHTmJYzlY 3307Pj1TTJxfmwaWUKfW6A10rGqEiLQg5a+u0M4bLVmycUzhWZMQ5jiIGMTO4PfMxTpHbuw2 QbLNZB+eTpGcl42GcStap/QI27poK83kgVhUh+MdbdcpqaHPpBmt3QQ1PYB6tKdpjx7I8i99 8/yfxQusfXED+3h+uXl5Xtzc3j6+PrzcPXwdibEVUls6ssROGJ0tOCabCEzsgRgE+SyUa8v7 9CwrlaI6SzjoWMCgfQLkMHSVFHWISgTKXonBeKRCoaeTksT9BydlT1Qm7UJNOVnD+RuATSni GocFwafhe+B6yhKoYAQ7ZtSEO7djdMJLgCZNbcqpdhSSCIADw8EWBfplpc9fCKk4KGPF18mq EFaPDIcXHkroZa1Ede4tU2zcH9MWS3e/2Xl9nv4rahw0A6MmMn11vhyPWlQavGeW8Qjn7H2g z1pwjZ2zm+SwF6sge1FRt/8+fn69Pz4tvhxvXl6fjs+2udshAQ0sg2qbBhxoZaq2ZGbFICpI AotlsXas0gDUdva2KlljdLEyWdGqfOLcw57Ozj9GIwzzxNBkLeu2UT6rgY+SUDLqUN0Z+PgZ E9J4MFL2QLxnUMLRG5GqeHVGpr6H3DVmwObXXE7aU74VCQ/UuwOAqM6qhn52LrNT8FWTzS/d ug7jctDfBH8DVNLY1iKlVageQadVlEZCLzTEBR9R0rhwag63n5vr4BvOPNk0NRAfjRW4VcH5 OK7GUMduhDwA8DgyBVsE9QR+2RyRecEoC7UqNkgW6/tI33fEb1bCwM4F8jx3mfbB1Dh6Oo1H RlAYRUGDHzxZeB19XwTfXYTUr7iu0X6GGgcErAb7WYprjh6C5ZZaliCyIbtFaAr+oMLP1NSy ySGG3zHpqcwh8gi+Qfkn3Bpvp4BjjytRzQZWVDCNS/I20mTjhzMg43cJ5k0gVwXcsOa6RF+s czIpe2OZYeKEZrCZ1HdanY/nXCPfwqHajb9NVQo/0vbOnRcZ0CLk2WjDFNMx8PSzNlhgC25e 9Amy483U1D6+EuuKFZnHF3YvWaD+rKecUSpN5aBKPUUsPA4UtWll5MSwdCtgzd25UnI+hnxI NeueZKnZeTkHmHHFpBS+YtzgaIdSTVtMQL+h1R4dCrMWWx7w0pToo4Hq/SVE+90PcnCtGKWZ VMJ4MhwQFEoBoQjZaNoyDYfpthxNj2Zv3DissUp6hukFXPEg5LO62rYSpwwj8TTl3ixOxmB6 E8dWthFWZraljVlDHj1bBskM6xl0acnm+PTl8enbzcPtccH/e3wAn5GBz5Cg1wjhwugiktO6 9ZOTd57HP5xmXO22dLO4sCEKZnqOLtrVYOeCZBwDussNbToKtpoZK9A7RU3nP7A/kFeuec9i 82joFKCXaSSooppSCyEaZjbAIw4EWuVtloGz1zCYcUhEkIFXnYkicNesbraGVvnECHOfPfLl xcoXk73NXgffvql02Vk0AClPQJo8Oapb3bTaWGOkr94c779cXrz9++Pl28sLP625AfPde4Ke ktMQ9DqnfgIryzYStRKdT1mhf+7SA1fnH08hsD3mbUmEnm36gWbGCdBguLPLOBERGAuvcVBh xlIkMEJDEoMVYiUx65Ki80IoFoxKcaA9BWPgOmEOnlsrT2AAg8DEplkDs+hIoSiunc/pIl/J PQfGBk09yCokGEpiXihv/WuAAM9yLInm1iNWXFYuawamWYlVES9ZtarhcOgzYKvn7dGxwuQt eArFakS5ruEcwFV/7yW6bWrSdvbtjAKvR+UsrXemzjI4h6vl35+/wH+3y+E/On5pbdLSI2QG HgZnsjgkmAv07W2X0zBNflAC6GxKdxvRS+/axXQFaL1CXV1EYRQskTvZQMrxxOUirQZvnh5v j8/Pj0+Ll+9/uqDfi/2iwwg0S9kQagTlPuNMt5K7oCFUCftz1oR5LmwtG5vKJIZb10WaCT8w lFyDXxPc9uAQjrHBuZRFPDrfa+AC5CzCvwowUa4KUzSKMheIwMpxlDE2G7wglZlyFaRe+jZn Z2ZGHfihS6hDDFq0VFRTl8B+GQQZgxKg3KoDSBD4XuCsr1vu5zrhkBnmpqYtcbiHq8q3qE+K FTCN2fYsMx4Xr6irErC70aQuZ9y0mMkEXix055WOjsU2p8xRv7JpnizG6DMYw4i/w/nlNboS di3E6CyR1bDQMVew+UiyRtmohAagX0ZfKYHtIi32oKqbNjxuS84KHUunh13u5tJHKc7mYVol kUCUzT7J15ENxjz3NmwBayXKtrQSlIGOKQ5Xlxc+guUNiNpK5VlpAYrRCroJ4jvE35b7iQrw csA2r4mRJC94QhEHFwIi4aTRC1i7Zua70X1jflj7mbq+OQEXkLVyCrjOWb33b3nyhjte85DT MpDlNQNmEzW4EVQy3Rotha4amK0VX8PgZzQQb5wmoM4ZnADGBlh1gaY9vHOxfIGXvKZTrD5L 1USj5BI8LBfMd9fVNj+AV2IRY4SZgK4Jc4sFX7OEyo10ODHp+uaAdH0j3mypHPT8FCSq34FF wnadQ/wF292GVsyLDL49Pty9PD4FeX0v7ui0fFuFQdUUQ7KmOAVPMP0+M4I1FPWuS0Z0jvPM IgPZ6UJS8JLagoXXG46kTYH/cD8tIj56ngA4CSBiwTXi0BTTZQQElBmbgSpOMWVBlsbSx9cG nQUWacwwH6xDMsMpqZBARLNeoaun4q5Jw1wtiNIioQwynjFYTJCnRB78K6MIANre+s2rwyBl kZ9ovQ/XgxFu5ACe6W4VWW+8MTcQZxRQ6ZkN8psrzxkpV6AoFb01x1vTlqP7eLz5vFxO3Ud7 Lpj+hAiiVpgWkG0z5RIUaDSPZb+oEdF1j1UCXkDjtcHOU/2lloHFx290JIWG4EDO+lAQ3tAX /3gQ00A26KsgTJoFtqWYczidPHZ77Txc3OuGHyZs5XC12ltKocf+A3dwRKU8HgIvLLOx+1rv gyRbJsg582tztlxSLt21Of+w9IeAlvchajQKPcwVDDP4anzPPdtgPzHCowI/B2xaucbswSHu pfzE8tDkLp492yuZyk3a+pVRQzgDki4xcDrrGN5Pw2POAuWSchP7/hD5rivofx7IizNUsVYN zFqMsq+r4kAebIw5e8+dlKmNokEMC9o5rFORHUyR6hN5aRtVF6C4GrwrC5bcN5KXuKcCuglh WZqaXvv6MKcIe5HKQZ0UbXyR1+GopoCopEGDpztPnMDSeQN2ZS17m+as9uNfx6cFGMSbr8dv x4cXu1iWNGLx+CcWOHoRaBfLe5meLrgfb87GYKkDqY1obP6UYpzSqILz4E4G2lB2bTvdZcc2 3Ba5eBzstXa1fWcjAwbQdeJ3i2aeCxABlBTeoe4+OccCtEgmEsHHXPUk+9FFlXigHmzy1TO2 lTHYQ11v2iYaDEiX6y5jj12aNIkGAUbWYCLd2qxnpKYpOItpd7r2He2g2XR3OMHgTSLd+uKl NyIevier3yb51tRbLqVIOZUOQhxQWl29lE8ZC2IUB1nIimmw24doqFWrtW+TbeMW5q6jtozF WJqlk+lT4B7aplpS9BHVPIpoSkHtYNACbmaU07YBGU35ZA0BdO40Jsl0t8AEiVLTcTjA4W/N QF/GRO+0Dri7YRTjqLyakom+i3dztAricdBnOq+nByx52mKRHSbQd0yiqS+o8Gbkf9ZwT4rC 9u7yL2IhAMwTKG00dRffHw/8HXJlg6nAupEQZs56JaA4+nh21Iyh59GXRy2yp+P/vR4fbr8v nm9v7l3kNJozTAzI8HLJLxkieg8Di8/3x3isuKYtGMt1GGzZDw2EHXz1+tw3LH4BdlscX27f /epFf8CBLtjwFDC0laX78EIf24J5kLNlYHMRPalW50uQgk+tCG+Hem9eMRD9gFDYlJYM4/CZ CKbycs7WVzyobOVHjTObcxu/e7h5+r7g317vb3qDOc6NKZohjpzhkr2f33a3E/G3TRW0lxfO xyq5X4bXVxgPPcdlT5Zm15bdPX376+bpuEif7v4bXA3y1LPu8IGuuX+UmZClFU5wSqI4ocNI SxFGoNDgrvdpZKPw0UHJkhy9NXDn0DMH2rukZzD3ziTZejrWmBuq63XBhzVOhEwfvz7dLL70 m/9sN+/XVs0g9ODJsQWqZ7P1sgGYE22BVNdR+gD1/Hb/4ew8aFI5OzOViNvOP1zGrRBRgmW+ ih5A3Dzd/vvu5XiL/uXbz8c/Yb0opxP/zTn/YcrFRQphW58fBS6zZnU44dpdUFK2x55BDx+H 6ltQH09V4cbdvRDD/Q4RiinYigdpavcsxYaUGPFns481OkQbIlCIHdrk7sfuYnTq2sqKG9Yy JWjfI4cMs9tYW6hFZVZqx+KXGgJOFS8diZu6DTnzBi9WKEDd0O3dMPjYJaOqeLK2clE4uF2g QFwuL+BIixZUyowlIXbEHFzRCIjKFB0GsW7rlrgCVUA7e9XgCuaJWBa0mcboq6vSmiIo3idz ZoBd3qqcHLpbuXs15G64zS4Xmnelov5YePmohls9Wy7uesRDqhLDxe4JT0wDcABAqjHUwbu9 jlPQ2MR4rmKEJA++SZrtmO/MCrbjyu0iWCn2wJ0jWNnlREi2zA9Yq5UVaFg4+KCYJy5FIbgB fTIMn2xNoru6tD2oQYj5+6oS2R1RmH4YqRYI/QkoUUlUlq1ZM8xLd14yhqQkGAuIKZSOu5w0 uBLe7vomXkynEjrmwsg9wuj6uTuBGVhat0H4M+5T8QQt+QlQVwMQaEYHOVnhZQ+/AE6Jhp7c SY9K9B+04znU1eSQrHwJDVa9I7q9Mo05I5m+oTgFtnf7miXxDn5Y7O/UMVnxH0hTjdzaxnVa rrmMm3sdWWFyGs0F1i8Q7DCLR0zluBDgWIEVJwBssYQFYqYHPARJM1CdWf2oD5N9pH02nSeg Bbx4DkAtJh7QpGF1JEoYoXktyOaPg+KUce6gWCe2q3uhaZMQ9hrrf4hxveKduUF8FGKoDmzR sS4xXqZj1+7t1NRWwskIl3MbypxGjC76CJV4N+H785Vw15vUwSG5TcTbVNtoBDWYWt2/YpS7 vS+gs6C4u6M72Z0CjevFgkoIbbrMcGgWB+cILHjgAY3ZUzAmfnEgebXkFWJO75d6UvVu3jxk 8jDZ2aTJO6WJpM3VU4eZva5wEsS5r5h0vnlSb9/+cfN8/Lz4jyuc/PPp8ctdHNcjWkeoU0dg 0XpXmnW1G30p4ImZgi3js3JM5oiKLCX8QRTRDwWatsQyZ19ubHmvwpLR8Y15p1F8qnccZa8k DJbjziXmEautTmH0vtipEZRMhlfXxewlgMUU61NgFGDJ1cnJkPg7cMeUQuMzPNUworRsQgUf FYgIqPFDuaoLNVXF9tXVkAgeH6YVUSZyiA6rs3GQtnJcD6oeLDCe5USJjLlpXaP/C1EzIcL2 9XFqh4mS7jGK3FEIyL0Y1WPmt2BNg6fD0hSP09gTonRTX25tVjzD//X13iSuuwjaSRjcd2vH Owkrb/zv4+3ry80f90f7ew8LWwTw4gXHK1FlpUYL52VAiiyMjO2i0H0datPRIk7eh3VjqUQK X2d1zcAkSThk5xAPIjm3WLuT8vjt8en7ohwTctOLmlO34eNVesmqllEQChn8MNDlnAJtXTZo cnM/wYjDH3yWvG7Dxwa4YqHqofDCf0Xm3YNRhdjuEsxegLm6nbEEE01wFPlaD0xylIHAE/Rv yIbuGOyaXsH3A+QHe3kHIUdcee2q5uouE+kFIV74NWZBFFWk1jOYPVn3ajqVVxfL3y5pKZ6v WwwhxFQzPuz4pIzyXVmxYwdKr5HYpXuKQgbgeC0ZZk+CGuRNcEuXQABT2Qo8qmoteNVXsrik cmjKVNiIpdLq6n+CM/P8aGKq66aug9zU9aqlbj6u32dBWdW1mj7r6Nus13KiXtFWJfdZJc/p TPu3BdMwatCTjS1ID4MKV8W6jcK7Xq8r9xYdupisYGtKsTdxcQfQzFb3xW+iR3+nbeZ/YsXm bPDax7IEZrzJrHGwJxvK+Epsg/LSR96DRp1XmiPP6d5WVMeXvx6f/gMOlKdaxz3CGXMym1gJ z1XGL7AAAfPatlQw2tvQBX1m+0yW1gSSUHyZCWSge6YgWfjbC6QDItyWx7uKxr3fwx9xIIcD BBBjfJ0I1h4LGKnSZ0BqKp877bdJ86SJJsNmWyU1NxkiSCZpOO5bNDO/NuOAazTWvGz3VK2o xTC6raoox3yoQN/XG8FpariOW03fJCI0q9tTsHFaegIki2H5PAw8y3mgaGbyQBY6bNdvRIaM mnTS9M3h8G3azDOwxZBs9wMMhAJdMG9Esy3ODn+uB26jrEyPk7QrP3zrzWYPv3pz+/rH3e2b cPQy/RD5/APXbS9DNt1edryOISNdp2aR3AtdrJM06Uzcgru/PEXay5O0vSSIG66hFM3lPDTi WR+khJ7sGtrMpaTO3oKrFNxYg8Xy+tDwSW/HaSeWipqmKbof/ZqRBItoT38ervj60hS7H81n 0fKS0Y8IHJmb4vRAZQO8Myfa+EMzmIYt2cyrxR4H3EabBQIjWTbRj5f4yC7JS0JXzQkgqJc0 mVkn1mIlMwpXpjQVgEz0oTFNV5EW5zMzrKRI17OXh1Y1qOB5U9dEDrYtWGU+Ls/PPpHglCcV p81YUST0exGmWUHTbn/+gR6KNfQT0yav56a/LOpdwyqaPpxz3NMH+ifL8DzmfxEjTahXsWmF d0IQUOFD6W8eMYB8DKOKLTlY3fBqq3ZiUuHYHz/hV/jrtD8jOGsHymbG+LnfmaCnzNW8B+RW Cg7uLEbxHp/roR6fw/ok9fwEVaJoi9/9VgfiNFLQv0Tn4SQFU+r/Obua5rZxJv1XfNraPaRG pCSbOuQAgZCEmCBpApIoX1iexDPjWr9xyvHsO/vvFw1QJAA2pNQePBOhGx/EZ3ej+wHHdlVz eLagMp46HzVg/eBJKH04/MS/oRdbbz6ef34EZkbTunu1Zfi0M+usqfS5WJVchV5svQg9KT4g uOKyM2hENCSP9UtkGawj7usb3UFNbDfadPcUU6SPvGGFvbwfK95sYZklU0esM+H78/O3nzcf bze/P+vvBFPMNzDD3OgTxDCMxpZzCmg9oJbsIKjYRu+6LtSbe466GEPfrzzdF34bC4KBd/AG aVVPfVSd3uQRrBlW77oYGGC5wfuzlvp4Cp3EXBl4g9OwE/S8FUEYMaju49fqhaGbV7j2T7BT VHaz6lOY2imtbZ+3lfBaaYSHMEOYP//Py1fEt8kyc+mYCKa/9LGyhnUsPC3aUMD7DMtgXX20 kOhfcRiisQPHDjxdoGNMCn706Ia+dk25MVfpLQIpE6hE1sIrxqQ4zsleWYZmnIWlbg8+Czw2 sDb9EvOIYxNl1No7Lj4Yp0CJiapAMX5/Ya9cWBTG8VXtsZMRSGArhM1hhObxcvIKPyqApmdJ nEbwPd5UGXo1md6AW0O9cCbBMCFPZCgNDZwW4v0NHL80MJaRNSn8Bz+Je69g8IQMd1BI+/r2 /eP97RVQyr4Ny7BfnD9f/vx+BC86YKRv+h/y7x8/3t4/XE+8S2zWCP72uy735RXIz9FiLnDZ 3f7p2zMEAhry2GiAVpyUdZ13cJjFe2DoHfb924+3l+8fnlEJNpcyNz486OnrZRyK+vnvl4+v f+H97S+BYy8iKUaj5cdLG6chJS7eVk0F5cSfjJBibvc6yrF9CkqwdvH+Mz59fXr/dvP7+8u3 P5+9hp8gchifp/ntXbrCRegsna1w+b4hNQ9EkdGP8uVrf2TcVOF1yt7eVO9Y4d0weckQc7fz gIIPStS+x/g5TYtZ+xKFXVSkzElRubfVdWOrGVxvDZrhufcGn9TXNz0/38c2b45mDLwbsXOS MRbngE7onGWtashQCXzI0Owxn/Hhst+LtH7kO1+YenWfT/6pP23f9kFgs9hPB/9q7CzmmXtW lxpR/+BW3sJDXWJghyZifLAMYKvui9FaFDgCYZuz6B4q2d3vAWJcBYAGpgRirjT7cozPJlKM zX9mYueSzpLSCFpgIqQiWMtAPuwLAFRZ84Ir7t7TN2zrXQDY3x13cTH7NH2M80niMZkkCeGC kJ0LbB6mBeo5n4MsPqVQ6vjfg3OpcW0yE3TjYwHoGcpKygbEOt+JYbqEh8iEb0Yo9HYXsYMg IRxh183iyNGVFmzpRD86j0CJQpYIHydd/zQDK6cH59P7xws0++bH0/vPYA+HbKS5A8CNiM4N HOegxwmXw6M71mANGB7nctIhWd9auDM0zgafPyXRAoyLtHEBctHNpmxwtQM3O+6YTT/YfPFe /1Of3AByaqHF1PvT9582gOGmePpfT6iHmqoqgBtVuamVwyWunkZW7Z/0d0PEb00lftu8Pv3U h95fLz+cw9Pt1A33v+wLyxkNlh+k6yUYIqD3+cHKYgzEVTlpKZDLCu4/IwMGDGuInIfbLntN OimgcOjx2aEZt6wSTKGoz8BifeLKe60052rXJf6XBNT0InUx7QWeIGlBKVqyxD7QhHfrM+pC HxGRy+laA4o+VrE3Bc7kveJFMHeJCBKqIIGspY3BGaGH49PJSqxPP36AiaRPNMYEw/X0FUKF gzlXge7dQp+CiThYp+B44O3jTuIkfsilnQO8Mx/RwGUpmPNOiEuAoTUj+znFyNsakE7ARSEY AD0sd7dtgwLxAJ3TXWu718vG5DptIjAFpofus9kiLNbjkHSdws11xJoILCVTH8+vUXKxWMy2 bZQcaD8epReLJ2kdKavyJKr9ZB+wAAaHRm8G+PliCikI4NuiZ9a1CWbBpZ9f//gEAv7Ty/fn bze6zP6cwxQHU6Ogy2US7+Ri0hxvcgRUd7tQebjMACxDVQqQCMB65vq69FQt1cgeGS9Js16l fPn535+q758ofGvM+AM15hXdzh2rqvEFLrV0Jj4ni2mq+rwYO/d6v1kTrJbf/UohJQivMttc yYCCJsJ7PRAcc2y4wrNNQdddot1CEULawvm0ne5u5Nj1rbEn49O/f9NH8pNWAV/NJ938YTe1 UesNp4kpP2cQLxWuiykfjdkpBg7R8gja15kD9pvIzDJ0B7h4mpk0ABg4kQjEy8+vyOjBf+zj I9OS9CBUGHTa2Cdc3lcl3fHJsRaQrehw6cr7UibjUOlv3CHreq3OM8p6RFKqZ/efej475o4w P6MUbbdOB5vCjggRu8IMedcRrAysHcPVAqwn09qi1t948x/2/+mN3k1v/mV9elChzbD5s/zB vCF1FtCGKq4X7BayXwfCoE7ojoUDoBXsWoZhzdY9LEU68zsIqOAGiQfTnjm2xZ6FFRuIwSDS uUID2APsiJqCdNxjQowWFZuEabelD9BR9ncQndBTDmBLpprM+9vH29e3VxdzuKx70Au7Tx4E wwx2XvqwJh3trS9OC1+yagDrQ86Lwyx1A0ryZbpsu7x2Yy6dxF7bHfX8vRAn0Fhxa9JaQPhf 5I6XlCoigCi+EWbbx0ulcjVP5WKWIP2tFdyikgDcB4hQnPo+9DutXRfYzkfqXK6yWUrcuxQu i3Q1m83DlHQ2ppz7UmnKcokQ1rvk7s5DPjpTTJ2rGS4i7QS9nS9xS1wuk9sMJ8mYQOGaSOM+ hC3gJ7edzDcMAwwB3+tOK6QeFlR9qEnJMXaa+tgp9reeM7qRpOnSxPSX3U5ZDdLoZCu16R1R qaMR9YkW9GWSLEh7m90tvdskS1nNaXuLzRlL1uJ5l612NfO/r6cylsxmC3wP9hvvmDzWd8ls MpH7cPp/nn7e8O8/P97//pfBAf/519O7Fo4+QF+Hcm5eYVP/plfwyw/4pys0KFDL0Lb8P8rF tgXfqkXAXcZg2dXe3csZtQyXWAaq/rvCoFqc42CNtgcREYq0JHd8wLMyusOvzc0kJgWFKNyY rHWe5zEtZaDvpQeaviNa0dNqCkfHxtuNvctMng+ChQRXiV46niwHIEJEgnsEYxkc8/NeBtAZ 9jk6xthNMl8tbv5z8/L+fNR//+Xd25yz84aB2RHtpjMRLDAn9IsvVuP0N6F6LlSArWbst5j1 TWubFq44eFclfIliXZV5TKgypxVKgc/Y7kmD+waxBwNHccGHWLGYIkco+Frh87+Okg5tjALK S+QGea3Xyj7HTVjbiFeZbp8ML7XG7wJdroq4Mag93kCd3h3MyJgnFiO5D0xhkr913DDu5I63 VVmICq9Mi2eBp9hZq/14f/n9b3igVtp7OeIE6Hnq+vnS9BezDIcGxMNbH3BnHhz0Gas3ljn1 bTKsmEdOZWPWmNPlHe6zNjJk+IXdQZ+oDBch1KneVShsjtNSkpNaMU+m65OMvWvD0ZgXt4At 8xcgU8k8iTmNnzMVhII25aMCykLrg+g1gJdVMT+0iVAWyB/OfZc5uBSKzO4WKsijG7LkkXy0 LZFnSZJ0wfR1BkznnePCWT+YpaCxxQ1wSu0Wvd9ym6S3o1L5N8fkIQKR5OZrKP6JMJUrH41M FTEvzwK3ZwEBX+pAiQ3PtXmyb6rG/06T0pXrLEMRQp3M9k1NfyGuF/g6W1MBGysuFa/LFu8M Gpt3im+rEl/yUBi+Xi3+YKhHuhkxBdP/YBog361LzHbv5IEMwYNZ+kjAHH68TAe+9/pV7fYl 3F2X8MAD7kfnshyus6wjtmOXp4nwFPxhH/oqIF+xY4X0vQT7pE7hc3wg40M7kPE5NpIPmKXB bRlvGt82QWW2+ufKfKdaKvW+JtwWkSwmfNNbYLTt4Ek5XH4q0dAtp8DcP0ps1EyBwh67uXrH xLGiIo08XqQHP/S/mpYHkHHMU+LWLL3advbYGxqnpM3+C1fSewG038w34vAlya5sYxZbDS15 tydHF4jRIfEsXbYtTupR0MehxmGXIXkW8s0i2tgWd3HV6ZHlyttYlvAMGymLaO34TvpFXBlr QZoD89/jEAcR85mW91u8fnl/wl4ydCvStZCy8qaVKNpFF3EL17Rl3IilqfJ4kbw5XmkPp40/ Ce5lli0i78Nr0jLRxeKxOffyUWeNqbtBpVVoj9fdcreYX1kDJqdkAp/r4tR4iKPwO5lFxmrD SFFeqa4kqq9s3IxsEq7ryGyepVc2WP1PeObaEz5lGplphxYN1vGLa6qyEvjGUPpt51ouhEDw UsvbAGDZhdLKtIRsvpohOxZpY3JOydL7qE2kz12H+hbS8oM+e70zxb4Aj2t8Tsbq3vtmQLq9 cn7ZaGLdF1teBpZeYlAx0U85MXCD2/Ar4nLNSgloTZ7Fq7p6pj4U1dZ/IOqhIPO2xUWVhyIq ROoyW1Z2MfIDes3lNmQPVi7hyWkPFEyZsUC+Rlwd3Cb3Pq25nS2urJqGgRbmHe9ZMl9FYuyA pCp8STVZcru6VpmeB0SiK6qBmKsGJUkitGThObBLOMNCNQ/JyVxcQpdQFVp91n/+K1iReBGd DrCt9JoKJ3lB/P2HrtLZHLsJ8XJ5a0P/XEWeXtCkZHVlQKWQFNlXpKCrhEach1nNaRKrU5e3 SpKIUgTExbWdWVYUvNVa3BojlTl8vC5QQi+CXxjefenvKnV9EnpCx4RTvTnjsj/ErZWRs4ej zzE5jTiVVS19rIj8SLu22AoU2N3Jq9hur7xt1aZcyeXn4B2ttbQCsbcyEt2rApPGtMyDfybo n10DsMX46ampB0BH4yh+iFPskT8GSAw2pTsuYxNuYJhfMyHY+zC38P6GjLQ8vo32PEWh+/rq ALW8CWwU/XoCQlrj7qqbPI88wMLrOo6tINfhuypjpbtTLMYNhOn+qcCJobWmEnOBGsIiJlSn xjrytDmuLu7luo+0NDcEbocBSaus+GAA8V7rWBF7HZBrtiUy9GV26I0qsmSJ99tIxzc+oIN8 nEXOf6Drv5hIBmRe7/B96li4jy/Ar9GqK+yRi9GUZ3TVPy8EgGnqciITooUKFxnDJTlmOIR6 NlogpOCpr5DUSO5pP7sK7ifxyd1wKfyocKTQUZPEiEzLtNE+ddUihNwQP/LSow3iEUaUHCe4 sQ1uuorwP55yVypyScaYzMoSC0RqyIni6+IYu7gSoF7g9rHeitJFYkbss59dXDuBC0DJMZdI 2BicyNdRXJc5cvf5/cffH9ErVl7We/d9M/jZFSyXYdpmAzhXhReoYykWue3eh5kyFEFUw9ue Mvjrv8KbEC/wAPgfT56jTp8JHgLVnz4prE+HYON9G6VK2jCtRrSfk1m6uMxz+nx3m/ksX6oT UjU7oIkWLszp5JhDqc1wz07rykbEjZaIPk1vYdjB6ZDr5TLLxjYElBVGUffrHEl/UMnMf5zM I91hQoLDkSa3M6TUvAdxaG6zJUIu7vHGgGsm2hTjIw7QBhEAi4FRUXK7SDBHF5clWyRY79kZ irVXZPN0HiHMMYIg7d18iQ2EoBJLrZskTRBCyY7Kt7oMJADaACMavqMMbL1+d6lLzu809zju SDOkqo7kSE4YaV/io6lE2qlqT3c6BSG3kRkJprLOf9vu3Enq3rydgy73MdH81BtDiiR1pKgl lr4++QEgAwEsGvr/EYFt5NOKCqkjb10iXFq5C1wwRyZ6ugQaOzSMb9i6qvC7gpHNIPsh0cET RlbAWUhRn+Sx/QwEE9/E49RlRpujsTYD0wYQ9vrr7wnxIGKDOXSYR5Cs4aSYtkbrqgUzzYm2 ZU3FcnW3CEukJ1KTMBH6JnT/9CnwF61qYEK/4SDbtiWTOsPNsP/gYQIFFUb5tBiNNGw44QB3 zJHAzikdKYme+hhh7q2UMT2P3GKMDJgkPZBptW4IUt92k2Lt2zauxOkldwKl7OG9VuE69w40 I1MTqtAPkzxnRw4Xr5ear4RvHRzLNhbgy11zJE3Dq4vlC7I1lzBI6w0actWsY6Q18e+IRirg 1175rCPP9Q+k6McdK3d7gs8FuZwlmGFu4ADZao+OU1u7KP9ecrfZxCi9lDptSt02V+blRnJy G7nMM6vEAM1hm1pPhm3GSpFj65xEiBzQ0r0fUO3Ss6wW2e2sxakkv8vuVpdovsOqT/fmpEcC rbUTqF+Fx7fXkhdvKW9iJa33aTJL5lfKMVzpKlYIKJBVyTpOy2w5wzHTPP5TRpUgCWqBnzJu k2QWrfqklKwn95FRzkUQlYVxBGeFy5KT1WyO6eMeE2zfTYVXsiOiljseawNjgQnTpW1JARhT 5ti80gbW0rm9QkeIo1cAQtxWVc4j03mnd1P/4VaXyguup0nE+8Xhk7fydHeLe6p4LdmXj9dG ld2rTZqkd5HeDC4dfBp+WePyHAlcOx2zGRqyMeWMrmWtUiRJNksiVKq33NhgCSGTZBGhsWID T2XwOsZgfuA0XrKWR2apuL9zX6vzNkRWGiCTSI/nqtuoZTu7xenm3w2EJV2g6wM7QoV47/l8 2XZKRnp62O6wQcpVdte28WEyBtlK1JXk/lPVIZNdilfnjzHSkjKA7YuyziNRRQEbj0BoTRqp 9s0a8yULGc1Ci/dILij0dxKZoKZJzYWJZhjy0Fw4aQQEt5KiOxcU/axtpSpcoQs5vwAEBCbZ T3qqqC6OdooJvyHX4wncInj07LBDAhjFi2Ug10f5zRL9tcEm8hTTmSYLjKs0mcfaqYfanDHX Zo7mS2ez9sKBajkiW5MlRjbunthxHh2YRnQo2ol30vCC+a86+9SJIoZxqSQ1L7XiZSixud6M fbOISjCyzW4jwK9ej9Tydjm7u77nPDJ1m6bXJLpHo9jgnd9UO9GLfPPI0fEgPQ8/r2RecsW9 u8fe0sNlzHuDL/Bgs93T+zeDFcV/q27A3O0Fgzbu6YXEuwYc5mfHs9kiDRP1f8PIWEugKkvp XRK5/zcsNQUTE9LdllzwtbVmBdkagrnJWVrv/e9ZwfrKZCq89+b7DA31ufsrCcdQ7fFbk6yb YR901pYI5gdBnlO6Ui6XGZJeLNyvHJKZ2Ceze1zaG5g2IpsFLP1VLDYFhigt7ELERoH99fT+ 9PUDsOzCIGKlvMdtD7E3HVZZVyvfd8EGbppkJFNhoNEBpAvw0D6fw+Ke31+eXqfh6laKt497 UDeEoydkqR+UOyR2OasbZqCXHHAhhC+I4HZJye1yOSPdgeikMoIs5fJvwMaCPT/lMlEbcxVp tPtGi9dKFwHVJbCWNLH2R+72XBZh5GrMeuZylU23N4hYC4zawHORgg0saEWsVazMUZ82rwOO eieIfU9+vPo9jUoz1F3bZSpqGZkMgg8zsnz7/gnSdCFmaprY2mnEps0Mn154gCQBITrsA8PQ x0nA4QsOTqJTZtgXX9BXk3oiGMH5A5LLEs7FXuprSWnZRvw7zhzJLZd37YWxWFNxO29bpCE9 5Vda0h8CXxSB+M7Ig9ce61W2iDGtJzd17BTTxI3UvVhDDchXjcRf+TDDzctNwdqwxT4jLOHH ZL5EapR1GPE6IPZ4221YIlVNcTbO+6QS0H8Ah9M9LY3npQpFA3qiBclRhGdRtcT6fxThBUAL noaATxdx8D+V1Fy8biOv8KDYyGW3ywtHmR0uA5X7DKyb2j8nhaywsttGIC/K6rESaPV78BXz D1QD0qhl6xI7L3aHMx4mMqhwoT+BZhxPbfCGKRVWah98O9mJeC24lgbLvHDdZ01qDn+Meq8L GgIgCHU5UZ5t3FIALcLesmLmZFOqcTazNxIb/4lYIEs+KVRKjsVUGdqRwOMG7j2ObQdgcleu NX137J/nRZLMoyNatPPe9xupga/SSCDew8dD8pos5on7FSPpwLGQPZfeY9tPKC14igXhknUN QbXefOwd98DB5+ZrXMAbVpJ7WQ/ww/DwxcKzs42pC1fYok268BWY+vycALrpRNvkrP8jQUFk 4XE25nlR6pR7wVBnoYOH4aUZfQl9V7PgV9c/vziO1jnxjCiOjRgpt3TH4P4Ipo6j5VH9V+OT zE02fFyGhgGbOmWDu9XADc8l6ZOCl0HktEsv94dKRaLsga+UqIZPt1ilTmVOKnWv5yDhoADu vqna07TNUs3nj7UL+xJSAvsjK2j/TuvQ7pYXxSmGUjvVbRxVuh+OZi+VeWXNQjNPXclSiniQ edAptOamfyutbWy9dzEh1aiVAK3lJ4cwlCZtp1k9ryudKIzjl8V6+vv14+XH6/M/+ougXQbR D4H06LNNMOAmDIWii/kM8yM6c9SUrJYLbx/zSf9crOD/GLuS5shtZP1XdJyJGD9zKZLgwQdu VWKLYFEEa5EuFXKrbCumu9WvJc+z//1DAlywJKg5tKIrv8SW2BJgIpMLZBWnzbnoGlxBWW2t Ws/RwTicJ3XRZc1uny+BLyCT+ZAMHowX0Y0L5g2jQP/j9e39A5/xMvvaj0L8I96Mx7ih5Iyf V3BaJpEjXpmEwU/BGn6hHW6zLJYL6yJBBZkjrpEEqUP14mBX12fsu58c4MPlVJiDqRU3bO6K ytdmfDTjYQOFxUnNoih1dwXH4xC/mxrhNMYvDAE29msT48ubtWzAomBfZYiyClqrI/Lt77f3 69ebX8Gj9uiZ9B9f+QD88vfN9euv1+fn6/PNzyPXT/xACi5L/6lnWUBECl1XBzJXvOtdK9wr mS50DJg1+J5rsGE+Iw2WPHvgam3tCDRnZOd4hwhsFa2O7hHhcG4J0F1FOzWerFiYhf2gWWu+ fs0tcmTGamp4TgGqfPxhdXn1F99pvvEjFef5WS4kT89P39/dC0hZ78Fk6oDerAuGpg30pvT7 fD9sD4+Plz3Xh3VsyMCk8EgNat0+jE6sRPn79z/kgjrWURl4+qga12az9aPhIhrAcLptdC20 xqwzws7ooDkkjVEEDhbd/gNnFtgCPmBxaQ/qzq+kCx1XAx127BujBCxaJR63R/fPzn+uvNdo hw44bHWf0z5/eZEO4WydADLlyj68K74T2ipej4lHXNEuA0lBxnVmLvN3iCzw9P76w95Ph47X 6PXzv9H68Gb4ESEXodLZk0mEFLsZ3yyB9bwzPOT7K092veHDms+3Z+Ewn09CUfDb/2hvlaz6 zM2rW7jvUNpbt1Q1uAcG/j/lomAMJ7EAyrEERtWYJSZliejnxokIZjNxYNNp0QUh84iuepqo jbCzH3lnmz6t0zbCDzR9/3Csq5M2Jke0eWjPlpmtwWOclOf2Nly/brK7CqkNPyAY9t9zdbK2 3beQbKXEoiozCNx0hwi0ao9VP2iB7Ueoau5u4eoVrVJFaT2w/NDvbGxX0bqtx3RWjeui+qC6 nzLWuUQB1G1dNcjYaKpT7agRO7R9zSrRMzY61Lu5OOnAms/Zt6e3m+8v3z6///iCPexzsVhD D05NGTKM2CZp/MgBhC4gVcY+rDTyU4BOEA6BIZzQ6DM48gOV4zI60jUS1f29/nxLzlPT/ljk wB4YGlldgIU8oukpgHg5YrZPAhYPJbzlICcdKH99+v6da3dCm0FUBNkYWna4si3g8uSKsCpg +DTkRudFDNGCdM4atZaQTctJzJKzJRFatY9+kLiSsXpvpzmeSYQr8QK2FS9DUpftaBCjR7XH 5Cx3KL4J/DSi8NV0tSe2iW98VzJkNJDEjbrOUxMY+qhHPQGf6hZ8Xupj+nJiflxsiNre1fbM Jw5Bvf71ne+qmtI3hqgwXl2pVD1wkTKyPbv7gR44myQuD8KzkdlIHYvRMxQY+lBrhLckSswM h64uAjIaxSp6nSECOSm35bpo8pJXwKeno1FI0T+wQXyQO1YGBNt5FJlETasXJPPUIohNRxJL ROZ6OzYTTF5IbAlNACR2dsNwamLtRleOLErSdKNNJFs2c4w9S2bWAua8ppBiHVwvp2WD+Y66 X5k7IgwlvF/38auSiamSXAFuQCS4+rIIA9NLhRL/D5MA2KchEhhTIaiAjy8/3v/kWqqx4Ghy 2+36apcN+94cAVxfPnRq76C5TWlETDJRqP/T/72MBzL69PZudNbJn+I/wwPBPTZkFpaSBZtU GTY6QgIc8U/a1cECOc7zCwPb1WqDkZaoLWRfnv5zNRsnDpQX8IOJBkGeGJjxkWEGoGG6xT7K QbSmq4CI8ZVn6jMkjUO3M9QTY1e0Godqf6YCxIucuYbYYqpz+O7EmN2czkFciSPPMbpmjoR4 eHsS4jsaWqnmkzriJ8jgGQeJor+LCL59xdBHMHN8367RPuKq9LUwuyrb7YmiXoC6MpOM9jkz KwuISM/ngvIhhe+xJA0iM42IqGjQxrTqI5zlKz0/Be3gAp1v8l6M6bBT6uIUeKpOP9GhY9QX 0iqdaLqBhqwVJRgCLCnL0aipYyM4qiaS7tR6M5GVaX4fJC4HXnOV4EkLNmcmBni7kGjbqYEE DoRvOgsytcR+LzUhXNfhHRWGWCfWrIOSViQkRo2HJgaNI8CV2InFsVQvmQt5o5kPYRxhXa5U zN9ESWI3GJTJJE5DFOG6CpakC2L9HdaE8K7e+BHe1RoP6iVL5QgipGAAEvV8qwARLxcHiO7I T4VSslYPRvNwk2BppVKY4l89puG3yw67Cr4DBukG19FmztE0ZpWpHyIvdLnOldXqh3TjOOTN rS7TNHVYek88p7opsIEo1tZFxuLn5ViXJmm8QZY3AtLa7+mda06Y/ekYzCWvh8Pu0Gs+Yi0Q 2xZnpjLZ+Bs0OSBkNSn1vcDH0wKEaSY6R+xOjDue13hQB3Qqh58kjgLSYOMyC594Bt78/4Zn vRKcIw7wSnAIPTvqHMqsnQEWJkjMn4wVSay6spiBMwSsasHEimvRDVabOwJOwFdbe+d7H/Js M+pHt3KjXxcdLcGXaL/DA2MswYq6pmLUZfk4tTvH/RAvDF1VlYhchnOHDt+SxajvvwX3UUGX VdPw1Y8iyHTotsqqozsuDdzUeRRq4nOVeYslFvc/wRbX7xamKEwiTEGZOVhxSxEBbQd+0jkM 2aB/qZzgXRP5xGHSO3MEHqNoYq6dYSZnCh7YNbqtb2M/RANb1TnNUMsrhaGrzmhSfoS1FGCk p6LVYQaf/mCG2LWGazib+qnYoCsDnz29H6wOQIgYzXUaO0+5a6IDTUKJ49GUxpUiq4sEkC4B gx0/QmYDAIHvqssmCHCLZYVjgyx+AojRESChtfUY1LkA3RMAib14bcsSLH5qV0kAMcGBFOl5 Tg/9JESkDGHEYnxPFVCIeaLVOPAxJSCHM0GNJ8VVbb3mDgVuZiq6kCsGazVtzn21g03JFsFQ xNEGkUzVbgM/p8WsTtnl9glfbta0nYbGITKkaBKi44kmuFKoMGAfExQYGRQNJfjopWS96gSf SpSs1wGdzBSdyTRFpZNGQYiqiAJy6Og6z7ocu4IkYbw+qIBng367mTjaoZB3aTWTN5RWHm0x 8HmKnwVUniRZWwc4R0I8RH4ApB4ydtuuoIn5pGRq1pZEKTZXOt1j0ZwAJ4O6G8ROfTr4YCTn VXPpttgHYmX3vBTbbYeUXbesO/BjfsdQtA+jANOWOEC8GBFX3Xcs2nhYEtbExA/RFbyhQeTF +IW7tokla4cazhESH9l3xg0CW5nE8o9VlyOB51rnOYLtmnKFJXgNws1mg+dGYkLQNbHjDV4b zR2Nk3gz9MhIO1d8v0PXqvtowz75HsnWtnB+2N94fJvHMuBYFMbJ+iHvUJSpt6pyAUfgoVU8 l13lr6oYjw1vHSJNlg+sRsi3A67McGB1s+N4+JcjYbG+eK7ZkM5HC1pxXWJ9265o4W9Wd0bO Efgeug1yKIZL1rUmUlZsEooM5wlJ0WEg0TxM19Z1fjiJYvHsjtI9ojAIPEDULAGEMQIMA0Mn Hz+7cTUJW10LPyAl8dE5lpUsIcHqVQkXIUHXwDYLPESlBDq+YXAkDIL1YTMUCXbbOsO3tMCC Bg+08z18ugKyNnwEAyocjmwcRt0qy0ctol2EOrqaGMB1e9EdxvOXlZ7DMYlxk+mZZ/ADx0fh hYUE4TrLiYRJEq6fyIGH+LhDVZUn9fGHyQpHgBzbBYBocoKOjG5JB218tDjEKtPwPQn1laHz xO0OLYBP0NutC6kEhBmp23MNXrb8F/dLw53n+6iHMtAQdceVIwn8OTfGy0eLhw3ZUDOHt9GJ qaJVv6ta8DYwPveDq6Hs4ULZL57JbNwOT+RTXwvvd5ehr3Vb3IljfAR22e2PvFpVdznVDLc9 xlJss7rnO1CGu15DEoCTCenV0K6sniFWWWclEb48a3fiD14QVpGyOm776l7pXatLDk02yJdQ o6vo9+sXsND98fXpC2oNL+JEiw4smoxi0QG41nXp7uDrJu2wgSWzYPviUg5sYlDzWYY8Zw03 3vmDCgELls/8IXk1L6ttxe1qZriIllzUD8FIPiOX/RB2olhPQGag3Z+yh/0B++g988inweKd 3KVqYaqUSBHgqlnYZvPclrk3w8KqchoSp6f3z388v/5+0/24vr98vb7++X6ze+WN/vaqfnyZ E3d9NeYM4xIpXGfgi1Pzy9ePmNr9vkNlYvB1GR4TCuNXp/GYv95gy2P6sqDut8OcJ1KcvNhG OllajSPAcpGDYo9enKrIIogyG8AJHDYPZegTO7/Huu7B5AIpqTlDZmoBY1DS1daesKyys3AL gVU6K+4PEKscr3dWHqXnZ7MqWVNTeMdnptMYEt/znQxVXlz4SXbjKFl8UyCVWS7rIHwN1x8d bg54ptt66IoAFdJS+KHfT81CCq/zhBcii55JNGO9OoW28EFVr10dh55XsdzZ6LqCc4IT5c1a AUniB9tV3AneduvykKaUDmkwfrQwxSEuu/zQFEB7NLtmBGLvfNZz4LpwpFPgrDVZ9dpImOSJ bKG2e99T2ONc7QalG2/UpPHpBXEqSRKbmFpECKP3aNSSD76q48fAEJmDbZ16oTWj+QqZeD5x 1BE8lGSBPyaabEd/+vXp7fq8LI3F049nbUUEl2HFanfzDI13hJNZpivzMSHnWLJWWg6OKPeM 1bnhVQf1L54XNFPZFbL+S8SuEbaqOPeMq2UuAEPDJApcOglBk44QhBC7FBSzONPYjJcQEjMt 2paH6L/9+e0zPLayo0NNfb4tLa0DaPBJ3XH2g7gH0tgc/SQnUmdDQBLP8JkAiHB176ne9gRV sdrWq3HuAu/sdjC/nYM0gMbrqM1sjq2lk1SXs3zI2HwdMxN1Jz4zmeD3UjOO2iotqPqiDEQs TNnOZklCvwhWqm2as0803epipuKX/yNshNtSQWkfr0u08CHA5krdZoOvaZ8YCq63sbrQ7tmA yvOwfA4oGUl9/f6Q9XfoY+OZuekK82GMhjH00cxyTjGDfKh0eCp/WkXhHFCbYpJs4NxMHN4/ aKPgc73CXtg6rj7mZ3xXUrlWOO5ZHOAWdwB/ytpHvkDt8XjuwGG+jwCasI/U76MXMnYLP6Oa UaWcr6bl4UidrA6N2c3pZOMe3dLCErtmndEgssoa7RjtnFLstlOgQxyqZrcTLTUbMp0CzOyP dVf1wkGJsy38YIPFrgRIMUOdt2tJMT3yz3TnXBJF2c8vVFSYFpot6ItoiNBvuYCyqkD2CVZv kviMbk2MRo77U4HePRA+TrDvHFl+jjzPyjPLQ38ku6r4wAr1SgpomvNuQ5SAN12Yrgw/sOIl xAnz3BuKu9IQvZo1/HiAX211LPY9h+msNDfFrwFHj7xGK5dHSxY1taY10Aluwzc1ynguNedG YmunE/TUYXKoMKxthpyFLz/6E4nh1Gy80Nnh43MrdOidGj9IwrWh0tAwsmeAPDY4G+J+Uil0 oL5+3LdrmsqJko29yHJq6K/rTsASees5m6/M1tTKKWlf7eB2UX0WNZOkuooB2/pccWHsm0Ga cs1VXVjA69pBPONr2QF3kLAww72ouBad2bFS+W6zk6MPg8zdywBjD//OuLBlxUAIakal8JRR mBKsBqMijddgGhhNucfXQ5uV6yXwvuUD7klJX6008tJS6eNJd0UR3fBTx2Js5dZYAtV1v4H4 eMbbrI3CKFrvBd05z0KvWZOGnqPKYIARJD5muLkwwV6Q+FjeAgnwrMVDj/U+ABaXMMFwIyKY eZzOEycxnsGkcK3mAEyRuj9oEIk3qTNzEsfYTqHzaEqYAUWBE1K1Kw0ynqgYGAlcsugIidZl CUqdj3YyIEHoyJhjEa4H6EwfycpQKRcE3mRvInTK2Mqhgh0J8WI8GUDEDaU4pD8sXYB7iDUD TnhWGyi4IDTEUTP3Whj6jHU5uEXpaiO6FHhXQlMMGxnEBqmU/UgGYaHHwLE0s4B2mUNL1bmY 45ZF4YooSeL1aciaHVxUo4IH0yI/DtHJAipUEOLdLLW8AB0dtrZoYsQxk7AXTziT766yqS5q qFD4VrOf9SUMkfoOPv6aLK9zxdlJbx5dOEGLN9zUvXJBkHdbQbnwY3Slr/rF6L+3xz6jC/RY F2rUth7cjNa8gnSv+jOve3hGov2uDevgkeSI2cBRWlTSF5mSAFyjq4GI6n50o2/kjPgvXcC+ KvtsCLVc2NBXGX3UgjT3kzcNq8x6t++75rCT9dOatDtkrcMFIB8WA09R4yYSXJLNft/Bq2+8 2nNkT5ME3qFbRmt4V6fDarV5/ud8f76Ux1JjGtRYhoV1CgZKux/qba1mDtSu1vpTxEQXQI+p 8WOKC18aRcj2T8rpa04JSqHpFxxqdJuEqMmgAM3ouEA0L6hF5pXj85kIKHVoWEWAz8nSZ3XL brNyfzLZtHYgbdAAPmDBs/xK+rzsj8JFKauaqpg/gtDr88vTdNR5//u76p55FGFG4S55qYGG yvill+HoYijrXQ3OSdwcfQZ+MRwgK3sXNHkNcuHiGboquNkpj9VkRRSfX38gIduPdVntL5pv 3FE6e/HMTnNbXh7z5YStFaplPjrieL6+bpqXb3/+dfP6Hc6db2apx02jbBYLTXfFptChsyve 2aoXKgln5dE8okpAHk9p3Qplo92pq7HkGA6t2kZREK1owP/pchHI9tRqDttFHvlhC2YkCPVI s6bZF6rAMMFo3TR7x7XEZvYMdIi73/jKfX+AoSLlJT8Nfrk+vV1hKokx8sfTu3DvdxVOAZ/t KvTX//3z+vZ+k8kr7+rc8TWUVi0f+Ko3FmfVBVP58vvL+9OXm+GoNGme7jCowB04ZqhwhPBj gz4Auc7Puzvr+KrAfvFjFYKol3CJL7qb6cnKCtwi81UNzKf43sHYpdGtHIDr0FSYr4mxmUhD 1LXG/Ew3wAfUS1V1veoWX3YTLJHLFJZ2LNdfPz99VZzJa+upHKxFkzFM2RBB6Rg/NagNAiKN Yg/bC0T5w9GL1a96IpeGqJrlnPElr9p7jM4JlZmHBLo68836SKgcCoZr6gtPNewpw/IF9+id Ht1rAT9VYEXzaTXnT03geVFelFjudzx3PZCzgkFsPezWYGGhWY9WmvZpEvpehmHtiXioBPfH SH2ppwHhxglc0DRdVgRqrDsNSUL1KZABqQfkBWLVxnN0L2tTXhZqS24yoe1mXM7n3JE3YOv9 C38iDx3EEnJVW4D4na7JhfkNMnnISjHoA0+dx48CgrbhPvUiJ1A4kNAhajAxRocSR3w/xAuC hYPgAj60XNVneMuHGLV+Vxj2WtBiFTh0WuhOBTqSKEQH77HwwgBtNT+WqWEsFuBc9zJuRz1g 8GNhxFQSyvAJU2/H9ZqvgUbdHvsw3pirLhf2qcqtSrEg0G8KZa4cGjS7CWmB++3py+vvsDmB czQrJolM2h17jgZ2niPg9NCpc0nFw8jituSwM6kYT7FnPYDRUJO82ydagE6VetHOuxoiQ064 kwnBepcpMKEivp+flz1+RYzZwSPq7FSpk15rSGcEHQGwxuFyDkIfvcIfdVUae/qnDZV+yRqG H6Y1Lt531tgpP2i10I1UcY8EU+meyXUOsb9pYUOZ8XFGSSIUFswazORBsuWQl6iL/gQc6HDx fAQozmiLBHk8/tkoTbU9aymdHwaPWLOOXeI5Hg6rLA4jjoll15GOYTcdE0O7P/Kl8DLObQMU FykBKvRh4LoQZocwcey5xp/5SDduU0/dhnS6dcU1wV0xHDdRgCDlKfA9pPJFLTysXAZHA46R 4TfF4skeuQ6MXcXO8qmK27ZmmUt+R4QG7dRfUqpIiH21mhnaB1ZVaNJDHKMf+tWmqOvhLKQq DkJ0WlWFH+OfKuaxxTV+/Dp74mhoFUSOb/rzxDg3vu+z7SpTPzQBOZ9xG4m5S485u3tYEcJj 6Ye6DgeIGOSX/FDuKtxeamEqHfdWjDJZgx6zSoT0eVAEFwgbWOw7e0E00Xl11OqQMV8/kimn v3/BCvyPJ20r+ufaRlRREKi5EUmqYyMaQXOzwHi0+wUNETfkMrrs62/vIh7F8/W3l2/X55sf T88vr3idxRCue9Ypl6hAu82K/6fsypobx5H0+/4KPe30xG5Hizc1G/MAkZTEFq8iKJmuF4bb pe52rI8K2zXbtb9+kQBJ4UjQtS8OOb8kzkTiSmQeW8U30HgSxvbP4y4ZPwXmJ2zTaYD1kFAs OaRQtbzg9y9PT2ANwbfttjMqmJF9x2jg7qxv65Pbps0oZbvTtoQgLOZhkKudFV/pyEEYp5dM iTb6gRVH0lKc9OT6gZdIbz51Qj+ke7vYLgi0NtXDYKE5qeqhTLszRm/xU7yukQvtF9fzTmEv TU2RTcguG5IkX1hoi2cv2KfiPUxCc7e1r6xkts7obt33FpR6PiO0Ffp6iMiDMRYkwd81QkPr TYCUEw6MkZYSB1Bl8gsFI09Y242xcWRHe9AlMFKYYlMrwY+Sr4mpnZWXZgfmrE4mES7BEl3P yWmjx2nqsZl0knb3fP/w+Hj3+h0xfReH811HuEN68Qiy5a7Hx4F89+395ee3y+Pl/p0po9++ r/5GGEUQzJT/Jp+zierAvZRqWyX2B99ArX253L+At+n/XH19fWG67Q3Cs0AUlaeHv7RHZ5Om ICfc/HbEUxL5HqKmGbCJfWwxMOPOZhOZqikjoe8ERtdxumvssEraeMq96jgeqOetjQ1OQgNP dmd1pRaeS4wci7PnrkmeuJ4xjZxY6T3fOP6/KeMoMjIAqrcxxK5xI1o2RgPQurodtt1uENj1 VekPdaAI45HSmVGfESghYRAr0QEU9uvthzUJkp7h5RqyR+QAboB65QhRL7RXPPax7acALJdx gmfbxY7RzIwYhGZ6jBxih2ACPdK15qJslDa21mQVQA0j5uaNHMeQR0E2hR3Mpdj4sdGhuubc 3QSOj0zpjBwYGXewO1sbgtrduLHsJGmiboQDYJMaYlQHkYFz03ua3zxJpEBS7xRBNlUOb6to Ya7r3SD2ldANmrxKGV6eF7NB91USHhuDmct4ZLSzIKPcnu/h8uxtsOPEKx6opoUKYL28nrg2 XrzBziJG/BjHiDgeaDx58lFadm5FqWUfnpgG+tfl6fL8voLYg4aaODVp6K89h5iVEJCuKZQs zeSv09gvgoWtgL++MhUIRsFTCcxODqPAPeAz+HJiYnuQtqv3b89sYtbqCOsZcCAlOv0aPV3j F8uCh7f7C5u3ny8vEEX08vhVSk+fNw808lA3L6MKCtxog4w73J56Op0cyrzJ09GvzLR+sZdK FOvu6fJ6x1J7ZpOMbQOXJJQt6wpdkg55EBgqIy9ZcxlKh1MNtQ3UwJjAgRqhKWyMEcmonrNB GorRLZbvgqE+r12CHmNMuBv6RnZADYxqADVGeU3NwqgRlm4Q+sYRcn0GT5Jm5YAbfQshwciJ PNA32JnPBEeu7KlppkauoUMYNfTRkkXLJYvQysfo7F2fN+HC2hJgcypk1Eh1oTjRHS+22MOO cxoNQ0t8mHFQdptybTG9lDg87Cr7ijuYvmdAg9sWzni3XuMfdo6zmON57Ri9ysnYgh4AB3W0 PSqZdu2tm8Qz2r2q62rtTJCealDWhf3Cpk1JUpqr/vbXwK+MotPgGBJktuF0u0ZlsJ8le3Mh HhyDLdnpZKbxjEOlLs6OypIa151crRaMhnmWmSbuIEafOE/zduSZq4z0ZhOZihWooaFCGTVe R8M5KeXyKoXipdo93r39ab0/ShsnDJBlDTxFQq3GZzj0QzljNRsx5Ta5OUdO06uOqRvryRhK tOu3t/eXp4f/vcChJJ+TjY0454dovo387l7GYJsau7Iy0dBYmXoMUHncZqQrP9DQ0E0su6tW wIwEUWj7koOWL8vOVZ/Ba1hoqQnHPCumuTzVUAdVXjLTp85RbrhkrOeWGDYsUMzPVcy3YmVf sA8DuoRGptmiQBPfp/Ha1hiwIJR9F5pd7lgqs0vWijY2MHcBsxRnzNHyZeZrl7Fqsmz5hT6q lKsbxy2FS1lLY3UnslmvLZWiuesEFkHNu43jWQS1ZfoRMbidO89bO+3uI4krndRhDedbmobj W1Yx5RkiplBkTfN24QeYu9eX53f2ydsU75g/X3x7Z3vfu9cvq5/e7t7Zsvvh/fL31e8S61gM OHqk3XYdb6TF5EhUXaUK4nm9Wf+FEPUrY0YMHWet+EC90rEhyq0V2WDotQtj1usp9YSfUqx+ 9zxC83+s3i+vbEP1/voAd0CWmqZtf1RTnxRj4qapVoNcHVu8LFUc+5GLEefiMdLP1NrsSmMk vevjHgtnVH6bwjPrPMe42v1csJ7ysPOlK6p3b3BwlPPNqSddOejmJAhrTBBcU2R4n2MiszZa PWb7cbMr1tqjmokZd/EP6DmjTr/RkxqHdeoYJReQaHmzACyjXucn5jgQnxslFWTb3bnoT715 mJTpEt9RNglpfGwIGFWBkLfECbFWjBxZHLvVTz8yOmgTx5FePqD1Ru1dw3hEEA3R5HKGbkTG 8aiNuoLtPmMHq5KvlaLqO1Mu2fAItOEJ4u8FWldPFjdbnJwY5AjIKLUxqBtT6EQNtJHFjSK0 gmUJqnS9MNKbO3XZzKQ/NwCq7+ivELghgbfGiEaHjWQ4cLJ0GleMWlWEkQGYjdepLHnJqJ+t MgfDN9aFXTSXi4qBrhCFJoqmTElHWZ7Vy+v7nyvCNkUP93fPvxxfXi93z6vuOgZ+SfiskXZn a8mYfLlrNUIhkOs20F0Ga6jyqI/fCydsm6LrxWKfdp6nW0eN1AClhkQnu4oR4Dze1ppiJqc4 cF2MNiiX0RL97BdIws6sVnKa/rhe2ehdyQZJjKszd02VLNSZ9N//X/l2CfiRwmZr35tjoE+2 fFKCq5fnx+/jiuuXpijUVJXjx+uMAhZ1a117ShDftokNZ5ZMjz+mnejqd7Zt5wsHY73ibfrb X3UhLKrtAQ21NoOaBDBao3cCp2mtA2/9fV38OFH/WhC1wQjbU88o7J7G+8JaWkD1GZB0W7bs 0zUWUwBhGBhLyrxnG+bAZoPENw2uIWzc7Ewr/aFuT9TTBhmhSd25hv3ZISuySrFQEIs7YSUD XnRff7+7v6x+yqpg7brO3+X3PshxzKS91xs8PoKYi10VUzcKxn6Ap9+9vDy+rd7huupfl8eX r6vny/9Yl8ensrwddsiLNdPGgCe+f737+ufD/Zv0Um4uMdljj5TOezKQVr7gFgT+UGnfnPgj pespDwPpTd4lh6ytMauAtFVe3Kdg7NEwHdbzAI2avzyVjQdeLLHgYVeYZsUODDMkkWDYsaTQ /40yzc7fsPxL2oFxfl3U+9uhzXZUL+OOv8yb/VNbCwmW2QPbKKazoZStuI16dwu0fVYO9AA2 NVhhz6X6P2VtPE/dcLszXsKtmGbSjsekr8AxXXJgy6BQTQ3oNC8cOXbKRK/6hp84beJ+AQyU e8GlAol5vy2Vt2DTlZtEVpu2JWm20PKkTJk0WuGqPp0zYsfzjWOxYoam36Mx6zh0LA1hOZc3 +53F4Bm6uSR4jDoAT2mhJ0eoxeCTYeWe7F2bfTDDP/WFFdvWyQE7WQesIVVWXGfct6+Pd99X zd3z5VHpLQ2RU9i2eSoHv5tTvSJK4lcNvH19+PLHRZNbYbCe9+xHHykmoQqaKvHt7WnLH2dd Rc75WW/2kYw7X5f4krxls9DwKStRO3Pe4Y578lS3HFxOtnXPz70t3xXZniS3+ldduiBbreNa rKGFsNhFPLdjlJzJ3qbIsl68Ywc/F0zxUqzH6zaHN7X8aSq42j5qXEUOD+qrlBucituF17un y+q3b7//zrRGql8y7NjUW6YQX1FunN0WnWzRpHgm27v7/358+OPPd7ZMLZJ0elqOTI0MFW9T R58XSFuAq4Yi3x86hVEu35Xj2KVugF04XVlmn20GInzWGGTdu9UVubosQorCg7culoQ7GblR HPdfQUrYrE0sSadNHKOXPRqPvAi/QqbHTakNkEDmUqLCQdlH7Rt68ntVDdqgSBMHAVogwwfy 9Ztz4K6jAltaXZm2aejI7x6kurRJn1SVrNU+ENspjUNa5vJnxtJvYqT1qZID1MC/AzwgV+25 VTpELmCCnsthdJVUqpRHdGhVUpOUBmHIitQk5lmykQ08gJ6WJKv2bNib6dDs03XISfSW3JR5 mqtEJtHCmr3e7WDFpqK/ssY3KUNeNTxKw1nFWIPAslDufCCXec82kjX6mn2qIkP1z0byAP5k 8gr3pjnx8ea1JG9zFcCLxhbuCVtr0396rprq5JSkLtKBWLwA89zbOhnQZ5SAnsE1LAUJyatO a0njxchMnD6zZpp0xXAmRZ4aK3BVQga63552hnScwP69RYQGtlAW7rGHtC9AnobszGY0HNNq rFufc6KZKSm0mCK8KdkmgqVoqWzZNeSsl4H7ADo5YaCa/3D+5uTjEeK4ROU6P0mdOLZE/+Ml hiPuBTgP/MAShwtwmh8WZIz1ct5bApnPMHdaVdqZTnFsCw8/wu4y7C3AN64d+9x5nmUlBvi2 iyN8EcclnaydtSVGJsBlbvO9zRVSf7vPLEGyK+7X3Y3tvcLgsF8oWtfv7FmnpC3IQovueSQ9 K1yQ28XPRfK4ndWcvB0Wydvxsrb46hL63I5lyaG2BZOrwM15mu8tsVpm2OLe+sqQ/vphCvZu m5Kwc7A5zFkf7XIx4gsJVNTxInvnCXwhA+psPPuIAdjy0BPgXRnb4hcy9JBSuyYB0K5C2ILC iRz7SOf4glBxH/dxb2+XicFehGPd7h13oQxFXdiFs+hDP/Qz+1KCralo19aWgMtiKUMsDxQB rko3sCurJukPliiAsDrLm45tgO14mXn2ejN0Y8+Zo4H9a5qFdmkGNyzJOd8utFvXspJX9nZh O+rYXVClI/7BFMadS9fUrh3OvevaK3lb7rAoN4f0Z27brgQR42OBCIFEd9LzV/+mfcIW0/xF 5kDzz9k/3bUfq8me6HZBQMokx17qim5ItPUNy2SKaLe0G6iTeZFvItNJr4lA7At9FcTp1jUY R8sUvkQ/ZFDymc1cketsyn4Te0HE4yZ9kBz7pu2C0A84sy1llqn314IMC642q+rctlEgXSni g6iNsU1KHi4td+lwc8hpJxzlact2mu8rOOMGNkPG6EsyvkmDu7Ld6+Xydn/3eFklzWm2fBpv X66s4zNl5JN/SE8rxsrtaMFWkS0iIoBQkuNA+QmRCZ7WiW2Ze6yxeXp0SQY4R5Pm+sZjhDJR GjRhtk/b5fj5opIEVPVDrj5BfdRMLHnZ82qelKeDi10lJwHicMhD1wH//Egr5uUeJfIPVQ+h OooHkpS5GtIyLQPHiSd95zVy8A5YyEfgWk4oZ8NEng28vObqsK0gzCpZbv0x0o64SSrY/hCL s6ky28a2QHkI1R0cnabFLZvkq/3ANvULMxJ8WnZHtrtIzhQNSjwy0Xo3FxLLH3Bt2kA4RmWJ IGJD37T1NkOERHCwrMH3CuYhVWasav74etFNgszPljJ50g1kmw/JIUuOy601F3a5qngdRC9J 7WjlsU0rwLElt11L8uKHa7hta5LeZAX6hdC8Xflw//rCn4S/vjzDmR8jsYUURIMTryvlM+5J Cfz4V3pNx9CeQiUYhR5R/k4c7glK0nW2yNDqJ3y8LnRN3+2aPdHz/dwPXYrd183Dy2UTI/y+ Og7lQoaGtJ5XBptoEFwLM3dKTsOpywtE6gFjGyDXjqh+YRU0ko2kVaS3IuECMuaFLHTICd4D f1DJyHFi6+cMGw6YG2+DC6/w0XecGKX7+oHwSA8CHy3N0cc98skM6mPyKxJ4MWafKzEEaGmK JAhlK5sJ2KZuHKoRF2aoG6gtmOu0mB0DChoSaHJSLygWNk1XnqWWERy+WQ0BBDYgxADfLXxE 7jkQIEI6Arh4CBDtNAHZd4QzT7Rcdd/Fa+67IVpx342Ms9YZcazBjmS2vo8tL3QlLs+RDaxk wHcs+Xs+FiDkygCeLbA0e3ct3m4aifKtzFL7pUp0wokKt1HD5EdFwzIaOViLM7rrI/KR0dhz EEkDuouMSUHHxWkPXgORPPIKPPwcvbUXYq1QEraXW1uCpSlMbMO3sLsVPMEa1V8cQ31JKBwb NzLLL/KOUH0zYR9I3MxG0xtbBhtEeESxMYCW8cYJh5skNRwQYjyjC3qsCmzH74Sx7S5j4oji jZnDCNhmQA5vbAFDZS4lQJcGLKTurUNbdDOZi1WPoMlzZCH9wFm79uPAmcn964NCMOFHR1Nb sGkMGTFtx9RTjAsLnGVgIxboeFpw9oHTY2QqEfQxb6O+bQehzBm4VNsuctCCMPJCuk7wQbp0 3xXqK8QZyfclSWljR3CNNaNttlfiulwZ4LnqQNhfLVCHxjGdAhhouxtX6x8teKcTDzMNWroe GkxV5gjXSF+OgE3CGewHi0qR7dwVv8gy3bwUFUg+UGK7zwaOjlA3CJDSciC0AFGIzGociBCB YIAa1lIGIgftKw6h78ElDrbGxcoBnrlUBxgztCObOFpaOUi+r5CUr6CtF2cWiz9gk8/tsTrI MD5crix4Awo4TXoHdRgx81GPuG6UoWlQsYRb/Jyx4LsU7irMw1xeTRw3Zay8RpHpWPtzOpoX IOirXYkhctDFJCCoy3uZAdPlnI6sUICOr1sBQYN8Kwzo0oY7WFveAQBLvLTBZQyK7yuVbpNo iNK1tl+izSwfdPQGWzhxOqJjgB7hJd1EyNQN9DhAS08JOHxaKNtnfoKzCZUXKPKSLwqQxRYP JYgIhQgxiNJDrAUqcmJrfrToAAWLY7cSdiB4qrGL7iUFtNRZXUNCtuIhSHMUDViAsjaFE962 xtIXLOeRA71uU8+ktCTEDJ7YInADjxbdV1z85Slm3wpknRUu7Szs3Kdtjp0wM+rQ5POzhCmN 7Qtja15f3l/u4Q2V7vUS0jtutXglZX2iysOWDxLT2ZRwTbDUtVQGTgO1yiivGMy0nt8vj6uc Hqwp8kNfxmBPF09ivmiVs5SapD4k+VDkXce6PqvSnFRqkxkBtbjv7CkggdJ9RcZvsLGDb+5V vmjyYWsGumA/KyMYu4STNmG1JnQ4aOFn1DJpxmbCa3hVn8BFbZXdTJEFDZlUXZJBTyMRl4Rn 6h05Fd3QZC3NKXazBFw7llVe5R0Eq2/zzKitakWJDjTeLZ2tGRkC1yDpKemKnBphdwBOc0q2 0J/9eM90OGFu+cY+o7zT9hkEkt6afc3jxJ1ow4SDNUFBbv/pqkOqUkbmy9v7Krm+ckuxcZmE Uc92T3p/Dj3IIk5Nt/tE3pjMANLtEx1uqTN8DX5lG90DqylnaEE4ta3rDtpz6Iym53jXgbTx h1SWfLNrsXXqjhZ4QSzlrPuT66wPjVnWnDaOE/YmsGMCAnetBlCjda7nAugFrpGiKc1xGhms Mk6LmG2ElzjaGB57biKdSZ4zEm5ZYETxAjp3pwy2MOhEJN5trJLHu7c3fP4giVEpboCMmkgD epNqHdSVs9P3qu6yf6xE5Jq6hccvXy5f4fnlCqwVEpqvfvv2vtoWR9BUA01XT3ffJ5uGu8e3 l9Vvl9Xz5fLl8uW/WLYXJaXD5fErv2d/gqCCD8+/v0xfQkXzp7s/Hp7/sIVJK9MkttjcMjhv uG2+tYuStKK2CEUl74i0TfRWFEBtVaIc3xOIS4B+mp6YUmvrwuzY5vHunTXE02r/+O2yKu6+ X15nlzi800vCGunLRfLKxbs1r4e6KjQf++lN4pkUPpEhZKiPoe0BEBWxtiDn+dEaCX26onpQ yjkhY5yKspHGnIluEluYu+QArjszLfTaRGXbS6NHZ2yhV2eekhrjasZGSyxLEqDWIj3YniA6 WLFGfl4qo3kRPtFVnNOWlL2nQL6gV3BlMkfXVXWgMK5nFKolibEtN87IpLuWkyCStwmsDHCw PXqaPxsJ3WbFMceeSMi1OHjy3YqE3BzyLjtkxBggIw7H8kzdJlmR6eYHSDYNm8CMmGITOAaV KG2h9Ea+rGyyPVrWXZfmrBFrFDzntG5RJG/IJ0uZUEs5uSxM6MyFlwYOXY4XN3Zc1YOLCgYe tgWXhYq0Za6v+qc63eD008mS4TG7pQ2phia1BX1UGW3JFKhlnMxRb8HAxYw7OeLl/7H2ZMuN 47r+ih9nqu7csSXLy6M222priyg5Tr+oMo4mcXVi5zpOnc75+guQWkgKSnpOnZfuGIC4EwRI LG5eFgYZdEimAiGdnugoYfO5MR7ELaYDuH0xOJWxvYt6+pVApaFhjs2BviR5MNOixfaJbly7 0FPk1RjgWKixkUiWuulibw3UzOzVl0yJBX6W2bdBBpuXDWs0DfVd5CS0ZaJEldMOIco+d/zs G53LXGY8twMDLjLbDA14FAex/wUbwhLcwSL2zI+BC31Rxi3o604S9w6bZrBYMSHd+uXZzQ2y g0XqzRer8dyk12njNdeeXKoeTB5hfhTMepwGgMZQak/bK/L+otwxf62XEvrrJE9uB2y4OMWg CtCwfPdu7s56e8i94972Qwe/190JyVoSngGg7NI+T7xr6OQMijZoP1TiLY4uoxXodDbLMQ7J uj/JAejVzm49xClDTRfLMzt2/V3gZHauH0JBcmtnWaCD1bglQqNkIOBwzWgV7PMi04SBgKGP 8Erj+3dAp82j/50P1F5bfagaw/+GNdlrFzQbFrj4h2mNTRoznalGC3wQMLcojLEvYgEMipZ2 wuBIkRd0+vTxdjzcPwstgF7R6UaJhRDXScj2rh9QsYS4WoK6wo64x0IB0dQ9hqQLxIH2KGWT Kk8tlBJJtgeIYGbDAZvePulgbmxBhT0tPeDv6rVPja0V0DIuotIpViv0SpUcgItP5NtunqrL 8fWpusDIdBdH6jQ1lxZCwpebkfVhzaVBT3Xf2waZ4oOrlbt+QQgz9RtkLLrHAx0P39xokyzO LCLPssyZRiIRwGFjGPNeuTUY3VIGy+Y0i0H9vVwnWzpEDd/Ea2M8tKdEIChxI6QuZHLCFM4V OOgqk7Ag19jLqr5UUUCYWF5jFs3K6ZGS0MTRudNKc5sWsPr2hriBhj9X/bth7O36/uGxuo5e LxWm6zi/VQ8Yxevv4+P75V7Lf4dlfffVxxk+/Xo6K3UO8s3w5JWxO3R0iS246vGhVRG7KNsM 72xyFLkLesuAFPKhYfOERxSf5k+6QD/rCJznrFO9OoR1nv5aYRwp2v9JlSIz9ECtwMxkTiut 7K/nuiknv0vV9G0cUOZuStUqkIXL5BUJv0rXXWsQ3a5ffLrxTMb0HEd63SkD3rSgOJwgYJjJ cyLCn7TLO/94rf5wRTzl1+fqZ3X506ukXyP2r+P18CS9SSllRsW+TAMTj/WxZRr6gP7T0vVm 2c/X6nK6v1aj6PxQUcb0ohkY7y3M9ateqikDJSrrA06qOuKcdrIAgtVPcfh60GEjOVoszxtY 2KoDClD0BBgpEaHIRfjl6wmWoiWVRBDzNuozSAvUfW4IClxxxJqRigjzVURUiOzY26gZNng3 g1VUMvpWH/HrJPRW+FA53K4MNKtN6dIyDJK4znwgCgNid4ENhcBfwxSFY5KaFSILtnHV/hbQ 0WAG89/rLLqp5v4W18dAae6NvlRA4L3pDVrCNoFjD/hIIUUkBz7pJmHvx3Ju+MiPGOil2z5E Vfmi6uV8+WDX4+EHta3aj4oY7wCgm6yI+vKbXMrw4u2XypdINDC9DdG3KHCzJC7NBe3x3BJm IJJRg9biuznqhgXfhPH1s4Pwt1AeaUuenA5aruBfystWIomKEG8FQlkR42gnQ70qRj11c4v6 SrzuQi0CBTUJ/MMmZhU5BJzCTqkocRzFQ36NtaZwoNHrowgP9klJM9njggPR5Eb1P+Hg1LWX Fnn1xtF1YCul9NRcTqcE0NKrDFNLySdSj72/S8rIDkINwVti7ekWWvue2UGfakZen3K0Hh5N fHMb9WrL/DUG+Uyoa2CxODyQ4Psz0rh/Tg2SVYm3e9eeWeN579s8dK0lbQgppg4juC3nxNKw fuqz7McrY+J0T5ndcuWPjn89H08/fpuIpNvZ2uF4qPb9hJE62Wt1wHjKKAXWa3z0G9r05Jsg Xke/d4ebGApU+CO9BeHeTeXrkAaayXf4HIgerhooDtz5wukvgjyA/ha1MUuPtYksQZg8Mj9f QERR92g7Dvnl+PionNGySYXOXRpLCy2MmYJLgElskrzf3Bof5ZQ4rZBsfJA+HO25RaFoo8EN r/6G1B0IgaoQ2aBy7IKcugpT6Ii936Aa+5rOoOT4esUI7W+jqxjkblHF1fXvI0pytXw++g3n 4np/AfFdX1HtmGd2zAIRYmugpzbMCq1pK3SpHQe0aKGQgWauBR+mC0PX1XhgULjq2OHwiYyx wAlCGOtmmGCH3f94f8WheDs/V6O316o6PCl+uDRF1+4A/o1B/IippeV7tlsC+0KzJeZmhXSI clTPRCzLXbwCUAGRO5nOFpNFjWmrRhw/O4mavciuzba6sjpYP/KbhNv1rstEaNjI7sf+xAhv IuyHUo0IlMLfNe049kO1EZqvOkoYGT5tr71Iejev7fYANlOuNmt4YudDdztpuNfvfWpM7cn8 /S6+iVJQfZQKeWjNDVZYRusopxBSN26xCleLylhDlYGtCWnpdMOK0lNNcNiqTLXWt+PvPh+r 01WRdGx2F4MMPNRjgGoRuNsZA22+sw0FsFOsJAO+pjVYOl6KSkraLYdKCp74WKkDfpdRsvPL OAGJ9U5baohtgoMPrF4kAWacsl6xHApNYLkfDSAbq6Ym8rDaOWnwiv3wQ0ShBhEt0AOHdIBH TOplOzQyCLIbaWAA4WEE8RahlGYPOA8jDs5iN2G0BTuvD/QXwqZBoQEuSl7a4udZocrqCIxW M9LGGnGbXVOd/BVu8yamIvEhotVBFBCUi+iTceel9J7ecTsU/bvaDPVwOb+d/76ONh+v1eWP 3ejxvQKFqnfvsrlL/UwK0Sh+txJFW1cNdzCKkh7jvM3G+3mdTRXrzL8TDx4qoPSZbKme27Ah JXkMGI7vKdcSAjIYHqNFC0GA76/gu19uHREAapgMpFmZcqyRRgFz+1Eza6STyEFma6DKbmpg amd6XJEaEzCbWkE6Ga73XyLD+FW/Qsnv6b8mWxiWVTKKs9YEW/F/72gOF5OlQS9yQAJ5bx0H oFC9XWuDQ1Vctg+H6rm6nF+qa6PoNhH6VYygPt0/nx950oo6OwtIL1Bc79vP6OSSGvRfxz8e jpfqcOVpt+UyG37q5XPFGbwGtG46as1flSvOufvX+wOQnQ7VYJfa2uYTOfkn/J6rCUy/LqwO g4+taZPbsI/T9al6O2rR9gdohM1qdf3X+fKD9/Tj39Xlf0bBy2v1wCt2yaZbyzqCdl3+L5ZQ r48rrBf4sro8foz4WsBVFLhyBf58YU3lweGA3tQMFsVryioQg1F9/XJ1fUXZel8Qy16ShgRr FPkee1vGPj1czscHVR7CnB0k026oJaUj90uQOufGlDoo16zEiDZOoqqURRyA8MGApVE3Z3hM 8aedGPQl5YjlKNo2hqO0yN8cxhMS9AoZimGxZfMxmQ+xOXU0nUgBl3bqtDEh2iIbEhyELKFe aBoKrhP3y1biCnTAJHVEYO9eTemgLUtDkdm3n+IbO49PGiuyXni1FYOGVDXtBqr4s7aNlcP/ N0BGDnL9rKFD+cWqyAZ0//ajulK25s0mWNts6+flKgNt+zbJtuQq14ppKlwFfuhxiwRfSa6x TV1M70QO6E24pl8nbwMQG4jhZWkUgKbEAnMm+1TvF7PW16Hs1NJuz4I+WN5GlIJku3628VYq NWj3nxrNYZzFdOAJQ5gXraOCar/NcHHaaZ5IT6sc2NSnKDKu59h0CzweESxyguQTfOYMZMAR HyeLIeeCVfEtyEFzFC0l+tEQ5GiyLK+6FAYmcfkikq37NqkwIVYgVJcDJ0LxhZp6P2ZJxjAC qayz4VXlNrU9TedXwBi73O7fhag0XPJd2S7e3wT+UA36E5+KrF9k6reL7iFUIRrKAaNSbZJ8 69/BYMrp7Or4cnjfw1KjFFk6tIuLFjsQ5lhQ4S0vD2pPNKS+AIlz2LZGudOTXQj0zslpC7zU Fdo/f/wgHa/tiBXAbPRt0MBvJspLXvP65uRlttoGIW1b0FChNwW9LXFQ3SilN21qxzYPAjy8 5MV9wHymL7QkBe6Zdb3pxslwxZsTjBiQxHlg55STQxTuCR+yPCncDXMz34/LJrWHOj8ppREL XCZrSPVTRQTHA0Bin9tlS66t7LWqHkaMRwIc5dXh6XQG2fljdGzTKA06vbLUhzOOwS52cxE6 EzYQ/c7/T+vSqypinodklfk3aBQEsgLFJAStu8k9fOuG0zODZdofuzRyh12nGpK8f/dJ0MD/ Ppqq331VVgaCI8gqg41OC3RNDVK331zmFoPGAhJFvYaIGrC/yBcUcah+6i/TIKWWpbsBccxv S1UYmsAlbHi3tBQp2iH65Me5E1FGd3XwO0nFr6PhKQJSAwxTAphmSZ5o4K3jcTfo9nmlw98G oZsoVTaQ+lRQOt/iOP+kNmFL0S4OSeqGs9eOkz3pmymezZD3Y0YY+mVdkJAu2azg+0+ZMw1l lk6R57JVQofhgnGZpFB+QFGsU78PhKHul7mxdz7sHsnSAX6g7yTI5dsi7RNiTHHQd6TyxdOf VkgL4yEopguLxLHAUpydNJSlRCFRkVPqelIicT3Xn49nAwW4PJFp6ZIbQqrHiFImh59CYH4b zsay44r0gfZwvbllaRCHiepgIbjz8/nwY8TO75dD1TerhrL8HfCYhSHn2waoE3ottLvKoMqS FqIdhE5CCbkBtLyQxC2hfKDCfzyMOHKU3j9W/AFRcpfsFIwvSNV6iB2K4rn4mNpB9e1rj6C+ fng5X6vXy/lAWX1kfpTkPuZDIs844mNR6OvL2yNZXhqx5s6aLlH5st17qMij9Nw+M57fTw+3 x0vVf0BraUvX9jDNkbSFWxQ/RCgEvkxR8CYoP88DYNfuOqIpMDa/sY+3a/UySk4j9+n4+js+ ah6Of8OUetq14wuc/gDGiOTy8DT3KQRapPK7nO8fDueXoQ9JvLg226d/dhHPb86X4GaokK9I xTv4/0b7oQJ6OI70T3wxh8drJbDO+/EZH87bQSKK+vWP+Fc37/fP0P3B8SHx3Sy7wqGRf7E/ Ph9PP3sFNYq3eO/cuQW5fKmP24fvX1oonQSDej1Kf+2Dovg5Wp+B8HSW+VyNAhFn14TOSWLP j+xY0ZdkMmAJPFZ1TGZ7VCjxlGRwbg0VhWYuLLW/LgiEy2Dn6/3pGZZ2XdfTkPl7lOibAvyf 18P51MRO6BUjiEsbJGM15V2NWDEbTtRxD65eVtXAVkU0p0vlNFTwIIeXt7TCVdPBMT6ZWnMq vl9HYZqWRdQBmPl8tqTM4joK1ZCqhqd5bCn3+DU8yxfLuWkTdbHIssgw2TW+8T7qFQkIty/R yki0/NayxUZwzGTUi3Eg1wA/asceCla6DglWTSAUuG5nIWHRLjKJ0c5Uq2y7ClacSgXXNjIo bhMtFH+uGPlNj5TXynCHtiSGTMKaAELqlwDuSuzUJaVxvRsQ+jGsESu8fWjKcUprgKqYcKAc +L0GqFROZE8WyqQDZEraEoKWBItVvz+ToXqQOs8e8jrybHNCJ86C+c+8MRUEkmPkeGrbPfOW 2k+9Cdu9+207GZOhoyPXNHTTdHs+tayBELWIVcLEAWAxlc1PAbC0rIlmLFNDdYAk+kZ7F8Zc YS4AmhkWGco03y7MifKqvl04tpoI/T94Lm2XyXy8nGTK8poby4nyezae6b/LQOhhdboUBb1c KqaVtheU9j7AM4DSUNwJaC8TxHaFeGFsqJDNXgmdG+auMZ3rAFkz4wCZCyPTN1VvYFTnZhMq wHPkpuZUDdrHn+rQaBxtnGfjge5Eflx+nywWauuj1JgZyxrWlhjbxXxB8ndumrWzhTtVJOu4 HMPfIwKlhg6+02rpMICgVljOMePFRCqOwxjsJEuFRXAq7tW+1cLYvqn2n77Cry7n0xVEzQfq EV9C1qL76zNIasoS3kTutM483UrwLZUQG5+qF+5oy6rT21mVJe08tIHNb+qbfvoWl9P435PP iJzIn5FhT12XLeS1G9g3WtJj1zPHDRfpXsc4dCB8NjQjyDDTOVunSmz9lMk/d98XSyUJU28k +FBsjg81gD9bi4RZ8mzQBPK5F7H2qUTwZKGWsbT5rl9oH6kcpLlWII2rR602bxALDdbcvVg+ 2hN+y5Cs8YzOpggoc+AQA9R0SsU1AIS1NNCCmvkyHwSomSmA2WKm/l7OtOtFtKyzZUbIpkpc 5WhmmKahMDVrIjM5N53O1TTssG2hSMvS02K29h6fDFprwPPw/vLyUWtTyoU8zobQdbh3MH0J rxcgzOkv1f+9V6fDR2tj8m/0BPA89mcaho2uLq6D+N3M/fV8+dM7vl0vx7/e0aZGXkyf0omw WU/3b9UfIZBVD6PwfH4d/Qb1/D76u23Hm9QOuex/+mXz3Rc9VNbs48fl/HY4v1YwdA2PahnL eiLLIeK3Lvqs9jYz4CilZZm0MMey6lED9ELqzbW+y5LShDObfOvJ16A4KOLHcCcEe6nun69P EvNtoJfrKBOOl6fjVemzvfKnUzX2A6pkYzr4SY1SnE3J4iWk3CLRnveX48Px+tGfADsytLDA 3iYfEGg3Hsoz1P0kYIyxLNBucmYYE/23yhA2eSGTsGAuBEfpt6FMRa8X9ZMbbGj0uXmp7t/e L9VLBafqO4yKwhedKJgMpo1Y7RO2mMs5BhqI2uJttJdzQgXxrgzcaGrM5E9laG8NAg6W56xe nvTzk1inIYtmHtvTTGe4y8JV5/j4dCXmun64VwXYb17JTFJQtL1iPxnLYaHs0Byrb8kAwfDv 1Nepx5bmWKVG2HI2cAixuWmQDXE2k7m8w/G3fK/iRvDhYqICVKc/gACINhuNzNnMoupdp4ad jlVfNQGDLo/HZGa15lxnobEcK2m4FIyhpP/isIlBSbDfmI25i7tysjQbW4Ya970uetipMc8s OUlPuINpnLpM40HAloZ4EKKUVAdxYk/oBBVJmsO0Kw1MoQ/GGKHkDLBgMjHpyUHU1KJR+dY0 Sds52D7FLmCGzE0akLqjc5eZ08lUA6ixSZrRzWGSrBk1vByzUNQvBM3nlP4DmKllKpEDrcnC kMwId24cTpWUJwJiKnx650fhDMaUMuLnKNmcaxfOtMuR7zBNMCe04KQyEGGyf/94qq5CCydY y3axnMuK9na8XMqKQX25EtnrmATqnBJgwJQGfNZNy5gqnal5Ji9o6GxvrZ0i11pMzf7GrBFa FowamUWw1MZDcN0ilxwsMYxdOAhFDlPg9bl2eD6eegMuHQIEnhM0XpqjP9BK9/QAku+p0iXb TcadKJqru8GjiNugZEWaU5QSXY4GAGgkSt86sju2Ysr1Yd0NurH1MXYCQYd7pd6fHt+f4e/X 89uRm5wTA/Ir5Ipc+nq+wsF5lE30O/3FIDevx2Ab6fcs1pR0/0Z9RTkBEKDs/DwNddFuoG1k u2G8rrIrbpQuJ2NaelU/ETrDpXpD4YHYzE46no3lTMROlBqLsf5b3SleuAGmI7ExD/R1RSZM 1ZEL3HSiC73dsKbhZDJ4fZmGwBwkdhMxayZzG/FbbR/C5DQqNc/QUpzLUO2osKZyKLdNaoxn Csv6ntogdMxIhtob7E5OO6EVPbmcdWQ9beefxxeUgnGhPxzfhGdEbxK5SKEe+oGHVnVB7pc7 9fbPmRgDCS/TIKbsq7IVumkoyaeylZLyZb9U5h5+Wwr7BHJFAsITzhyTiZh2oWWG473OY78Y iP+u64Pgq9XLK6rg6qaR7YiW49mEsncRKPlyI49AsJxpv6XVmQPDVGUoDjHodBhUyyRRLXfI yd1FPqaooKzbZBt5+CHYtyLR3UaDnm2Ic+Ws8gLQvNipZdxSGxwxYcp6NSJswC23Q/cMPxHF o1vwO3RxuGY3o8PT8bXvcYhO1ZldNr6fzWGr07fbLLXdrZ7ow0nszAPu7gZ0LIs24HDi5nJk MmA6ft7YYobqM5vAOZkbsdzBX65NmWsKMkzHdsfc7iU73dyN2Ptfb9w4oOtsY3Si+FTwmHbr SAU6blRuk9jm4S71SJLwEwMOlsYijnh8S2p+ZBosRC/AhSlKByILIZ7f9YsAmtLUqgg5cSqi eAwwQ2ZECBVP6djF/6/syZbjxnV9P1/hytO9VZkpt+1knFuVB7bE7tZYWyjJ3c6LyrE7iSux nfJyJjlffwFQlLiAis/DjNMARFFcQBCr1KmsJp7iDJPVP/RQgO6xp7wTRQg/Y1mNAKNdK/WM 7B8w0T3xrFutxOGKis+RWYsjEtOAaUZDY+wYgWXO+zJVVWad3AOgX2YlbAbfg9bFson3vAZM /MirTzeY0OL113+Gf/z77lr/61X81WPUuT1RYVxYyka3lMDjLE5AP0dm5gLRitSkojATtNke PD1cXtEB7DOJprV9uNpCu8eiltwNtp5Q8M6eiwxACtIuu+01VacSaTKJsjg77UmIXbVKJI7N Ra96P/2iUa2FH2upX2s2a28rR+sE/JNzirLB4wYs+qq2syBSaJ5ONe+EXTdZ5RYchN+9ifXi FQJ5VvDnGV1iktFV3/I07SIFTorKdvinED5iManrXUyhg17ek0n4dv2GtGXgBjOSEH+x3asS kWxkv61UOmQ9sa7uAgU3ENrg/lQL5WT8QVDVZDt4yDpG5A7dRO0lbiD9En1cYQIsHGaK6BHs hLOjZxcG5F34+GlVwHFeJuqCUouz8wEU53C8sHlyVs2YZcKMgQ/INMAkOZqaFRrB2Za7qnWc jQiAEZyUWZmNpzDrElNwDvRboUpnNDTYC1TSwFZJZ5t9WBVtf85pEzXmyGsgaZ0yGViAatWc 8JmKNbK3Z3YFo9O7olkCIF7e05kcVvxZUcFc5eKiZzLDJpdXX20P2FVD69Veh3oBN61wA2gN YpM1bbVWgg+gMlQxgdLgq+XfGBYzVgIbI8Spe/pYfdw/X98ffIZtFuwy9DJ2Bo8AZ75xmqDn hR/NYmNRuHLnjcA1ZocuqjLjI1mJJtlkeapk6fWihjOPar/hEHZ+H5O6I5GvVdY2P5OqtL/G O9bgRhH85LiFRuxE2yofCDswlW4qn023hs20ZJcnHKOrFAR9OJNsY7GpaLfO1hiypYdpwus/ ZllPgk84keN7MMEFZf2mADJnwVUKcw1Sa5xvIfErZw2MIOh+03hJPf5erZojh9xABmZwOL15 xGyB5UntpMeudk3YwKEvWJfEsSFvTkY4M4kjrpFJp3S6LO+FGOGOWg30rND1ILgR0rQfnYRW Gkb6QuvcXmYeKzKQXqTn6PWb6lcyBPlHN02PgX/0cmwwFE0bKaBGFAL7aOIk5luiwZ0nAXa7 kbhihX/EmaULDM3jvQTxs9ZNcnpVxJbmGNXl/B7zvpxhWMPyAuTg94vDo5PDkCxHGcFMctAO DLmNnPiWQZ+M6GjnkGqTzDVzenL0gmZwEuM9nWne/0ozOrzqKvxwjn7uCw090xXnG37fbtDi q+//Ofl69SpoN5mpjTWQYITLHF6L/vG+KGHfiGSLaQk8dmqQ3g7H37YAQ78dna6GIG/iLmOI PHl/65Gf9LxVkIpPlhFpRXeNxIIoHkWjXK5FcgHCJbceDRGepHA3AiL320xp0S6treAr+x1c BsG1Iu9RkHwrO4knSND+TxwN54W+R2TTlcqOxtS/+7W9bQAATB9h/ZlauhWeNbn5jKyk0wFL 3yaYSZwfWfNQtABHIusNz8MSYJz29OJvLRNy9hHCYrjTduqZni6HoyLVVgqM2UMxgk+kTVRd nYhIMDvhA5ZvI4P0ihOUV41PeLzA11Tja4bwBf1rtuVvaebWfFKlIibdi+DcGVHvan42SzsH JPyYeNfN4/3p6Zt3fyxe2WhMREMS8Mmxk6HXwf11zEWmuCS2IdnBnNpOIB7mKPrKU9b33COJ 9/g04q7iEfE8zCPitoFHcjzTEc604JFEh+7t25mGuSAFh+Td8dtIw+/eHEYbfsfaRV2Sk3ex Hv914mKypsJV159G37c4esOp232ahduuaJIs89s0L4tPq6HguYNNwXu22BSxiTX4N7HucT67 Nj5Y1gYRm/Hxu4/5wV9EJmURdPGsyk57jt2OyM5tClOugoDslkk0iERiqvlIa5qgbGXnlqMZ caoCEV5wIvxIcqGyPLftBwazFpKHKynPQnCWYCW1lEGUXdZGvtgpRG8wbafOsmbjIrp25az/ NOdVKl2ZJV6BkAGTVf3WsW05Kknt2r6/en5Ay2qQWxYPOfv1+LtX8kOHJdbiJ9NQRR6mCJ9Q cMfmj6JWdUCVxs/SQeM4R4I5ftINXHGlErFbrrklY6rXhoxmrcpc1bAh4WWkAcnf5JDNtFri AlnexHIPWMrPsBEqlSV8RUdJY+sLE/ZtV1IIiBw9TNDCCppY8iUiQ2Lso1+RdAXiLepbtQUh 4nInWqpeJxWWn9nIvGa15+bWOo2z7fifNwXcf+6vvl3f/3P3+tfl7eXr7/eX1z9u7l4/Xn7e Qzs3168xf80XXISvP/34/Eqvy7P9w93++8HXy4frPXlGTOvzX1OBjoObuxv0jr35z+XgSW9W PqaDgU9IzvrSK0NJKIzlxWmwkrOztgRNuoL976Zxn5y5+H4YdPwzxvARfwNOGgdY/ZUxuyQP v3483R9cYR30+4eDr/vvP+xicpoYvmkt7PxKDvgohEuRssCQtDlLsnpjGyQ8RPgISvAsMCRV TnrdEcYSWjd1r+PRnohY58/qOqQ+s21WpgW81YekwM/Fmml3gLtuyRqFG4rVL9kPjvc4SsEd NL9eLY5Oiy4PEGWX88Cw6/SHmX1ShCUB3MsbPMx9VoQtrPMOLZbILjC1YIAfA6W1Ev/50/eb qz++7X8dXNES//Jw+ePrL9vZxkw9n+dXI9Nwpckk/AqZEKHftExUOtd6UzDj16lzefTmzeLd DGoYAG2Lf376io55V5dP++sDeUefiw6L/9w8fT0Qj4/3VzeESi+fLoOdndjVBc1IA+zWp9vA ySyODusqv0CnbWZ7r7NmcXQaRcA/mjLrm0YyXEB+yM7ZAdwIYJaObVTnGqF4ptv7a9umZLq6 DCcoWS1DWBtusITZFdJ1zxigueLTkQ7oasU5oQzImuvijnk1CCJbJUK2UW6i8zCh+KG28OJ8 x/C0FCTJtgtXBer9z82i22Ctl8jwFyL8uA0H3HHDcK4pjbfq/vGJ2bOJSo4jsS8OhfZY+C1d fKYIDfOVc1xxt2OPomUuzuQRt2Y0hlV7OQQsf4OutIvDNFvFMbGOrtl+RpfQuEAwg+vbkwBf pBzsDfPBRQYbWOb4d24SVJECg/gdRUSJMlEcvXn7G4pj1jvUMKGNWDDfgGDYSo3kwjYmGni5 puKbeLM4elkjIW+khznwcQgsGBi6FyyrNdOvdq0WbCW4Ab+tuTfTaupppfVlNqap0tuUCt2G TEHIhnk/QL3K9SHeeoO/V6rtKmP3n0YEqnAfH1neWNUI7vEiivjdg8NJB+z15ZRHcVKdWpz7 EsSF25eg829vWoa/IHTusZSdQ4Ae9zKVw1NzG3BFf+coGswJPLdHjRjCdMSgmI74woaqnYxN LpyOzdgYGJqZYbJIrGaCLy1mh6rdVn7FT5YgtjIMOtJHF90fb8VFlMb5VL3J729/YDCCczMe lwPZV4PWPHv9AD09meE++cew42RcDaBoSTWdU5d31/e3B+Xz7af9g4l453qKxc36pOauiKla UqqSjsdsvGJPDo6veGmTcHInIgLg3xlWOpPoyu1qbqwrXy8wLXXUpuURmkv1i4hVGTHeeXR4 sY9/Mh0WWbnyNQ7fbz49XD78Oni4f366uWPkyDxbDscGA1fJSXBFGbyEziWRDKIU+7gRs5ja RiHVzAIFIs11rJZiJKGg7XR35trnoudfNd9KGhnOUeBTWBTo/WIx29Wo3Og0NddNqwVu4P27 5vwMRMSmzZY5wDC/X4p2c/YgG7G47mY2sUXYMBOLeNEWYwawGJZTJExY/KzDExHpaOKms+VI Poi2Tzen7978TGaFb0ObHO92fNFcn/Dt0YvoTl7Ynunk+erF3XwhKXT095RcoteQCksI7BLJ +aTYU1fk1TpL+vUuj0ycRTHjHyGaiwJTVAMh2iLQ0yL0qMUEDp9J7fNIZWUfb77c6fitq6/7 q283d1/sm7P2zEGmhpm2m9GK4r7fuMO+oG3z+cusFOpCOz+vDJPPo9w9z0opVE8+lrbnlvC8 x5cZ3FuwTpclS5hYI7jSlAnaKxSF7diKUpskl2UEW8q279rM9k4wqFVWpvA/BSO0tI1tSaVS JzZIoZ9g2RVLp0aaNhjZEVljgFSSYXpjW5tjUB6Y2C06FSVFvUs22tNHyZVHgQ6xK7wdUD2D Os/sLx3bgJUEok5ZtdqSZXOcBNgIiBgOaPHWpQhVDtDdtuvdp7xEGaQ0MTE37I4hgjxL5PLi lHlUY2ISMpEItfUqN3gUMHv8q115OHF/uYWhs2WoaZpoLV2nrwqC5Z1WhTUKEwo9VFEgcsXk j/p89qCey6UFTSUHP2GpPY9Li5prJeJaSWCOfvex96pHaQheGtjpGdAUEFdzQzsQZMKeqQEo 3Nz8E7TdwFaMN4aFu5KgtWXyN9NaZNVOH9+vP2bWfrUQ+UenXOyE2H2M0FcR+AkLH246Hv9g LL+KaoBUeeXcDm0oGsJPIyh44wzK5hHLZOP8IO/TlhJf2m6gFDZzLnIT62IGXCglLjQDs3hX 01RJBvwKBE4imFDI84Bb2gF5GoSOlb3DRRHu5NUt6TN0LVw4GtbtxsNRDWBRk4najz6gAsZp qvoWLsLOwTDx4gqj5pCwK0cng4mu2WZVm1tmCKRMqg3d8GA3VLmHclYSAGqp4LgxCK0g33++ fP7+hGHmTzdfnu+fHw9uteH48mF/eYAZ1f7PuljBw1T1s9Be4IcBAl6BTjAYXGGFJYzoBlW5 9CzPd226qanf0xYZ6xrvkIidxadxMvJsXRaoxzm1XFkQUTMFUx0KnOMlzBDc4xXn69Csc72l rPH/YJ/oebV0fzFsvszd0Isk/4geHdaWUB+8QlJFnTlBExjEimU/GqdWCd3DzM4/T5sq5Adr 2WIUQ7VK7b1jP0Plb3tbHFhVqPryq3ER9PSnveMJhGFkusIQsxFqDIZ1/AVGVKdDE/tV3jUb LwJsJCL3kiLxMOR1sRV26RECpbJ2KzWiI065ZuUPKzOGJ5+6ziFGeiboj4ebu6dvOkXE7f7x S+jSRLLvWT9Et0wuSxqM3ri8bV476mOxxBxE3Xz0QPgrSvGhy2T7/mRcMRRvxLRwMvUCazia rqTSK3o97YuLUmC9+pmdY1PECzWBvLmsQH7rpVLwAJ9vH1uA/0C8X1aNHrNhYqKDPWoeb77v /3i6uR1uIo9EeqXhD+HU6HcN+qcABtsr7RLpFSAYsebYlXwojkXZgPjNa7YtonQr1IoXatcp 8JBEZTVbuohKP1JI6XusL+wu9RrOSwxIL7gnlRQpOXwAjcVCJGaoaHQJNJsD6c42sK0xxKvI mkK09gHvY6hPfVXmF+EI6uNw1ZX6EeLX/fERJ6Nph6ohStlxdbOb0h78mES/7uwl8+JF8S+7 5M2w19P9p+cvVIU2u3t8enjGPIjW8ikEXtbh7mwXeLeAo/eWLHGY3x/+XEzjYNPpfB3RzeCG gBnYENrgefP7ROjTQ3QFhqLPtIMea6xrH8lZMJtnsAzt5/E388DEzZeNKOEqVmYtntN6KU3+ o4idf1/SCMfr7UWT4w6ADrzxVwzGdxohaXClGxuz+DbyTrlrMV10VYYjh3gSBGIumtW2dAPL CVpXGZYtZNMeTQ33+kbvvVJVsAVE7Aoyjrwm3u7CBrZsTWOjg2gxzsTpMEFMvaZoh3XYdOMP 8wB282uwFOjqOMMfDRkllIsVT7UJ/UK4LJFKOuJ1sW6jjFp3JoVDjEpv7fFotTZ4k3dLQ8zn LyAKCl+KbYRhFYPIlAN/CwfQYGbGRLPPrvFkbdMFELLSgUaWcLXfSLvQjLekzou+XpPncdiV c66KIfNYpOVMtZ0IdmoErKutkKesjzpD+R0vvLn3rkF6bSyK4ehwLoZ+KxyNxaNEI3zf6wmB 7kruTSFJ6Js1NjSCaCyuXpRRy2pinnC5dPQq3ov9BicmTYiqw/wU3PxrfFbmThkZDaVV8X7h AqdP8t5xRsUwQ5l6IELEQFlUaedHoLqOzRM39mSPjU6bNVxvgeiguv/x+PoA84s//9An++by 7ouTN60WWCUWo9IrtgCrg0dBo5PT7Vcj6cLUtRMYla4dcsYWuICtWmmqVRsiHXmb1B82Ib2D 6Vic2O8lOuB7b6X6WPbSHCloj9MnwQwXNUsTftjUGYuMOvMSmqHDC5tr4Bv6DdYPbkXD8evt BxAhQZBMXf8kWkq6cXYRzS8MHYACkuD1M4p/zMGveaKXjEUD3asCwaaUJMa3nmnbZ5Y4+GdS +tkPfQkDjsWiDqsd4UdZ4s//PP64uUOXV/je2+en/c89/GP/dPXnn3/+r2VaQYsktUt144PL fK2qczYPj0YosdVNlDD6vPSibZ6tCHgyKt+6Vu5kICKYqpgBg+fJt1uNgZOz2tbC1tENb9o2 ToC5hmqrrcuJKT5aOtLORAyI6GFGxbpBcM9l7GkcXvKnGOQejudQl2B/tRiUTMKRFdY8fSar pRhX38ppgdMhNKl+01YAb54ikI2e479YR6ZJiv1H9dQqF2s7/YsD78vCUvDQQWLyhZlvxLsh zAkWYJcyhb2lrSKMjKNFrWAX6G3+TV8Gri+fLg/wFnCFdkiH/Q8Tk0WGcdhqPt5dpmt/SVGG qEwb9ybmTqJeTzJ6UlFS4yB1lcOjIp33O5coGCAsRp6HqZNAimUvL3rTJpaTkrfajA4ApGBM 9cjBY+sTcXA/sZ7jlAtAhPIzKRHGA/Ro4bzAzyGHQPmh4RRNJo+q873B/ebDIK8pUgRwG0/A hS65cMrYk7PStEhD3lhS1mlAOdFz55YCYx67VqLe8DRGcbby9geD7LdZu0Gdb/MCsjRTeLyi evEl5EIFrQ7ogi5A8Fq0cXskmKaKZhcp4WJbtkEj6KDm66eToTXdtMdDFGrze280dFcS96gg Ra5frJDqAxK94zAAf4ChtmhnQc2UPxVWU4M6pNnaEv9wEqNWnv3W4H3mTu2/aCBkdOneF6Mo RWr4oOlwzU0RltyC47haZNH9fr29YKmFvQFmhOlfuJ7om2f4JTDSIPOumE+w5BKakzkSLbTN EGy2wA/mCIoiq4J0N9MXDvxCbwPunB+WdFOKutlU4Vo3CKO69Nadbn8JRyMsWj2MnnTm4GSg xbOlOCIYvD2wzCc9yfqyjcSwtw0Z89Lo+uqggaXUe9FaPMt6FcDMgvLhfAvzPKm5KGE5js9M s4weTUNpgFhcODareUdW+uKGS0Z7nzcRTueYxU/mKc2bRU6WRxz2uaWmPxn/dKqJ5sUclmUr 4Pyu43dyu5f/FfGYMpQ4VCrzNpIf2OKbZF2KCQvWzCHr7H11IYozWSr7apNki+N3J2SpRfUP v+0FFlVjE1xOWidKypsN2m/XyKOD9QeaQOL6efqWk7g8AThg8KGAHNJIofILY47rGsvaiz72 g0GMjoau5p+KtJUu15EHKOvsLl261Wj1JTVfkiU2ppwceWP4IdhddEzBFMuh9RsL9dFqONy5 NWMsRMSqNlJ0cWvlSBMxaQwWRrJ8Gk+UyfWgFnNmTnqUZJoZPM1t3MFNDw4ZXwZblVnlpELD C2bYBcNZy61OXF0pZ8ZGuLYGEo/yj7RBgnbXr23abvePT3gRRGVJgjXaL7/srdQcnaNu1fq+ wTTgg9351jC5o20Z7G2NJTEyclk2ly20GldqYNCOJbAueCL7PaVs0ceWpePZKNnuxrfNsZOz pDoP9LgNHJLV+bDx7SxrA/U0Akg2GBLQqiwUmoi4kSBKNMyqrqAwIts+q5HAaoWS2jnm/eFP rPM0qgkVnJokU2odjolimVwaz9KWT/eidW54jjaxzJdEUmQlGlV4/3OiiD6/nO5fsHdmDqIl uonN4G2HtCiV43MWJxuMQDGLG+mC3p6wJi762o3coQltZji0P4pOXcBKkANVk7hhPlqhDoi2 4ox6hB7drm3gMmu1NcNtqusynuUSVvvixfGY3HkFB2mcQqEPLBmB4jTRUCXCgsgxszbPZhYu fLKn+nfxg1EjTkAaAvQ8mnlHzQcTaCQ61m8qMhSe88wGPcuhn78TF7G1VaaKrYi42Oj1Qvmj OZNC1gLzy1Ofmys55PXn+LdujUXpYAEWYXnyBzw/KVIkiBiNpr6GT+rpiB/+w3ahNELRFE5E 5FgYZziaLBK4I85uYQpPiAijphGfwJlQ5EGUMmkaQHjEHdHNBXCIc8O7bT3u7PEdJAXS7mv/ D5u7kUEXRAIA --82I3+IH0IqGh5yIs--