This is GCC Bugzilla
This is GCC Bugzilla Version 2.20+
View Bug Activity | Format For Printing | Clone This Bug
Compiling the attached code, I am able to reproducible SIGSEGV the GNU C++ compiler. I am sorry for not reducing code size very much but after spending more than an hour on stripping it down, gcc-3.2.1 crashed while 3.3 did not. Also, removing lines which I think have little to do with the problem also turns the crash into "just" an internal compiler error. (I know you will not like me for attaching a .tar.gz file... but sorry, I see little alternative) In order to give you more info, I also had a look at the crash using a debugger. Please contact me if you need additional info. I will be happy to help fixing this issue. --INFO-- GCC version: gcc (GCC) 3.2.1 20021107 (prerelease) and: gcc (GCC) 3.3 20021107 (experimental) as well as 3.2 20020731 (prerelease), maybe others. First of all, I patched toplev.c to not call signal(SIGSEGV,crash_signal) but die of SIGSEGV instead. This makes it possible to find the crash with gdb. [BTW, to ease debugging, I suggest you do not _exit(1) on SIGSEGV/ILL/... and ICE but terminate the program by killing itself via SIGABRT. This way, it gets much easier to debug internal errors.] The crash was encountered using both these calls (3.2.1 by default): g++ -v -I. -Wno-non-template-friend -Wno-unused \ -ftemplate-depth-30 -c -o spline.o spline.cpp g++ -V3.3 -v -I. -Wno-non-template-friend -Wno-unused \ -ftemplate-depth-30 -c -o spline.o spline.cpp From the output above, the following calls to cc1plus were grabbed: /usr/bin/../lib/gcc-lib/i686-pc-linux-gnu/3.2.1/cc1plus -v -I. \ -iprefix /usr/bin/../lib/gcc-lib/i686-pc-linux-gnu/3.2.1/ -D__GNUC__=3 \ -D__GNUC_MINOR__=2 -D__GNUC_PATCHLEVEL__=1 -D__GXX_ABI_VERSION=102 -D__ELF__ \ -Dunix -D__gnu_linux__ -Dlinux -D__ELF__ -D__unix__ -D__gnu_linux__ \ -D__linux__ -D__unix -D__linux -Asystem=posix -D__NO_INLINE__ \ -D__STDC_HOSTED__=1 -D_GNU_SOURCE -Acpu=i386 -Amachine=i386 -Di386 -D__i386 \ -D__i386__ -D__tune_i686__ -D__tune_pentiumpro__ spline.cpp -D__GNUG__=3 \ -D__DEPRECATED -D__EXCEPTIONS -quiet -dumpbase spline.cpp \ -Wno-non-template-friend -Wno-unused -version -ftemplate-depth-30 \ -o /tmp/ccXIR5cn.s /usr/bin/../lib/gcc-lib/i686-pc-linux-gnu/3.3/cc1plus -quiet -v -I. \ -iprefix /usr/bin/../lib/gcc-lib/i686-pc-linux-gnu/3.3/ -D__GNUC__=3 \ -D__GNUC_MINOR__=3 -D__GNUC_PATCHLEVEL__=0 -D_GNU_SOURCE spline.cpp \ -D__GNUG__=3 -D__DEPRECATED -D__EXCEPTIONS -quiet -dumpbase spline.cpp \ -auxbase-strip spline.o -Wno-non-template-friend -Wno-unused -version \ -ftemplate-depth-30 -o /tmp/ccZEfMxs.s ------------------------------------------------------------------------------- > >> gdb revealed the following information for the gcc-3.2.1 crash: --BACKTRACE-- #0 0x0809752a in convert_arguments () at gcc/cp/typeck.c:3155 #1 0x080972ed in build_function_call_real () at gcc/cp/typeck.c:3019 #2 0x080973f5 in build_function_call () at gcc/cp/typeck.c:3069 #3 0x08096e7e in build_x_function_call () at gcc/cp/typeck.c:2807 #4 0x080a1b46 in build_member_call () at gcc/cp/init.c:1497 #5 0x08081a10 in build_expr_from_tree () at gcc/cp/decl2.c:3891 #6 0x0806e956 in tsubst_expr () at gcc/cp/pt.c:7325 #7 0x0806ea3d in tsubst_expr () at gcc/cp/pt.c:7358 #8 0x0806ee7f in tsubst_expr () at gcc/cp/pt.c:7505 #9 0x0806ee7f in tsubst_expr () at gcc/cp/pt.c:7505 #10 0x08071d05 in instantiate_decl () at gcc/cp/pt.c:10149 #11 0x08071e3b in instantiate_pending_templates () at gcc/cp/pt.c:10234 #12 0x08080ef7 in finish_file () at gcc/cp/decl2.c:3378 #13 0x080aa8a9 in finish_translation_unit () at gcc/cp/semantics.c:1595 #14 0x0808a941 in yyparse_1 () at parse.y:458 #15 0x080c1af5 in yyparse () at gcc/c-lex.c:164 #16 0x08209713 in compile_file () at gcc/toplev.c:2124 #17 0x0820db9d in do_compile () at gcc/toplev.c:5218 #18 0x0820dc02 in toplev_main () at gcc/toplev.c:5250 #19 0x080c31c3 in main () at gcc/main.c:35 #20 0x0018f7ee in __libc_start_main () from /lib/libc.so.6 --SIGSEGV location in convert_arguments()-- ... /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. Strip such NOP_EXPRs, since VAL is used in non-lvalue context. */ if (TREE_CODE (val) == NOP_EXPR && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)) && (type == 0 || TREE_CODE (type) != REFERENCE_TYPE)) val = TREE_OPERAND (val, 0); if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE) { ==> if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE) val = default_conversion (val); } if (val == error_mark_node) return error_mark_node; ... (Neither type nor val are NULL.) --REGISTER DUMP-- eax 0x0 0 ecx 0x2 2 edx 0xc55c08 12934152 ebx 0xc55ba4 12934052 esp 0xb503c6f0 0xb503c6f0 ebp 0xb503c738 0xb503c738 esi 0x663474 6698100 edi 0x29c3f0 2737136 eip 0x809752a 0x809752a eflags 0x10293 66195 cs 0x23 35 ss 0x2b 43 ds 0x2b 43 es 0x2b 43 fs 0x0 0 gs 0x0 0 ... orig_eax 0xffffffff -1 ------------------------------------------------------------------------------- > >> gdb revealed the following information for the gcc-3.3 crash: --BACKTRACE-- #0 0x080c53ca in build_expr_from_tree (t=0xa5a5a5a5) at gcc/cp/decl2.c:3074 #1 0x080c6b85 in build_expr_from_tree (t=0xac912c) at gcc/cp/decl2.c:3357 #2 0x080c6ba0 in build_expr_from_tree (t=0xac9140) at gcc/cp/decl2.c:3360 #3 0x080c6ba0 in build_expr_from_tree (t=0xac9154) at gcc/cp/decl2.c:3360 #4 0x080c6ba0 in build_expr_from_tree (t=0xac91b8) at gcc/cp/decl2.c:3360 #5 0x080c6ba0 in build_expr_from_tree (t=0xac91cc) at gcc/cp/decl2.c:3360 #6 0x080c6671 in build_expr_from_tree (t=0x7ef720) at gcc/cp/decl2.c:3302 #7 0x0809885d in tsubst_expr (t=0x0, args=0xa8e280, \ complain=3, in_decl=0xbc8310) at gcc/cp/pt.c:7373 #8 0x08098abd in tsubst_expr (t=0x0, args=0xa8e280, \ complain=3, in_decl=0xbc8310) at gcc/cp/pt.c:7398 #9 0x080995b2 in tsubst_expr (t=0x0, args=0xa8e280, \ complain=3, in_decl=0xbc8310) at gcc/cp/pt.c:7545 #10 0x080995b2 in tsubst_expr (t=0x0, args=0xa8e280, \ complain=3, in_decl=0xbc8310) at gcc/cp/pt.c:7545 #11 0x080a0bdb in instantiate_decl (d=0xa5a5a5a5, \ defer_ok=0) at gcc/cp/pt.c:10181 #12 0x080a0f34 in instantiate_pending_templates () at gcc/cp/pt.c:10266 #13 0x080c471a in finish_file () at gcc/cp/decl2.c:2775 #14 0x08110b33 in finish_translation_unit () at gcc/cp/semantics.c:1599 #15 0x080d77a5 in yyparse () at parse.y:488 #16 0x0813cf36 in c_common_parse_file () at gcc/c-lex.c:159 #17 0x082e9792 in compile_file () at gcc/toplev.c:2126 #18 0x082ee6a5 in do_compile () at gcc/toplev.c:5353 #19 0x082ee703 in toplev_main () at gcc/toplev.c:5383 #20 0x081457df in main () at gcc/main.c:35 #21 0x001847ee in __libc_start_main () from /lib/libc.so.6 --SIGSEGV location in convert_arguments()-- tree build_expr_from_tree (t) tree t; { if (t == NULL_TREE || t == error_mark_node) return t; ==> switch (TREE_CODE (t)) { case IDENTIFIER_NODE: return do_identifier (t, 0, NULL_TREE); Crash with t=0xa5a5a5a5 (uh, looks suspicious...) One stack frame above (recursive call from build_expr_from_tree()): case TREE_LIST: { tree purpose, value, chain; if (t == void_list_node) return t; purpose = TREE_PURPOSE (t); if (purpose) purpose = build_expr_from_tree (purpose); value = TREE_VALUE (t); if (value) ==> value = build_expr_from_tree (value); chain = TREE_CHAIN (t); if (chain && chain != void_type_node) chain = build_expr_from_tree (chain); return tree_cons (purpose, value, chain); } `value' is reported to be 0xa5a5a5a5 while t=0xac912c. --REGISTER DUMP-- eax 0xa5a5a5a5 -1515870811 ecx 0xac9140 11309376 edx 0xa5a5a5a5 -1515870811 ebx 0xa5a5a5a5 -1515870811 esp 0xb8142820 0xb8142820 ebp 0xb8142898 0xb8142898 esi 0x0 0 edi 0xa8e280 11068032 eip 0x80c6b85 0x80c6b85 eflags 0x10296 66198 cs 0x23 35 ss 0x2b 43 ds 0x2b 43 es 0x2b 43 fs 0x0 0 gs 0x0 0 orig_eax 0xffffffff -1 Release: 3.2 20020731 (prerelease) ... 3.3 20021107 (experimental) Environment: i686-pc-linux-gnu How-To-Repeat: Compile attached code using calls mentioned above.
Fix: http://gcc.gnu.org/ml/gcc-patches/2002-11/msg01976.html
State-Changed-From-To: open->analyzed State-Changed-Why: Confirmed. Compiling the code with gcc 3.2 I get an internal compiler error. The problem can be reduced to the following code snippet: ------------------------snip here-------------------- template <int I> struct A { void foo(); template <int M,int N> friend int bar (const A<N>&, const A<M>&); }; template <> void A<0>::foo() {} template <int M,int N> int bar (const A<N>&, const A<M>&) { return N; } void baz () { bar(A<1>(),A<2>()); } ------------------------snip here-------------------- Compiling this with gcc 3.2 (just "g++ -c") I get the following ICE: bug.cc: In function `int bar(const A<N>&, const A<M>&) [with int M = 2, int N = 1, int I = 0]': bug.cc:11: instantiated from here bug.cc:9: Internal compiler error in c_expand_expr, at c-common.c:3646 Please submit a full bug report, [etc.] In fact, the short testcase crashes gcc since 2.95.x. The code looks illegal to me (foo is specialized without having specialized A first).
From: Zack Weinberg <zack@codesourcery.com> To: wwieser@gmx.de Cc: gcc-gnats@gcc.gnu.org Subject: Re: c++/8511: (hopefully) reproducible cc1plus SIGSEGV. Date: Sun, 10 Nov 2002 12:43:03 -0800 On Sat, Nov 09, 2002 at 12:33:14PM -0000, wwieser@gmx.de wrote: > Compiling the attached code, I am able to reproducible > SIGSEGV the GNU C++ compiler. > > I am sorry for not reducing code size very much but after spending more > than an hour on stripping it down, gcc-3.2.1 crashed while 3.3 did not. > Also, removing lines which I think have little to do with the problem > also turns the crash into "just" an internal compiler error. That is an expected effect for the sort of bug you have found. > First of all, I patched toplev.c to not call signal(SIGSEGV,crash_signal) > but die of SIGSEGV instead. This makes it possible to find the crash > with gdb. [BTW, to ease debugging, I suggest you do not _exit(1) on > SIGSEGV/ILL/... and ICE but terminate the program by killing itself via > SIGABRT. This way, it gets much easier to debug internal errors.] I do not understand why you need this. When I run cc1(plus) under GDB and it takes a fatal signal, GDB recovers control at the point of the signal, before signal handlers have a chance to run. For debugging 'plain' ICEs, the thing to do is set a breakpoint on internal_error() before running the program. > if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE) > { > ==> if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE > || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE > || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE) > val = default_conversion (val); > } > > if (val == error_mark_node) > return error_mark_node; > > ... > > (Neither type nor val are NULL.) There's not enough information here to know what went wrong. Probably TREE_TYPE (val) was an invalid pointer. > ==> switch (TREE_CODE (t)) > { > case IDENTIFIER_NODE: > return do_identifier (t, 0, NULL_TREE); > > Crash with t=0xa5a5a5a5 (uh, looks suspicious...) Yeah. That means the garbage collector ate a piece of live data. These are a pain to debug -- even slight changes in the input will make the problem vanish. Unfortunately, using the code you posted, I cannot reproduce the crash; I see same the ICE in c_expand_expr that Volker Reichelt did. This is very likely to be because the libstdc++ headers have changed just enough to perturb the bug into going away; I don't see any logged changes that could plausibly have fixed the bug. We need you to give us a preprocessed source file. Using your installation, issue this command: g++ -V3.3 -v -save-temps -I. -Wno-non-template-friend -Wno-unused \ -ftemplate-depth-30 -c -o spline.o spline.cpp That should provoke the same crash, but it will produce a file named spline.i as a side effect. Send us that file (compressed! it will be huge) and the complete output of the command. zw
From: wwieser@gmx.de To: gcc-bugs@gcc.gnu.org, gcc-gnats@gcc.gnu.org, gcc-prs@gcc.gnu.org, nobody@gcc.gnu.org, reichelt@igpm.rwth-aachen.de Cc: Subject: Re: c++/8511: (hopefully) reproducible cc1plus SIGSEGV. Date: Sun, 10 Nov 2002 14:19:44 +0100 On Sunday 10 November 2002 00:54, reichelt@igpm.rwth-aachen.de wrote: > Synopsis: (hopefully) reproducible cc1plus SIGSEGV. > Thanks for your reply, but... > State-Changed-From-To: open->analyzed > State-Changed-By: reichelt > State-Changed-When: Sat Nov 9 15:54:52 2002 > State-Changed-Why: > Confirmed. > > Compiling the code with gcc 3.2 I get an internal compiler error. > The problem can be reduced to the following code snippet: > > ------------------------snip here-------------------- > [...] > ------------------------snip here-------------------- > > Compiling this with gcc 3.2 (just "g++ -c") I get the > following ICE: > > In fact, the short testcase crashes gcc since 2.95.x. > The point is something different. I get a real SIGSEGV, NOT an internal compiler error. Sadly, I have quite a lot of heavy template code which triggers internal compiler errors (I reported one of them some time back and it is not yet fixed), but this one really makes gcc SIGSEGV. Also, the debugger shows the suspicious address 0xa5a5a5a5 which might indicate some more serious bug inside the compiler than simply a missing C++ language feature. So, please tell me if you can reproduce a SIGSEGV, and not an internal compiler error. > http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc& >pr=8511
From: Volker Reichelt <reichelt@igpm.rwth-aachen.de> To: wwieser@gmx.de, gcc-gnats@gcc.gnu.org, gcc-bugs@gcc.gnu.org, nobody@gcc.gnu.org Cc: Subject: Re: c++/8511: (hopefully) reproducible cc1plus SIGSEGV. Date: Sun, 10 Nov 2002 23:03:15 +0100 > The point is something different. I get a real SIGSEGV, NOT an internal > compiler error. Sadly, I have quite a lot of heavy template code which > triggers internal compiler errors (I reported one of them some time back > and it is not yet fixed), but this one really makes gcc SIGSEGV. I suppose it's *not* a "Internal compiler error: Segmentation fault". Did I get you rught? > Also, the debugger shows the suspicious address 0xa5a5a5a5 which might > indicate some more serious bug inside the compiler than simply a missing > C++ language feature. > So, please tell me if you can reproduce a SIGSEGV, and not an internal > compiler error. I just tried gcc 3.2 on your sources, but I only get an ICE. However, since you haven't provided a preprocessed source, I'm probably compiling different code than you. Can you generate a preprocessed source that also causes a segfault? If yes, could you please send the preprocessed file? If no, then something strange is happening :-( My first wild guess would be that the compiler ran out of memory when compiling your source. Can you make sure that this is not the reason (i.e. by using a swap device that is large enough)? You might have hardware problems: for example faulty memory (you could try to swap your chips if you have multiple banks of memory). I remember one PR where a faulty BIOS was responsible for strange gcc errors (are BIOS upgrades available for your board). Good luck, Volker PS: gcc-prs is a read-only list and therefore always bounces, just don't send any mail to that address. http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=8511
From: Zack Weinberg <zack@codesourcery.com> To: Wolfgang Wieser <wwieser@gmx.de>, mark@codesourcery.com Cc: Volker Reichelt <reichelt@igpm.rwth-aachen.de>, gcc-gnats@gcc.gnu.org, gcc-bugs@gcc.gnu.org Subject: Re: c++/8511: (hopefully) reproducible cc1plus SIGSEGV. Date: Tue, 12 Nov 2002 18:29:22 -0800 On Tue, Nov 12, 2002 at 10:25:10PM +0100, Wolfgang Wieser wrote: > Ah - still: Doing abort() instead of exit(1) on ICE would make it easier > debuggable. (Or am I wrong again? - Okay using a breakpoint...) Use of exit() happens to be the easiest way to prevent users from getting 100MB core dumps (which they will then try to mail to gcc-bugs) when ICEs happen. > > > (Neither type nor val are NULL.) > > > > There's not enough information here to know what went wrong. Probably > > TREE_TYPE (val) was an invalid pointer. > > > How can I tell...? (gdb) p val->common.type->common will dump out enough information to tell you if it's a valid pointer to a tree. (TREE_TYPE (val) expands to val->common.type. You can find this out by reading tree.h. Yeah, it's a pain.) > > Yeah. That means the garbage collector ate a piece of live data. > > These are a pain to debug -- even slight changes in the input will > > make the problem vanish. > > > That's _exactly_ what I am experiencing! > Even if I remove some lines far away which seemingly do > not have anything to do with the location of the SIGSEGV, the SIGSEGV > goes away (turns into ordinary ICE). ... > > We need you to give us a preprocessed source file. Using your > > installation, issue this command: > > > I'll provide you with preorocessed code. Using the file you attached, I can now reproduce the crash. It turns out not to be a GC bug, but an access-beyond-end-of-array bug. tsubst() [in cp/pt.c] is called with this TEMPLATE_PARM_INDEX expression: <template_parm_index type <integer_type int> index 1 level 1 orig_level 1> and this 'args' structure: <tree_vec elt 0 <tree_vec elt 0 <integer_cst 3>> elt 1 <tree_vec elt 0 <integer_cst 4> elt 1 <integer_cst 4>>> tsubst is to return the element of the args structure that the template_parm_index expression refers to. Here's the catch: 'index' values are 0-based, but 'level' values are 1-based, so it winds up trying to access elt 1 of elt 0 of that tree_vec. Which, as you can see, does not exist. This should have been caught by bounds checking code in the TREE_VEC_ELT macro (since ENABLE_TREE_CHECKING is on), but, well, there is no bounds checking code there. So tsubst happily reads the word one beyond the end of the inner tree_vec, which the garbage collector has helpfully set to the 'poison' value 0xa5a5a5a5. That then gets plugged into the structure returned from tsubst. The crash happens significantly later when other code tries to dereference the poison value as a pointer. I think the right fix for tsubst() is this patch: =================================================================== Index: cp/pt.c --- cp/pt.c 9 Nov 2002 11:53:16 -0000 1.630 +++ cp/pt.c 13 Nov 2002 02:21:05 -0000 @@ -6539,7 +6539,8 @@ tsubst (t, args, complain, in_decl) tree arg = NULL_TREE; levels = TMPL_ARGS_DEPTH (args); - if (level <= levels) + if (level <= levels + && idx < NUM_TMPL_ARGS (TMPL_ARGS_LEVEL (args, level))) arg = TMPL_ARG (args, level, idx); if (arg == error_mark_node) That prevents the invalid access. Your test case then carries on to crash in c_expand_expr, which is the other bug that we already know about, and Volker found a reduced test case for. I'm cc:ing Mark for comments, he's a lot more familiar with this part of the compiler than I am. I'm a bit concerned that this does not happen when unrelated parts of the code are changed; the original data corruption could be even earlier. We also want to add bounds checking to TREE_VEC_ELT. I note that the first thing the patched compiler says about this code is val/internals.hpp: In function `void internal_vect::mult_mv(internal_vect::vector<n>&, const internal_vect::matrix<r, c>&, const internal_vect::vector<c>&) [with int r = 4, int c = 4, int N = 3]': val/vector.hpp:50: instantiated from `vect::Vector<N> vect::operator*(const vect::Matrix<R, C>&, const vect::Vector<C>&) [with int R = 4, int C = 4]' spline.cpp:102: instantiated from here val/internals.hpp:84: internal compiler error: in c_expand_expr, at c-common.c: 4319 If Volker's right that the code is invalid, this should be considered a more serious case of ice-on-invalid than one where an error message came up first. > [I hope it was okay to CC gcc lists when attaching spline.ii.gz.] Yes, that was fine. zw
From: Wolfgang Wieser <wwieser@gmx.de> To: Zack Weinberg <zack@codesourcery.com>, Volker Reichelt <reichelt@igpm.rwth-aachen.de> Cc: gcc-gnats@gcc.gnu.org, gcc-bugs@gcc.gnu.org Subject: Re: c++/8511: (hopefully) reproducible cc1plus SIGSEGV. Date: Tue, 12 Nov 2002 22:25:10 +0100 --------------Boundary-00=_YHFHWSTT4X4A1VQH0974 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: 8bit On Sun, 10 Nov 2002 23:03:15 +0100, Volker Reichelt wrote: > I suppose it's *not* a "Internal compiler error: Segmentation fault". > Did I get you rught? > No, it _is_ an ICE "Segmentation Fault". (Sorry if I was unclear on that.) >My first wild guess would be that the compiler ran out of memory when >compiling your source. Can you make sure that this is not the reason >(i.e. by using a swap device that is large enough)? > I have 256 Mb RAM and even more swap and I am pretty sure that mem shortage is not the problem especially as swap is neraly unused. I could analyze strace output (grep for mmap & brk) if needed. >You might have hardware problems: for example faulty memory (you could >try to swap your chips if you have multiple banks of memory). I remember >one PR where a faulty BIOS was responsible for strange gcc errors >(are BIOS upgrades available for your board). > I am using pretty new Infineon SDRAM, never had any instability problems and ran memtest for several hours some time back. Hardware is not the source of trouble. (But you're right: Checking the easiest trouble sources first is just logical...) On Sunday 10 November 2002 21:43, Zack Weinberg wrote: > On Sat, Nov 09, 2002 at 12:33:14PM -0000, wwieser@gmx.de wrote: > > First of all, I patched toplev.c to not call signal(SIGSEGV,crash_signal) > > but die of SIGSEGV instead. This makes it possible to find the crash > > with gdb. [BTW, to ease debugging, I suggest you do not _exit(1) on > > SIGSEGV/ILL/... and ICE but terminate the program by killing itself via > > SIGABRT. This way, it gets much easier to debug internal errors.] > > I do not understand why you need this. When I run cc1(plus) under > GDB and it takes a fatal signal, GDB recovers control at the point of > the signal, before signal handlers have a chance to run. > Oh yes, you are right. Ugh, why did I suggest that? Ah - still: Doing abort() instead of exit(1) on ICE would make it easier debuggable. (Or am I wrong again? - Okay using a breakpoint...) > For debugging 'plain' ICEs, the thing to do is set a breakpoint on > internal_error() before running the program. > > > if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE) > > { > > ==> if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE > > > > || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE > > || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE) > > > > val = default_conversion (val); > > } > > > > if (val == error_mark_node) > > return error_mark_node; > > > > ... > > > > (Neither type nor val are NULL.) > > There's not enough information here to know what went wrong. Probably > TREE_TYPE (val) was an invalid pointer. > How can I tell...? > > ==> switch (TREE_CODE (t)) > > { > > case IDENTIFIER_NODE: > > return do_identifier (t, 0, NULL_TREE); > > > > Crash with t=0xa5a5a5a5 (uh, looks suspicious...) > > Yeah. That means the garbage collector ate a piece of live data. > These are a pain to debug -- even slight changes in the input will > make the problem vanish. > That's _exactly_ what I am experiencing! Even if I remove some lines far away which seemingly do not have anything to do with the location of the SIGSEGV, the SIGSEGV goes away (turns into ordinary ICE). > Unfortunately, using the code you posted, I > cannot reproduce the crash; I see same the ICE in c_expand_expr that > Volker Reichelt did. This is very likely to be because the libstdc++ > headers have changed just enough to perturb the bug into going away; I > don't see any logged changes that could plausibly have fixed the bug. > > We need you to give us a preprocessed source file. Using your > installation, issue this command: > I'll provide you with preorocessed code. > g++ -V3.3 -v -save-temps -I. -Wno-non-template-friend -Wno-unused \ > -ftemplate-depth-30 -c -o spline.o spline.cpp > > That should provoke the same crash, but it will produce a file named > spline.i as a side effect. Send us that file (compressed! it will be > huge) and the complete output of the command. > Okay. So, first I CVS updated to the current version (20021112) and did a complete re-build (rm -f build-dir; build using gcc-3.3). [I can build gcc using gcc-3.2, too, if needed, but it's too late today...] And then, I compiled the attached code (spline.ii) which makes gcc SIGSEGV. (ICE: Segmentation fault) Please see if you can reproduce the crash. Regards, Wolfgang [I hope it was okay to CC gcc lists when attaching spline.ii.gz.] --------------Boundary-00=_YHFHWSTT4X4A1VQH0974 Content-Type: application/x-gzip; name="spline.ii.gz" Content-Transfer-Encoding: base64 Content-Description: Preprocessed source. Content-Disposition: attachment; filename="spline.ii.gz" H4sICBZr0T0CA3NwbGluZS5paQDsvX93GzeuMPy/PsWkPTdHcuTUkh3HsR3vSdO0m+emSZ7E3bv7 9PSdI0tjezbSSB1JtnO73s/+8jdBEuRwpJGTdNOz21ocEgRBEABBEPw26SXfzGfjvMgeDmezb1rf 0oLjs2U+XmznxYksGE4nk0ExSmhFWWg1e4QAEgWXpCDp0aIDo4xX+m45L7/Li+F4Ocq+Gz548N3u w93vxvl8Qdoku6TO/qNgpd1WAM5Zvph/d74shovsZpjNFg8vJdTdvRpNdgNd8Fr5tEhH2TkZ2hz0 8ahGH306kmIwyeazwTBL5otR649WK0mupvmI/CdNF5fl9Do9G4xS1WWbfuwctTz1BuPxdFhRZziY L1QVtMbi4yzLRwEw4+lFPkyzspyW7eG0mC+S4eWg3CLf5yjQ0XQyyIsaDfLiajDOyXjKi+UkKxZR jcZZcbG4rNHLdLlIp+dpOSgusqgG5bJY5JOsRhcMdh2UrrLyfEz+iG+yLEZVbRACT+fp+SAfL0ts 5Ld0ET4OLsJ+cIkwdp8vxoQhL6Zng3mml8j+Xp02oU7y/YP97dlwm4iX5c32RbHkIMhnMqLz/CJi 6ceAWAEFQlxXNDxZBwaGxHk2WJD5A330D3YDdTAY849ktKQfA8heAAif991ev2ZHdFzzxfIMUqS3 W9nR3s46VOuHhXLM7PfDGgll2vDaGM4XZV5cSCrsHVTVC+o7UmtERqygPa6qZ0Ab52ffXQwpBc4Q ajAaSUZhzcXkJXvMAFgHCoVB9Qz5meTFIpktylF+fp4ujigLKs5YF/SymOcXRTZifczz/814B3tP qsiEKuckWc7JlCSHhwBdXSjhU/H5aKdqWvv4xPLPcDl6K+y2sptFVhbJN8+/SYjp0Gpqah15qftk WLdkx1SrJFuTbDKcfUza/FeakhVM6g8XRJuMyJ9dQiLknzTligdpNS+HXTFb5FfRSZjSStpMl9ld T4jO1H2zDh3YNkCOEYSKjSk4qCr88UEzPiQtK7GxkZlnC43LvIvCwchE69GxTGZJ26FKD6FUP4Aa KRosyCDPlossTZM2gTgj8jpNO+jMDC9LpNNugAaxPVl9lYPr6u46qw6jvINxUOsr2SIMxHiO/wrw HFKB8JzLSDb0Igjew7LhTis5UA9tsNjo0NYA7xt6xOKiA4OLS3YAF5cq69daUGYvRY1u1l7DcmTT 8XiTQxNYkp5uzstJbc5cmTVbmOa9IXvnwTgLqF5QY1eZGKTHJeuRf0z5b76VF9/El9FgMaBY8p/z X3u7v/HNGR+EslXml9NywaaAVB7SftKzI1XNKF9MycYvK71fl7MZ/Xqru+UGUG/nSYWKB4yQpoIV 0nE8A+r+6J9rMAfrnbIH7V32gC9qa869bMNZx8APV79KuoyW2NoLqpQJc8ZoSY+ILBwqm4h6Kxj2 RS3zR9U2oxbLULspJGqrTRtsU3AxRXJZFstxs8C1JBrOZwUK2xU2/8yGi5XEq+4ttrPBkHoAV1lG imyzs/LDXfVF/ud2dTn4OF8Mhh/cHossG42zeqRE7It59in6XUw/oJprHrQ6Rtk4n2CmvwGeiQPS QVp6umgFBFy470BT3sTqanCVpWTb2wkZYSFMV0coGh1050T+51rvmiWUmJVF46yI3LFy7oGSmhUQ AKtxlIRLMJ6tsKFeeU9tU2ylzlfdziMykRCwrrKtkOkFDtLWtJPBTf3JcxYBc8Mnba6KyI9iOekE lrhskVptugrPs+U5QJL8okgG/AWkzv9m5dTwF3jJDxueDad05lHvielgiXHOxCMBbM2zu/RUcALn xSi7acSaMMCWzcGFBDo/n0s+yYMAWK8OlwoQxHoaT4sLgck4GhBhTgKHbFSmBflqwZRAIeQIy9+P qFDqm9pfOxvsen2tzn7Y9or3XWOHFb+5mdY14hVWRbNowb2Zi+OKJNQ2ZzaTpoelf5icn1Voda+N hktawTRXWTnfNH/qEeYXxWAslz/5FXC40WHPGvUmWtg0CxxFfyV35apeIXt4n9RXel6Cvjn/hk9B zsvpWZzCt3ujp5b0oMtl4fN8zL5AAN8mu/t7Ae8CO/vqx5x9fZs8flx99Ok/guOnTkdmCT0MMo7k mEfdKincouFg4VQyi/ghit3MLZmOxw4kpxZ1Z9kN57PCKnJLyP7Kwmme2YgzY9IqI/PIQkfgYC5L VpQXNDyLMdIW+cm/MEai0SAz7ynHH0mZLZaEi0QLrsVpcNGxttO2TqhE63Q5ANryKLltWQM3EWFx KNx1ysDKsJSexMTsndrD+XiRF6lsYOPBIFA85r2ODwfqGvEgQT8ZWFjhMn0/OrxpFT4EgotQgCr1 ybI6Xcj/PFiQ/61IFdYykigsEGm/wdgLos9Jq+rYC1lvxWgJ3tyIllgHiABR/2T/49zGpLVymAAy pn6/sUEFetnb89bBYTDGmE3n+U0vJXVNlPerKwegMpPVBrq7X1nVN1hCImTIu48rAfbVgB5XD0hV 3nvkJWVfskeInn2Hnk4kTTzEm+ksKxxa7lVWDUwPsRHyqQPyUSVIRaBHuxXDoRTfXYPrJZSD9Raz RqYBXPyxSlIMiii4x41GwY0IrjFRcLzerufUln8HUYW73gq7mwuPkl2ws1MnKsu7BK4H+eJ8PLgA UZF7u0HgAUDzxWCxBJD2d6trYgCzYpQPCkDRx94KXnwcGAdeGH08LBhBlhF3WeTTIqEfqIXRkjFV 1ymvd8RKxBk835Oxk3j+jxEOmKbXKZmoCSk6fHzkrzOcltloOZkd9gKViKUznI6ywwO8zmFvX26+ xPdb2oyMgqGQF4NFNqqJ+3wxnV0Nxr4uVR06vmq0LKxowxlH6ZZFTO5VsOWTvcC6M2MljIn7fTld HKlfZcb2RbfJKL+ikQrkH09b5WTUAFSRgjLWYGzfZQisDzbSgeyBrIOg5LFjGniAxkW2SCdn6XBZ 0rMHvn/H/fOj6fJsnCWDxfTc3agXxkFYtIuPAMsbAaboQiCO14PocTGb5Kfd+PpZ6eRNUJftsEcu YODFoX34nD+Y75HIOfeUUvR6Pp4OFrzT81U7jewTkhEOdrz6aFcbs5pD3v0avft7lltiaolgVFAS 0ERmOV6TFrXwQhygBue3UM5niP6+Lp4rkA7FzSSkRc3fG6HmmiStQdXx+tN/J3Qdj5sj7KqUpVc0 HlVrO3AQyEmcjjcmbiC+YRj+w7GQiBBDWK4/hqjRREIAYw6PK2IVyElqaoRNzFXEjNVZQWoSm5zF puYyYkZ9UfBCpYvhjdYcXGjiolHixo3A6Hw9jGohVGH2SC4fNcIB68x6EPOWa52q2SUsQooHjXBw 9SK9KKfLme8w2JrlBjFbEzF8ypukXGPLHo7Gx7yGEm12FGuOAMor30ii1Grzc9OsYI4caT1Nu4lB NzLguMGuqHt9o643H1KKrsceDTNJmHquHb17sFdtR3Psxvt7AyNsD48h0V6S/b3xOnG0eLYA6rea h64nwzr2DWWPt9iG+SRYqTE3/k6wG34NyrlIzuiYpsuU/nHkfueXt2gF9tcRfhWdfif/Rb6y6aOf 6R9HPq+ld40t09+XNIXLkaehXV/WRu7E21RXHlODEATMQYoNRBLKruBccmMwevsoEFhr6VQzCEr+ vdtPAwRXFXyeYJyi5N/7e36C+mdCNVQYSXLTdfj7YDQqra9y8liQ2RUci+AXBnaEf7hwPwheyosp 3mQyHWX4Fxrv8QF+AgOb8rwHzqCoEWt+4vVnJmJCF8hkCQi+5Tif2J9UH/QjJ6uLNe8odNqQpleD 8a/937j3Pk3P56KNhd5Izo4sluJzaH8AhGG5gQIMOM+IKB7NPa3nVd+vz8YfjPGBj0Oyf/iADYR9 wMdI0S3V6Yj18UP20WyDLsl8NpTT20LxIijLifbXGBYLD0Pxj2IVYaxyPsfaA3aRFYIwzvNxGAav gMFQlcgic7/zBcHXjP0VMk46JxvBQZl6FYKst9QV7Rkj/ybmimfSBAtN2fUmORu+SA9iH2SDka2U d2Pqeg+E58PLbATOpg+ClXZb6lY1K0tng3IwsVay+FLm0zJffFQnlf29GES5dpe9iK/p+WC+oAuG BZoalqs8Wxa/Z3lB6xE63iKHlBrgKJsPS3ElnIgPo/jIXHdqxLIStc3SOUNFCKVsMRheUlwygAql wmw6zoeMBBjdVC36Q7fMi8uMUI59gvCmMwZeHVVeLAfliP4ClehFOSYJRfypCjyWHwwIrJRDuE2M 4aFHvH+AcdgzQ0VaykmfWGRmn+jhdU4NJ90RFar+jgRpl5PJR7uRxhBdT7KqEpWhDiZ0Z5GVV5DU E9LLsligI5mk0+uCX+yXlT/kxegoTJqJII0ex4TY9jdVo2eVOHirJTJJcOjTYujIdhu98prrpqpp La/VvHKsShpVMRhl5RylEPl8TdiX0wj7yn4rfghAgJVU15LaqmA2JyZAZpBIDi1MXVrHhOYFBcit 4F1Nx4NFPs4MwksBZLKnoG4Foc8GFqFJQZn9vsxLyJykcEZZ1sOf5DOy1M4GZZlnpRcr7/BFQzj+ gCaUrXjcxd5e5T6OJpsL7VNFViuo2JnBZ+/y1LYucbZ30gq19nXKzpAbOsfKkTswxKrQmzn9kVus iTZcEXtD2uHGN7YLSMReoNVyPlL7JAFWDPzMdiOJ2JOYn9i2I7nAsOHbi0TuMsyPYoeRqJ2GNQEM 7FKDBd/4IPUY7Y9sJMDigp+ZtZrMMHTZF+zDXF4khqYspA7fEyTOpkFtFxK1bbCaMt2RCA1CY4j6 YXeKa11RK17bVY+eeD7vQqS45EjUpuHb5PFORDu+v0nkNufb5KAf2xujLdiLIPFivh5L0WXpDbMK r2S1q0rgBsucYFBpbtVqLF2ik5oxhLcr85am+EC2Y8uQw2nJpBJB48lOmMOgmueuGyzfDF3SKXUu /t+X1F3YObLbUUdNsOFfPQ2piybY8L2nIVv1oYY/yIYee26ZrjJeF0T9obsw6lPBhVGDIJCUZXaR zxds2YUaX0/LkWiORoNUyS1aYZ6NsyFM0R2u5N9c2nD6QTh8rflg5RdkT1O179W1dm3HVn5BqDad 5EPcMFabWGyDT51T7d4O2cJ+l7QPki22haLBgU5lQnjlxOLIcPG4+yhi6FD0ibaJBoK7Bkw909vZ 94pvYe/RgvksG7oRu4srsm0cHjmFhSj1BBy7A/EdJxio7j8O1THQJeRX2Gp1B7A1VQX5sjRQ3q9D ezDt52S3NZh/UBHiCMeICG1VNzknKNCR/Iqxi6rGuETEd9+SNny/blshGqbAg6j2JxVLEbnkAG/G s5rypnpBkO2K3q2zTWrH06/YKRvagO3YarXgyfN9Tczpt5rS0uly0fGkimV7kUaGusJYVxmsuKZp rVB80CEAQG5Yl9zzC8Z2BsFumYbYrzZ/PFri43wyGJZT6IzsPYkwpgCHKz90YnmkrUrMDZxon7K5 TJSzOYF+Z6uOdCYn0K9MUH70OM7wgl7vBDqvXURYFdPD7WIiKpku7FuWkb4XvsfUwuK2y0Exmk6w qwowJcFcVrM90Fk28q0mmY2HX/nJ0LZdkB6C1KGZkVqVyUZYVTdnkplzIZO92h24YVlSZfAxsrSe 0DXNbLet89miPDKLSrdIOXMTRVz2/IZVNMourJJ5NrNAZaRUdHBr3vMQeJZJ20XcWr9+gqp+LJk2 X44XWNgS0wK6Z3QucXRsmgOAijm8ILHEG/U5JVA1goJecmQa+VXwrN23papoQ2ThOus2ZtVaYJ35 2PKsdTuocURb7x24aJnVMlkNPYa8mS/P8l93fwvHw4wrulIViwY6m8R29s/VO9MzRtvD4ypCeWLM IN1iOYZpbS8C9GNv/8pCASIwJibBhbc9O3P69fFvDiMIZhbzbwpRnBS/7v525P9MwzsrqgwD36hk OUL2ZYCqAylaIfNL/LVwhSNy1+d55o0oE6xeJWBB55nuPMg93vTmd4OxQbBxcwRTc1ODZMUnJlk0 zuYLDp+WaP/8Iok211i7srHrQ4pj4r3WwPV4FqKGFpme8YR79nQqxKy3Vyloa86B2ynN3/W4OiZV ZB5jiccJVyoLivwRnxbdgDW0YRWTbHIG8k4x2LVyoSNPhWSiFxmxwC4UNID+eZllBtRAntVhVWV3 I8y6HYAd8CNvhabiY51UOboLT5oLg9K8tpc1xOSwfHF7jys3ogboq/W4znLg0MQ2NOfyYExWlZwV kYbZYA5WgT5HuC5PwsEMzugatsxEBEQx5cm0sJywZN9wk8v3gdo0c9+yGHYE0ED+ymmR4g1h1JNO /TsoLzrmr8p3lDh4CK7eIM28xi8agsY3XxfZIiuukDQCVspDJDVlNqRx8jUAmBy35O1C+R1td6q/ JzfVJlkeS3XxoMxm48EQuxwN4BONUmcssOlwnA1K1tTe6Xyb7Pd3Yy83TD4ssslM04T+GhO+9m8g mV30YV7djCaX2anGA8Db36uE+GgnfmSjuKHB+f5I8XBnQzzLW5HRczgopkVO1CkVUjSJZ4rn93Rz e+4/7scOiyrS2WBxGb65RPkznNbftuim4yvMbQAP2dqcEsTiSc+LlBiAVr5wO1d4xwzKBU0T/nc+ J5LwXMXFmsrmbE4YfHjpJiX/kH10s5KHrjQHDZuuhZn85WqM3+dKY6geK2C3PKlqK7pjuuVM5Ru/ iU0T7nheGBBghN+sl3Dc3JmPAXijj7qZx7VvKmfhTvmVOtVZTjJ173SUFdNJLeASbQ53zADDe1wc Oiip34WHULJL0KfTcdQFN7tpfQy/TR4jb1l6pEs2vCIsru7vGhqtGOUX+aKLbAhH2XCGn1u5dekW Kvjq0/mnR+EiAgXwSEQQ1u+cpOa9aAxiK4lCng80YlQmFuefBRYXkVhEUJf54Qg4ujHfNLOgxxu+ EwOlAayTL/how5eEN0T8d0nxu2Ekz1E4PqYYwv9+/gXi71rfZ/izOnGP0p4tptdkD39NmznnirPr oddo8eXXj+r2eriYTs7A3qubSAzSlP2Fb/0E6MnZnKI9D+A9X+1hAi/2JgIEPh3AvO5zYLLrANqV DySbp36zyWAxxM3/GSmwdhYHOwdxWzCyqZ4vz6azBf6WB/lALJxZOAWfRMmKa5l+IPZRneR9bD3O OiEHB9k3k32ASwVSGN66crcTTUI8Uz6NKc0FG252UQ7oPT/Z4jxwLrtkN0QCdU2lOFvM+TbRV9tE n9fWj1adj+o8WGVO+GyBpr506o2ng9Hg6gIoLFHy629KambjbIJ7GXerUgzzmyJOQgYkFbH/VQqR DlQXqBSkuoi5/I6Mgrnxk7nzzJLpufU7t34br06IPSss4t71IxNV+NPuk/qo4W/u7TKGZuE9tiBO nC6ZxjALuDw1y2gRLGE7XlhADzGM35nT1dyuw5MnOSVjp2RpFjFXDCyRItgso0XwrQSq2ckvQqK2 vIbf0S8iUNK1aZF4c0E2YsxCfpP/qmZdmRPinxAArcE+0nL5VkJvd78O86bpRbFMhzc3BgurnLa6 iHle7dE5QxRo3nTgyw83ycnTZCf5C/vzMNkm/7HGDECxrfxawFwKCkBFN4E/R/yBCrlBTtPfj+i/ HtKMv8lTWj/5jlbjpWU2EYX/xQsVRr/7+md/3SUGUBa4TH3uMj7G+W7ZmN7Ta3klnmIhhG/AN8FA yBdDhhjQfF8MKWP3j/dhjhZ8sWljfwo1W4Y+crIhF90rc+YHkuYX2bVKE98P1Qll3ucRwsSIUqB2 qmuCeO8HD9h5n80QgWefDDjE0hoP5vNEFYqonxnR6PnwkFln6ltbaPI2lQK37NtVXi6Wg3Hyb6TS kYiSl3XgozTXl4MFqcmLVH0R0KOwOhuMUgWYSBiOVRBZo4mFsInOvz1VFRpJoi/9sgM5lRs+vSTa bEwP6tkonYrLIruZZcNFNrJq0qo2kIRFbsvSNtKJQU/Wha4ec9JGo6hshFivuriNoez2CxpUd0zv pezEMeHZdDomwIeD5cXlAp8UQ+pBVUlf89mN60a8x3qVlWfTeZa6UyE6usVefjCWtHnk7lmELZuX +UF5NB+z6tU8bFWT/KuCTIop+0K02h/0QyLd0Xzx6a/iL5T1yaAVXwieB0WMmcDvNqwOpxC5pGpJ Sv7UGdmIlURNlLSTNiEmEeNs/6K2EqxMDZ7Adtv9+lt8S91wRHYsZFkxcAB1rBLpAKvmx76rLnyQ IkX3+8H25ijiIOCjWa2tHGR161YLPl4XIIJ6zQ5ytjKgZtSA8kKyyREBy8DLHl4iR2fOJF8pgXaa LFhDxumPd5p7nyefzs+vR95Haexq+O0dq38a5UBqB9668TdgUUCuESrP0o+p9GDui/QZXWUnTGhx OcgDkRZT/pSdasE/ps+JdXB6Al5eSbiHrKRPz5gtdB+sUTfRBaesOrHQQeNjAdvwOFl4khYKPVk/ gciT2cqHIkLExOYEwfeY/n1iGAgQAP+cKGiV4IS3MABR1kiuFdRb7CqkzTBh7mPzfz6bzmN5RdYN ms9uABxrSz7nU3B5+NGKzaueu8qnUa9d0Wq76yQeUIPhWS6frA6DQrCj/JqJLVS3e1fASj1btrfe yOyERS/fpD++fPUiof86gk9SNQw/TWUPj9fsAXtR8Mya/r6vBg4g/Yk6ss/zCzN3RajWyq9TuhlZ V5tSAQXS3LiLdJ3LS5hOmgJjIJKx+jWGK6swOWhw+IGvRnP0clK2qj7E24u+1+JsZB/1woCQW/TG cLy5r1SCM/Zsm7rgw2eEn7jxWzciWyz5ffbrnspswA5gaJ6oNKWeYrpxEpdpq+cRQ0rmDiKG2pRn FdNw5Q081t1PKdUoRq5ZC4rIrhEFh9+6RXIaRDDWBalwZYRlH/hqfEGciSR5VsNweHctkdKr6Iad MhXLiZjZn56/ef239M1/E8NspwtKXr+h/zFLfvje/P3zi5+7LVDy4ue3p/9IX75++8sprPjjL69e pW9+ObWKX7569eKnZ6/c+i9fP3/z89tXL05fyG9Iqx9evH/+7uXb0zfvzKanL969Jp9fvHv35p3I VemM9uX79NWz96d0yDc7Ozs9A8JPr9+8e8Hbv5c1+gKSSjbJiErYnl5KRgrZbRPnCz27y0bp9Oyf 2XDhfCUWaDEXDZH4T17pfEijP5EeaRCoDxHyreJ9IL7xNDNZb4GwUutLGJwLRpyMbrEzS/avzpF3 iPRiYmicIAWQiuLn3+mF8HBDb6ec+CHqRgQNBugvA3Wj3v5ZgeYVE7lGtysBkxMemGZOcfLnghjc gvJ2NPMKJGiAih4+dihRObjfl1n5UQzNDJewrzBs1UAsmrZgIYkrPvDV+tBC4u31ctJR5V6Z1fqD C2lrOdEoFPn3kVMBzL6qCMrcBgIlVVn8hgl5uQB1FqPGlF0EID0c+WW6kbkVE94skOqSqGfhguWY mgExk+mI+j3EIbKyDTPulZG1zsvpJOX1dOFimqqmQPLToBOTKnKKxX1u+7MmlyJUS6MzyQtCiIyO imIBMu8ObjwfdIvFFK1Pi1swa/IiO6fhBc4EeWkvuclZf8QIXS7OlvzsEv+U0QAI0D97adooyYsr 6nuiMeN6NuBn/k4LTXMlqK/NXJkiZea1f1utKsZjv448ObTVpJ5POQeq8DRKmDnC1Vw3pan6bgbF exUSn4Xk19+oza6XPTPZI3YaetNJ9zjIYqFDoAwP0jerrVCoalKFstwnDaeTs7zgKXUJgrnE38xN 91O6cmJG3nbNrIQEyHL9/IgCSjwuyJvwygmifEm7cW6SWluRQWl4UZQHcxUgkM9oSF0+XhDpczVI xznLx0VaDuXPI+gc8w65t78TGjPwWv1zOZkRbrIdWcyh8jgIxFCotB3Il92CXUwG5YesNDJX69It oaASx5W2lc6ZCNQyi+3HaZrT4ITyLB5kH8TWzohHk7NsAmJjJAunH7rG79mgXOSDsVmYleW0NIuK KV2CQrDBgYoKrBtlZshWIxp6CkxuXZ+ZG0mComyCmKYsYR0Ko+ZbVoa0r/vqmhlt/Clbb3VXsHZV RLBsXGMCiLi6zM8bmgR3IlYbzVojyotGBrMGQ5nbBePXynC2uquymG4G2KwjTUCLeFlBfrAL3v6F jTQbjK8HH+dCktRsO86Ki8Wlb87qzUOA8sIk82FBDeEgJjysQxsszPAhzHaElBKpJgxFAOk6J9pe Wcj6bgP5xB4IEPnw3A8Zjw12P9DTcecLfyUi8Anrh3/BOiIqCwdGP3Cj3fowH1x5+j8bDD8sZ+Ib 2kwCNEx0+lGmHrQ/jAfzhf6KzJv8w+iQv4dARvBr7zcYC6QNCIITm6+rxeCM7hHtyWQaXR0d6M2K 2AluJfa0WqWC1FappJouNmfTLndgG/Ooi+EkmqWS4GIzZk+fLjbmzqkvwWD2EP9jbn8XNhEBRNeQ omROFqHen4oEqEfwOIQmTyN/yuTATo60dLgsyayPl5OCP+wDXvjj06may6Mckx0YAyr7j+DIXyCh jzA+ChlqxmGLxhBlyy3Nl8Z3JSQkAyqnsiQJ3TToKSP6m+x3R/1fe49ASmXqpU22ifWsi4Qf6Df1 CpTDzulsTJ+NUne4kK/sVz/tpfRkt0iPYusSeRhfmVioKaP23l6Mua6fvEjTfMrX0XmhUw4Mp9MP eea771OcfVxk846TzdqCytcVBtZ2HQVzdyLZFdyuhTtjSnNzffD0Kdlsix3qyftE150jDM5wTMM5 XUAd51ERTT5eQ/xcFkPmdjFS9kKqiNrit6+6HI+ozX/6KiukRW3xG1T3HJqCQdC8H6MjWaqw3WJ/ qXKJFs0t+UGVqv632F/MWcHWL8OGVJCoGAev3iqJp6G53WJVqAi0E2dCuAXNK4Q3Y3NL/9AJdeiz UnS4FUzpsJh3ICkhyty8kyfjbcAFuJQIJrKSz8c0qFSLe88VY1I7uub0ygXLz6XcFvroPhYb0KJW bRwr/t28XLrnpCozxBocK4F0kS2GECah/sxHGlJptqTVhcu6m0S3O+eZ+OOrUy9CqIGDGFlb/C08 ootD7VoI55/Tdoy/w9OhG/DrpBFN1IgW5ceqJtTBWmfurs7nw0Fh0BW8AG5uT+CHwL1o6DlzLtAH hnd1PivJ39Yc46jEYGKhgvQMFCid/sGocBZsV1dCAIDWc7IKrObyuNFtrhFQthgFQfiP/DaBqCrg cBsbiQ2IqNwQIG/CasZoZZZJY3pAxLOP2Vq2jOHC4DpGGoAmRCDAxAU0aKmOWKAmqN2h1C3UELVy cYbtY4cnr2PWh9okJiswZr01ch2zSJCkBCHdWnOhXLsrhc9meLGY7HUdxV88DP/RurGt1gt7YLDU vJ0u5K80NZ5qWTNOVQW9JTL2zcBDh7IlMKatt3vQdBCriP4ndcgoJ0Yg6jrRzIq2YoL5BLJt15FT xtxNdiFR0UhigjKbEFPFTQHB9t12+kSjHZ6Wj2zG3T1QkV17sjdw7BaTGdezbhbGnordXC8E3OiI pkj0PgHCkSY1yQBBqpVg+gleGz6NMLeGcdDMMER3mcDOJvQoL13qz85v6iceNhIt0Q1P0pYCkMi4 bDDxMcb5Odm+XwZrI/VTbqBRWzDY0MWL4O3Jv2HM/DlNVhJM9yg5HhfegYZU780xcoiey2zNvqt7 97WzdVaCkZU+E9drcJExUtMltsEBIyrPoPaa3a9O8Uiau/w54kyi89EgMUjZPILJ+S5d+3Yg5oOL fCi39K3qgLv6g0+CjgJRMEflrhjChCgkRgn1KruZ1CuSMAZQCpBmxObzgOdmool+psMKr4iM17OS lP1vRu/GVmRaIh1o4eYwhy/LnF9wEpBXq8H0p2WT8+tNRoaN6pzeBG8ICeM9IyflutU3vW5qUKBa ZUiD3o9uXel/Pi0nA2KNP3z40KcS1S5iLShzCSY+d9oKHcIer4Lk6kaAb0VsgRKejd0z6qsaxEPh ht7CuArTdHMDNCe2CGOhFsRkcON/3ityrisNQV6ZR6FxvNK0m+x2k71OxyFfI5gnzUxtnbHsdDpI ovqrgcUPVp7BRRlmCf/4mkO+L5E3fODViLfqq/rzyXo8Q1DdtVFdFdG7QNPkhZFE1G+RWUi0Psnk 18ezIWKZilV47urp1TUVonAWrgekGsq8Kdwt5Rog2cqqZ31uY1gZzGbJ/GiqN4hLz4PLqpOX3C36 fahx4Krhp3l+89XMIDoMW7pWZToyT2JSu2qU98UFD5ph/dgDXcnHYx1gRqEX3cZ+2IbTTDQMk40h BkYU1ZvTXz0ALrJu+9BDPPS4KJqF6EGRhHodOSzx9gDNguwzCUWi227ATYKkb3bhg5GHOwpv6Os6 a9TjS3Ovq3dv91EjzjQYcUQ6HGXj3OO6oPvgkI0X9F4U+mUQ0kG+iHhTI4poziiaGEMzI4icdGwE LMPV6gPw4N9qkkWldJpX6MWVVqACDtZffe1bc2SmVELGNQ/lEeeKM04+m6EG5zRaCnWkuu8u+l7L VH60buRwLRRYrJb7fNMquFQiU00MS+OvjMnK5MGog7BiI8itMHn2pijLPtgK13gqaXp+rmI1L7Ni iB63qvrni4wedlWfw7Hhl9l1XgRtLZrp5KARXaVGO3WHq9PWRI1WVmeDndY4R6Sp+GkcTsATLSIE LMaYzoNOQhq2bQDWA+PMpqFSUGYAjMpg1RR96cEWSmGR0idIYyeAiRPZhel7cofTGNb3UFkGI1fQ 2SUzPj5NaBDlHHqjlr3rWJbRh9Ys3DG2Lo91jGFMA5m6uyyKVP02FLm6Oy2G5kzGcFYoV+upx7Rg gSWKtew3H1kWVFKN1KL76F9/s/YZaSSM1AFirX92UaTO1pI1iCaVdaQ4w8/0xRuXUYeU0KypDrFw H8pk+ZhHgRAVq/5ynpXB+iKGfEovVNELLuZzu7w0le5Gs7K11kVpUMPWd6Ah2Fw1hs7Khz0Bz9vc 70Pgz27rCONoNWfEJUfs5XlHMP45ZBDs762psCofq6EZQnn+1CePKxOJ+p+q4Xf4wYMvMuoPPBoj 5K5RTVzeACWZ+bwEl6BGCYtQMkronsIuEMn0YJFZQCWGiTLjXbNoaQGmGx7rYZvByCpwADPHo1ki rrKAAgdhagsYBepaDHhFZ2j/JqvFKjKgzhxyuqO2By2cW1bR3Hwzh4YtmiUy844uoQaw8SaITRce wGCVXNlFLsZzB5KILLSKCEqwhG9GYckVwgRXSJHCgT2UU7nAqt/JkUe3JjLOsK6QEqylJEjcYysu CPDRwQJ+C30KAtUIfpt43xmqSpLcXylF8wURsDpD85OD1Vrvrtbx9ig7HyzHC5Ai+vF6UHZXyigz I1CI5DJygT5ZBwoefT0fXmZ4J04NHMAin2RGCs4dX3sZke0LAbcx2XscrAbS1rAymq1lMFGZlkQS Lv6lzKdENH+UT1fYWa6NB+6nhXgVj+Y3OC862nNDz7O6+qLfZT4epV47CSTh0m2csJZbLF+RQ7HQ PUE+Qqqd6PDZ4XM+4slqc2BWu5Rim0L6B+K9dOBf+OCH4IZBEpTZH0v2MIoFllNvNh3nw4+VbqeY MVYOz4dLRcuPeTYeBYLjjT4UI9L4Hulipa80kLLLSa32eVG3PdlPUxAsy9vVYOybSbqe57NsyBK2 GSBv4epeSQT1V5UhsgKWor65NPW7TzzdqnXoEV02/s7rBSYg+qLQQWCEciYmKrX2YkKWy/BI/5rw tCni1+V0WcKPo8FH+HMK637MBrDutVn3o/kzn4/mIgWDcqqS4ovJYnp+7uZ9JJ/+l4hPvnUzs2Hl dIAlZSw7F55iuFwz55GvgkgRLl7Qkgs+v8iusoJfUNrfreadoUhMwf4bWLy0acoRSNriB10WdCho A/FS6Sg/Pzca8Ta9bmL83qmOjmDUlZdMTKwmH3gXilsYat67wMI3T2oL1KojEMM+/zW2/5bA5qjD t3tnwdNkUm/Gx7DSSVpVtJdNUPR1ZDMVB61LFoWBU5BfkPb0XZhxHRBeHNISAwHpS6FVHLzGTk1g IE3gUQcVk0sG86FJzeBCsTyFdaYB7xcO3j8C/+Bjbje4SK9H8qgbFWavBOL/0g3sr/3frBBboknG +cWlvlgJjvEoFlpTmFf1NDjLJ7f4X2IyopFTMLrT26vZp2Ef+aabHghZF78e96rVC1AbF5MKAe02 YcsnrhUb8EcqpqUxSLV7J1qhmJCKQTGdj7Ns5jIusAnL7PclYQ+a7jj33wdDG04GecEy4/kmj+tl YqUSBiQKiv4SFir/4jFTy8BBgQIplF4szADFebt5GGSAgrhKcToA04F3AXeYrRr7I2s24/SAOZHV 5B7OlgLrpG1sM/RYtvRgAqdOTGClQ7KFWPiI3arCXhqIlmzLrgLyV3SMys/AXo+3ko//SRix7RRT OQ2jp9uabG13WwNhlnQIUBWAKYNQMaCLwIDQDjjQoEdCQaYpg8plUUFmmgetXy20RbzniGZG1Df/ EROL10GOfdmLeFbPjx7X67kM27SsiyqZa1sZ5E+ixWdI7ord3vq7eWxTTDMGDsbBh3l0FXdP73MQ 5hdkfRhQ97xQ5U5793G451sIplGnBsNZ1KNpNebm22cb65KmN5vP8sLobr+JiTZmCTx2vrI7Wr1N 9Pb0r+9ePPshfU7+ffoi/T9vXr5+9v2rF+ztI+vbDy9Onz3/64sfuIPBgfDy9V9fvHt5mr6ndYz2 L/7+9tXL5/KTp/n752/evkjf/+P9qXjdyfzw9t2b5y/ev/c0/vmX0xd/T09f/vzih/T1267z5d2L 57+8e//yby/Qr+zRJYLa8/9GPz/74dnbU96W4uVWeP3m3c/PXiVP66PjtIlF1GlYMYYfXvz47JdX p04zjjpP0dm1vv347P0pAea0MeiBToeYLPLfl38jnGNMp/z2/q/P3klmcCG8+59Xb8hQ3r578eOL dyktIv8xB2ZW+R/CepFV3rz2UVnUF8Qyx+7pjuJPH27cWXdFyqyIojilIQEFzVrLbq2beezL6XKR Fxl8IieBJx36jZThoBhmYyoEYbJWvA/msi+zqyP7/TIlB569fv7iVfoCkRD8yw8v39NPbFJ9rX+g 9HtnSQjx7dn7f7x+/td3b16/+YWvdPrwQX9tWQeCl+TAhVErfzu25mUZFRAk29O9ngOEFgah8Blr 8wdeyoU7rRGtzR7tQy4xdD1M+dc8G59XnJ3IqmTXSXfFGgYjD/mz103cwr4/skcBvMkXMCh7QSzP an9sMeWPf6N5fyTof07p6YyJlTwD3JIophxQ6PqRhDDKFoPhpQ0xfN3K4Ame8dRlE/pXJeVZdfZW xfTjekDm9EILHQpLN+6DFZ+bX15iUSDj0Liw0PAvo/robK2AjzwIFQes663m+HNRCTUeWvgk1aYx HFO1pIrHohYJwkNPok7A8cliR9NeHjYOsGuAv7DAN0e4BGJmB5rXxJIQIS8uyUabI7v+SlYvkDGg 0SxmItEgrQLEkjjWZJnpLKtiFlapLq8wuM0YAqYYg24Hhpj/ipk12IvloBxxp/R6fKFvc0qI0ZwB cGiMLeRsoXcSNYrocWGQOWgI0WA0Ktell0oAJgHGy2qNQuPkUnaP4ciSGIYOV73E8q8khwQ1HmwV rWrxmUCn0QUYJFidB2hdCO7YIqjd6FJekcR3uZQ1iuFjGokFwZEhUsxcoz/GXPaA9ZiFDDLZYmUL sZGoGSwXGS8XpYYuYlFcSe3ED2hlK88zKEKe4bIss4KaYFHb07nViE/JOLvKxnH7NG8coaf+hOxJ b6yNHS+zychKo2MoDVj115foLm5TyKs6W0swDPZnJBxxz2dtOHWABLDJJ9nIC6r29FSf49aQf0QI nbGYh9jB8MtQ0UQJgELcERanxXMO7phYDxyNc55fDkpsP2FArrOVWHX/jgpFjl2NIc3BkAJEqr1Z QzGJQIa6gcOYiA4+5MUoTg8Z88fhNyTPKreDDMkoCU/wGVmsz4psiLSwajLs0dE2tQfHu4pbIaym s9Y0/vSvOCD8+HU9GGfldDAaDuaLODBeONeDRmYjQsDHrBLeP9UbDeEVi1wUnIaUj0/3+AiCKAyT 2aPZF1cX6wALKQsIt3UHqmJ1TaEwxRSFS5667nmfmkBxKa95TJcx36LQHh8vrkbHnhnebgVVEMke Al2H04xhsL9jQZWWIbk6JGIj1wUWgkZlVRBe/dlq2NStZ+0K3K/LBuldF1gVvYPwvkx629uLShIF gCH6wl7wNVYxrjPWBRjSGybsGs+Ur7PNWEN7AHwx/YGRqi5iKyFDaExNc+aUq9IAK1JrVmbnNemj UGqYPhYm3yaPegcbCFihYYXW4qJFerUymWNNWtQOjkF2FpoLvBMFyBQnq0JxHEqrArLlWxUcFNLZ oCzzzJZtstRevqI8gpXsxSFarrJVlrtk9Zy4iP6aLvEnHbHhOTxgjFD8iASG6AJndI7srgDnw291 iCFtYAGvIRjW0weRCqFiZJhCQMlVG7W66Fg7/SqeIvJz/9EG5OeH7KMT9EfLGB7kj0o6qNhLxobq sSgdq1cpkGh38naKiQLDIOaggxqG+Xk+RAHE78fkUe1sym59+yP2tuBxU6hvawoPNjGF02IIKEd/ 8dljf5GBEeEwDtBATSAVS1aoZSf2WJCH04roNRE7Qn8o/+R0PELiz4LQuNdU3M4kf0NY9He1G4GB cSI0gwkUZVXCzLK5+6Dlfu9JQ/PI33i1w45n7PXF6qBk/leUqPKHSMc3x7LFuG97O4OZzpodC+eI 7CYbLheZnfpuZ+MTQ2QVey2t0elpZJKCU0WI86i3WeJMZ0w7T8tsI9TxT3wrcG4OL306Qdnhq5r6 EnrMBdFVEr7IS2RuYq0VGNkF5tsz5ReTwfyDlK2X0+u4y7o05Ta97+Zmv8+uKcAqKJ7WRJzT1p0q MyEfu7JcBSoS635qsft+Ixfa9g92NqCzB4vzaSnyvLAVT/bLM2I9Sr1bfcGhzeNiMrqPqdOG5Qjz qXdMFVK6p9PFJTVOWcmcuQucsBB2bfFgvbx0fTRF3rLI54uRzn7XP/BW2LVvBPYePwpU9l2RnM7z m3Q6Axn3eo/3vXBYSkHvHdGsuMrLaTEhMzUHY9iNqevF8HrKQzsBwL0YgILABzvBwZAaT55EkW2d 3Fb9nSos+ns7ASz0A/VkZc3Y5k3+IS0TXWVOhPY4K2i6IfkXS56xv1PNS+zRu+EwmyPPVrAXiBNt pAbcJtkyH60ChiZAjMBSJt0f8xcL4FNyIHk/EcD+3PI0zVk/sieWxJ31RdO9W73pRPbB/pxEDfNM g/Ik9RHxkfxZD92ttHroq7Tg0YezjwtPJg4JSDzO4b6854EYRmtWBy93anzJ9RX4utgGMk5ZPVvp CSIYzhizyQTBUQdycNmsE5w5Tgyb+1YjR3Xnjo2Z690p/XuUzX/t/2aRcT9iNRmuycF4UE6StuWu nGf00Nt6l8JNI1AFXKRuqQZuDDZNl6IKoc1SIGgUyswdiVUqU+dVRLkuVYYfo/XShxichMFynlXl XxoSAxdJ809TPTOURe4WUiljj8NeiIILsguryotzLoBDDqwA6FcQ48YxNckwypFcHrOBc2/THB9r hQllsklxrBiEBdVza8Nr8HCBuTBDlwBU+5THMi9SghFTmBWxyaqh1W9gBkbLmU8BmbX6cMrlX/1A KjTStbDFjuwvutw2GMhO9yrDp6xrP61B9/tXv/6GSji7Kulx9utvoXc1ZNd6kJ7ufLArmJHBrzcy P5NSYGMvnexSAq3iWVcGr1lwVzPfso4arIPdzC8lotAzkqzlQzXTZB2H9oTiirp28C7ncVfSffsY guw5XcpgH/Ooqt4uT6Egc7amb5+nr16+/u/052d/Z7kTeBH5RbMnvHltlb18/faXU1D2+tnPL6ym b5+d/tUuevn2Rfr9Lz+Coud/ffM/r9N3L96fvnv5/FTkbRAw36Sn7355/RwU/U2kgABFNKdD+vIN KHnmFr199/KNWfKeZtsg2JnY0Lc03r/8fy++f3n6HhS/e0HgvX7+Lv07Tc5BK1gfKUm8316+9n5j 5c9evfwJ0vfZq1dvnrPatK0x1J/lFLVkplxzEt+T1u9+glR/T0n88tUPdtmr/05Pn/83KHn907s3 v7x9b9V78/bFa6uIzNSLZz9bhaf/z+YAUvh/3nyfPn/z+vTdm1ew/bO/vfghffnDe1BGIL6i+WzI qH96/ewV/ESn7t3L03/w7D6/EAL8BPsljd7B6jDHB5hxDYiQ9Qfzg2zhfvmRfgK/f3729i2pw7gE Fr/4mSZvcUvSd89e//TCLH/z7h80Sc3pi+enL/WyYt/ev3/20wuybt6/Nwf5/gXp+K9v3hmd8gQ3 EuKb7/8PAWgQgnD8q5fvSSfWrDxDS9gK+eHFq9Nn1kdS9uwfjMzWh5//L8YdpJSBMkv/RibJHO1b MlSxIDQXnJLpt7ntxc/pa/Kv90j53569+sXmOQLh//7ywimGAwA9fk/+9+y9XZmU/vDyZ7fw/fNn r5C6VHS9dhbdm1ev0v958fKnv57aqL/4v7+8/BtZgWSe7S9/f/sufU1koVVOmN7u992L9Idf3jor /dk7DhesRvW1j0xDPyVDePn6B6vohxd/M0p+fPPuFC8kAtoofP8/Tj2yEgjdfnjxI0Tm7cuXXeNX +vdTu4TK6BenVuHL16cv3r12it+8N1oT6hvM8oqsDlDwC+fQl28gpuQXLUye+qtABIQg9H394ad3 zkeCJGEMY5mq4ldoMYRwKjHsQhbmKY5gW5nY7NmPL9Ifif6kcgZ+/+nF6U/v0ndCwxgMRD69/R/8 06s3PxFFhkj5UyKbsWKOxQ9Us//y/PTNu5SmtHpmIyOq/feLf7zHAbw/fUY19cvX7icxdLzds9PT d7zxsx9+eBf6DvWy/l6hd3QlmZnO81XIeuwrzFQG18Zr8enNu/dUf/7YxT+9ef3KkKh/JSRkYhWK 9r/hxacv/v7SljJvtUBSZX9nIt6VG7z8789/8X775fXLvzuFz9/94+2pU/ri9V/Tl70DF8b7v/5s CjAq4FLCRj9b8goTbL+8feGO5O9vf+p3kcJdrHAPtmddf29MMytyJbDFrEQiWJVYiVHn1RuiQEzg //Pm3Q9W0c/fp68chfv6/714Z1gzyNp9j2D6HkH1/V/f2bjyIqPWLwi0X9xR/sIGZZWBHvQIXlGj 1RrVq/QVsZ2cwp/fu2WvnZL3L06dMsLxpzZzf//+Ufry1dvdfvrmxx93DcYwPn3/8if726u3+3v0 0/6e+4VU160stnr14qdnz//hcJs0gL0fgJzXq/iHv718T62/l69/hCzw/bN3716aZjG1ciCbMuqm 7395+5Yoce+H9J2xZaAWLVel5lp7TvaCJu4y757zgdgGL5+/MK1sUfb+7YvnL398+dz/xUDnR2L7 /vQzxP3HlwYV6GbT+EpsNyr0X37/y6khDNkXOjhTxLNikDBUrEGyszglewVBD/jlFzJRUqobFunr n169QD4QK4EscqtXkYtSJICkXRiw3hIdbBe+e/ETMRztAkQmvv/rC9MscjZb798++x+jBeGCZz+8 pBbUOwIP0c7eCpxy6Q/PTp9ZzGd9MWaVssubXwxT6PQfb0P7nF9Izynfu+KlBvx++vb79/bv9Nnz 529+eX1qzgT/RI3X0xdOsdisOeWn754ZTEG37G/evEW30C4eLMHq2zdElsJl/rd9j5CCH0wRRb6g AoqV4+Lpr29oOlbEjiMjemH/Tl/87QUR+GSJnJpcwT4iBhErJyak8ls4rovn75nHCOzPSMmrHwlR fnz17Kf3xCrv7ezsdM1vr35gH+3Sl9+7Ra9PkaqERM/xYhQyLXdgs0INHWBv6xcwlJ4xFKei27tb xUQE+e6O2NFq7ujdKlW4sDohZHgFDzaaTT24gAoeTGANBA/jsxcLvSi8eIAqXkxgHRQXowLkGrUI yLbv79aad1FCa7lY4dVMxDx1XEq5FVFq4dVicEOo5qsUwC7EUVilAGZ+zsKrBLEKcRheLYiZn9N8 lTBuI7X+5+UPp38FHniyHfvbeyGnv00e7fQqIrbs53joAQ89aPAd/fBjD3oMgR70KTjnGpB9SFjd eP5xDpuaDSpfzzFfVqOA5osSwtIHTuYJ7DgrPAc/8k1GeikoD70rCSt6aqJ1L8oZFmT/aHc/JhRJ vuTCIOWj0FOZWN/hFs6zTGiTLkCDfrbv7fTjQszmAVoc7MTTgt6H8ZDfpcC8igA6CkQ2WVZwgaqY VdW8kDUvYitmFxWMJV4uYRERc3VSSV8NBPESY0K70IEya51OsskZf3tVxVlUs8eS01OGaiyDiM7p s1JWi3KZG1EkWSWIrLpPu4ng4cC4bCytFuUFx1L+zipBZNV9OvypY6Qrq14F6pqPuS0+8tiRcJwh e9WHV01LLA7CFJ/klytBAah8TuT2R2+ndrfz8XRRyebjvPiAhAGU04kbBrCY+nGbf5ysBQrCoqGA ODAj9SGM8jBf9vNE6AX0FIwkK/C+vVqXoTypGRclWW4xVNqrMmRoMZzbdU2tUc5Sn+hVcUzj6QXN 4l8t/VhFyrZmeLGOg6Rc7df4YsWK7qqI+W3yuL9fK8aevpMFY+udWwO6ghPP77zAjtTlmJJS9uIH va5X3YaOmZTlxcghBSmWr2+ZpeR//I2TR3HwebF6JLu8GMpVwCnMw3Wuuon1itfltKQN5x3+7sde oLdbNh2Pq64quCxzOZ0vuFz08AzCLjbDaBh4eHvcIhaAqLYAz3PmQZFJ30+Y0rcc6wzB7BO2r42+ gczV5aC4WM4q0rSW2dX0Q4aHcVVEHpdTUgnE8TIGkZdj54PJbJzJ23VmiCUqXFUNGa1vxwcPB+Pg bbvBkAjvCJnryLPlPCvnl9kYuWMLg86yYhRZcx6E6QR7DrLJVMXuFlMW6qo2alN2HSHI8kPyabqo ozrU0GcD7BYImdnJbBHC+Xz+sRgGzAhnO3mhV5OXHTntGOBq3TIbXGQ89bVZt/phV6gOy2UxRJ8s lFGM8nYCWWsXJjW/TQ5idoawG3pHINCRiPp3u7KJr9HGbtegqD7qxaF6DnHFb9Pg+NlicDE4G6MT xNDZj6TcmbqcSJWSk7ffTocwZ/XVNSyaDGK8GFh9Hzyu7ttwgwzoKgY6gJQVUyea9dvkyc7juFHR m7uIU2Y4sefRgt+rA9+cQLsHPZdWH7sHkYwyGiwGhhTIx6Ns7lcZwsIoP84QUUXTYzgW/nwwXuDy S8hjAUxthWCOpWxE34P1CiYua64HZxoX5L0uvvNAPiymmA6be69nuXQgf09ycCHAulXz5GA3bh4+ 65u87C7uk/Xv4qoLlHZqkwv4+8ipJpKQ6Hq8wK0oU8DqmqJEzt63s3JwMRkk19nggwEe/6LT2fi/ 81wz+HeQzwWvMK+qIHrHP+p07qHvIstXqArP30Wl6uP1Znm3RcP48yHhaVIzo6zd0pMxGC7yqyyV tix7tlDU54tT3lqwGyzK5KlKXpHcN4lDX1zkFwTwlveeJjtHjIf39g42OTyeOcfmUrJ1JP/tyoVG MxqpVcYokJ/DRppGHX7rRQzNTM/DQTJYdPjZeJ7Byts9OuAgsjBTk7UAky0mxwXCo8W0BOmXGMoW ThAWa8raRKFAa7oI6P63yAzSPgWd2C+EKkbSJtZ6ByXMThxSIn0UgpZ3/LINrYN0wgcD+jFSPcV2 dGENs5rG84pupHfAIHYEeWnNys7hcxOOSE62eN7wFdYAhMuBrDbX1rMazaOoQK+PpUyx2DySEnIF jsSYWcEE0NkX6ibzIJ/zqbIc6P5/PhsQ2UesJy4PpPJnJj0x6bLBhFjER+ALYdJRzsxw/pnadUct tMK1p8b5bMrvDw9TXoP8Niq480HrUooetWA9GkXHPtGdIv8kkxqlOemDmrlzFQUkW3FfDLv7nPLX hVv8OSDGLlJdyq9J+j49m07Hg/HsckA05s7Nzs5O76iqySgbysr9ysrn+U02ktX3KqtfZjey8kFl ZXbDm76dwFv0dipbjLPzhajdr649HcrKe9WVy/ziUlY/qK4+H+bE5GYSkrXp7US0uZxenw3mGW/R j2zB0gnyJnvRTea8wUFMgw/57JrXp5FmlfXJjmZxtjxnDfpRDWazrBzKce/FNBmM/rmcL87ZE1Jy upN/ibkRf0SwCyU2BLLTF233JJAILj0fTwcQFUIk2XjvqFW9QAcjIt9E08rOsum5qh2xOAf5WFWP QWYwm8ViQq27SDTO8kKhULnkBWNWL97lQvBkZVXm/BL8eMQDeJj5/8ijgZi+oZLenzRKVh1e052+ PGry7idkNU8mJ1WNZpGvBsZr7bKMhFV1bEWZJMt5ThTk4SHPNLc4AkW0kVUyYSrGaAO/U3VJW8Gy yQe7xP49mA/tIqfgYmKXkL4HY7uQKE2BAJ3SR/2KCeAnVO4MsM/6zNBJUKO+r5yealBeGBn4vBiA Q7RmMmHtPQl1Rb3I/sFqs2ZyxjKsEoNG/cUODHcCreXjChNwHMCPWtVPVptardfD+XD2MWmrAsMz R9P/hlL78GWPt52XQyxQC/ZcrNx1dd9GeidvbniDDoPFJ6PDql03RQdqy1ASTEAOCgBy3utiPc37 FkTkvGi2LDNxXGT2VdTuLDCUcMfOMIkBUn+oAboVK0H0T2vA9Q06TlM9lnTcVN+MqZjQFwfj06Ev +zlDoNgEBjC9Vxgdd3Kn4/E6M2uF2xKIN+c0O5ZnhfUC2diCS7PfTWJOOPREk3E1R+MKmpo0YP1T KtD+157b+KlFRCVL5oT1GTy0ngzGBLgtDQzhf1micMmnrvpNf64i8WBH5WZ68o6qWHp4ppHO9CIZ zmeFf1zoWvhnNlzU69fptW6nNFXnbLHuHM7Yyfidd8ui/hHol4OP7C1xtOsiy0bjbDV1CTsn//t0 nS+mH7wCeFW7bJSN84m/sWpkhbl6nuDSLDnOihUkFEYBDbPwAgVKZDK4oREI60qNSTbxiShDZgxX N8egwqbdeQynCDVbS8eugqNJF/92JWAHrGUJYGhMpjSL35oWs2+M88zcigTmHDfDDGizVUm2zsya lvI180klZ4vptQqvGfojVa+Hi+kZQZm3ClYlO3L+6pPEVW/WafTHPGhTTc5KjhE+wNn1sNKwRILt 51GJcU08w/KMYDk505E1Zl/QgojrzXjpKdQzdX2UhthbebiRGDjz00jvcX3TdOCP/R4dG7U54525 12cQ5TJQOUy9DgNCgACc2Hl11RnjqTnKVKN63o47wN5duPNiHfLXoH8xGYYAGSNdYzqKlecjZkJi BlBcx09cnZkzBft1Plpcxol2avDy2hVGl9dBM5ouz8ZZwozXUZV5U8z8j9N5SJsVI8cWlX2zszHe 9fkaXUf3DON84bjHaw28/vDdSHmOxnpYBDGQEbL0TBOfDHXzwkRqOV6fNnXxw8wk+vbSIiM4Tos0 Nehn4vt7A+iuhSmKqElci8K/N0XhCORjoXi5JX4mxo1wzh3PxXjc6GQ0NBue6aDnhDuV1hi4xMDn JR1vWNzBaal6l6vag+8KJjGQZSMjaXiuwMjDo4tYRnLCGhzn2mNcb3yetacmtOEZbXQNVo7eEUCm iSUGOVp/iBWLLxoxbn8JvM7XxqsptKB9JpfAqCnGWJMZqs74fHOughWb4e4o8Yu/zILPfbP4rY8e zgMNU7F5gwl5ZcerhRsfzPoDgeLNO6AYvVxjbPUEcJPCPHK4tRT1Rji0uVGvMeJq1R0Ye715kaJ2 La3vUG5tHFbiMYfuqzd3popGNB5U2v/ggNI55mBRW+iZTDmsOuEZzoo64KoPQsz77tf5iF2qYlch 6J35mWTZyXQUeMnx/HpWkv+ew7bQ1cfuZXhmIbxmz6flZLDgd8CtMzorakxj0Ai8uQLoO1uudvCv g4qRYKSKvj4Gj0LA2/aiWA7TqwHLnsbz14RJdlVvDlrrdGv028Rc3QWtrDUzHw6KVZZMUytG9d/Q gomCN29+TM5iCRJ2nbXaamyl1KF9q6FO15uhO6CQczB/Th9zHMKZ5OsCOWAQLSIatLAm9HQrkEBT 4jNbLuC5PDvbTuKxq928hQFguBoBehXRFoyM3iPJ67nKgRSKl/IKKW/wM6PWvIrdrnF+i+7QotCy ECygjvKqaYyzhLh2m41q8x8dpm7sTcNkMHlkbzhHgsZ1eAtjrpVA4UzqAVVh43JmRdquwLUNsK8x Lyvw8QoMjZ3DsxtVMfbNZHDjzfy2tp2jW6t7RHa+HmuztH8QOCxh98MeRdwPI3CeVN7j89+rA9ej aJe93d01gHEmN+7gsfgxeAWOL2mnZG6UsGXilJh16IbMLOCWrlnG1LpxU8/uXool41Igi2KySuyR iDg2q4jHuMBCZzBSCBg3AxHs5y72QoTDoits4FfIyK+wPq6QTq6wem41EeRmFtHrYHbJZGaXTMdj u2j20S6ZzwqryLm8yeOGrZLCRaFwcSjcHnk8j1XoYrGYjpySc6fkg1MydkqWdhG9LGIWLaYmgXnc r1NkjUVEu9pl88wkjDvNcpatqbgsWZHI8CHEI/Vg8Y9S9m7RcCIj8JVasn/ITByiMk+FOBzMF8eG uN06obHEHeaw6RwltxYS9PaAHwv6FaJBY3vhz76NCWsQRGXeY7iQpi4yZZAkZS2alGsQhSgXPxrk Yy2S0PorUoRHv/tQ4V/9FLF9cRop0TKGOl3WmiJ2K/13WlOxXVY6vLkx9RU/x3FXKrZUxyzXjU/5 qQ4QqM63sf+b6OfbZG8/9r6/m16GpW7JJrMx0ezH9FI0S+Wbvqea/vSEGTDDMc26SsGwnzxxy2x5 Ns6Hhy1h4qjr1LyheOY8g7lciAS5IkWHooVKZJOkP6cinw03jXRL+mm+kO1Fj241BZEUkC0wn3bF GBwGZ0KZCNBoYfZIfnRIY9aKvgwrG8vmlA7tzqHAuq2G0e5Q3qKtDICkmEC7NVqDoVMY3cTBQHQM gIj2ql/W0ujR6Gc6y8oBTTkG8EMIQ+luInffAvDgqY2uoA79/eApLzqSILcWl/m8AuJ2COJ2DEQb RQeeqPCHsr9pK2pWtxm4zlFLG+ILPQpVqrLsLWRZqP/tNfvfrtM/TXtk9f/0KRd6nNpUYk7nYrIl IuaUJ0+f8loPHRZAwN+rDf6eF7wilFzFP9N6+SKfFhH8CVYubOjnJsVMt6zZrZmpio7nWG1qThI8 75Vd6xpWu8VS66t8X9P5+fWoKtEKl9HLYrjIbugVRpDff69Gk1AXvBY9EiUDIgp3Dvp4VKMPX4Iy MS+EXemWlSb+SVWX3G/DCY/UY7eGK+pQXa6qoDXoXOWjABj6JsMwzcpyKgwEdjWAmTYoUJ7VvkaD vLgajPMR9cguJ1mxiGrEM1PX6GW6XBB+TssB2dpFNSiXBUt9E98Fg10HpausPB+TP+KbLItRVRuE wDR13CAfL0ts5LehtEJwHSJGGWL9PCegT7uJLjgtB2Q9EHnCbUn265hXO0mglXQ2mBNGy6UMaR40 lz5ny/NNdZDzHjYFfrpZ8HmT8E3/nW7zjAot0oQJL6oiw/NFbPem5svAaDWEco7Rpsi0GlLTzxGp xnFC+qBJMje5mM83vJo3DH9j4HMlR9N8we3c5juZop3QbgQSRKfRwCrTLFWC7JjCP0mYMrE/K8ii ElALDiT+TUKTFLWrTY1qU1+13KyXeysqwacxlIIQw1CtNIAnWH0YtnaTabgJ0iLcQKxNUVetVAf7 cxPxcy/OZsWpt6JZT68BlEmEe4tsTCoYRVeMYBYAtYphdNVqpjGQrWQcA+M45jHxjmYgcwyxTGTj V8VIun41M4GBVDMUQL+SqQASirHY82fBDep8MSZ7tYspFVfVyUNVk9kgB8kn9/di6+8ijkopmpNj Lj3T0143kX/2T2RORgqCeV6US/K0RxZvOZeJpeGXfjLPyG5ipP2UqvYR+yErHIl33in0dic55HXa na74Tsr+uIV1RLrW0x71mAxk9nkCkP4+0xDIRw2EfWFwtCZSw/1FD/eX/onZD/3zmNWg35iTBnYx e8j+gh3NHvI/WX/MMVJFX+Gspx4i1/XEEaAtaF2KwI0cs/vJzPlPqnL0uFvqo/hxnwERWMpPcjJu V8T3uEl0jwG2//qXtjfb99r6w7Fu0LHGdAyG1Fl9TPdWnIMEDIpifCOIvAYqJ+tjQn5zmq0xyQ0R RCCyDj0am5pjNTP04cydeDlahXZLIm7ikUwGHzIGpk0lIsOXSkO2Gsg/8O0Mo2GbV5VsxB/WbFiz UGEt7G6tXB7t1miyy54/q9VAPWJA/itOav4gclMVnw/Gc1COEH52AoBo8PyYQOcj1vDpWUE6Wk4m H8Wj2ulkSdTYWZYKDUXo1Ks3bKMngPLlYE7q5Vf5YJyKd4B4iBLFd8rCT6obDqezj/VbEeLkFwV1 mqZy3RxF4lndESHg2zc/CPV+y7W42uOdJNh8HNMlfOKflXqkwttVUApvVE0oH5KV3ThkqqIR35p8 pVGIRuLS2VdSVZNK3dD7SqxqYqkd3FcyBZcffVLoK5EiF95XakVQKy++kiiWob7SqpJW9Cb6VxpF 8tNXYsUx1FdC1eWqrxSLoBhLuvOVSGEi8aw/X6kUIaW+kqqWk/CYfNn6T6dWq4VTTLHZyznL5HOR WSeA0COYvqQ1ysHYy6waCnAFYgjWAqU9G2uDcnwla0NE/C9rwzTcFOuPWe9Pmxttk0DVfqc59JoD qS2c5rBrEKZlhTWL44qAQbyXKWEKerd7rCK6bJkMRc1rVlUIL98NM6THlwI2jDp7Pi0Wg7zIyPIU ks/GhB241YbW8g/tGF45c7o7BoAhdgEtBQnybfJ4dwMRJxI7FljHegVnhPsHKzZHAscJ/k9Whqbe RM+L2XKh6y0GF/z0UFWYLhcVNc6n5fWgHJlVDsV1ueoOzvJRXmZDelcDTK4JBO3CBFMOitF0wp7h ms89YAJd/XHL31ztrUFSLHaT/LyYlh+N8M0Z/PVDPl8MiiF98nm2KOmrv+nCEzv8dsrSBNJbRcQY g0DeZedZmXEo5Nv9E/FwM59igbG4PGlfmJQoqnrpUJQcOXVPZ8nVYLw0rlWCz2osdBgcIU9NOZQZ /69bQY+olH8d6TtULe+9USkSUAoYB96gN7f54aFDDYw+1WA0uQzKVTe0SOiStBrEzCZydZMyRHaU 4HTD4Cc13DaArgOLtZLKNhOaX9UaqiIYRcxHGbqEmiKAjLv7TMmg0fMRQ9W4v8JS5KQRET7qk8Mk rCqy5lr8iqpTLqMbabv7/LarurVZv5c2TxHAQoX2Nm4S0DuNa5gEqnll14RG9A5kOrzMhh/Ajcsn tRoFs/ZU4Rh/4+0lNRNM4V3NNUYbR2QK5hkJpdQ261NLmQYxdROnnFi3buok147pGAoVarCV0KX2 NFHfO3L9XV/mY5bFlcdxsjvNFLMOuNb94IH4fMT+LPRtbeset/hy61mq75ggesbkUM1JQJtWzwXW DEyJ5zM6M34pas2QRRMKLNmWnUoCUSPwycpL8k55ezXONomiyaGhqeac3qgAFpU6nTBjKQQwk9cg hbpbn6aD0ZU1LBqVmneBgclelq5cktZCKra3O2yd5GGkv4fbBGzzGj0AFBI6GIup/TsVXOrkLB1o Qfa+Ox0FyjvwJMnG8wyp9+BBJ9neriQQtjpXog8GKIY8NZc8AciTbBRgle/3N7jK46nhMruPCNbC BWRkVflb69hKzfUqZTbOow3aOKsYNviFm2+Tgyf1IERsCLnnqsyuspJMqbEz1h4L6V8KW5JCMDsE 9yVdjIKmLfq1wFjaYi1YYluwFgy1cTiBGZzK6YKIuGykUiopTTVclqQ6nnhJbYBUbd1zaGNcg16r vDMA/4ndq0eRzN511YQzQz0tKnuWNgPMJdEW2ZxUhexmRlrkC199YxLYtRWyosQ8ttlPE54DgG/p 7GJ2VUUnnwIAH4q/NWBJntBWtEbXYsNoYGDjQKWkyrClMDBoIRMbsZp2iiHJ6HIEijhiyq1USFtt K/GRzuMErLzFZEYvh8s1ZCV12qIKfsHzMgolD3oWbGJnmDpxUb/fBlh13BFY82jnzHrQdrNUbW97 kWZZuFCMUWFudERG5PZlN1N0M7oK4RSgYtXot7eR0T940MDoYRdrjduPTY1xO4nSkD2vJ5WXu0g5 OmzHVtTnt6do3w55VC/AXGyED7ebGPuDlca+XXPsD1YYOy6vfv0tMGo93i2elg4MT7gXv036+80b geCmZAvNY4drAgaAX520DYSoZh8tR6XWH/J2Mf915N9NRw3jeMVRrDgIiba4adzMGO7d7VSY14/X xP3kjukvriuvyzUrU3x1kqsLzutS/FNwy/EqzKI+B7rEtyNaj3ya1b29+uoOdNoyzYOVyIM5iOJo ZI02UB0Y+8AA+TbZ7TehnkAwDExANfyQ5sU8KxdVjgokRqPLPEzuv8MbcIXIFqUg/9PeMdrhA7Ke biHP/PGdIzautgZzX+0dZUn7vto+0nyhj+oS3NepbSY9bSMzcnjI83nr7XiaMicNYj7JNtsns+X8 MqV9tmXtamsqHtEttjl38hPXgEB3XzVB4NsqBIgy3XYP9ptfG1IFIBge23VBpcxlMXPtVwFsSz31 bbK309vUmj8vSemfatHjQ4pf73v9/VXWO9rrphc867T2io9CNbzko0BUrHk/69Va9HuPHm9s0aMo Oqse1qpc9pUg4bp/vL+pdf9ZrHg73BAsiRy62teQDdpDGpYH3Qo06JmW9gmbgqPLkGTHXjS12LfJ o97BKiKkUnhwG3M9EZLzeE4gSXi3zJ3eTVxZ8uBBDmK0qmTLWlJlPXlS3bpKlDx6tNPkeusmFduU KsHiEyldw/med1pwisXoKiRMjZetgwvDPuz1xPwr3x1/12W+GIFzTH6GdIR/PVrlvgAQdE4Qv1rF mz18bez4tdkD2GaOYDd0CJv+nMacw349YMVD2R1WZ2k7NVHbCoj1RI+1X3bhgOBXFStiw2baD4jj ikNRIQK9feF3b4x7N/ehVk4cdKyj0shzTqAfADtqWsUfV6LNnXF5lNyDB7C552Ugn2zzqjyX2rqX Bw86UJtWIkpPFAnk7e0GEBVHh3GIbm8biAZOgviEWEv3fuAYTHfyK6n0W615exrqTnWke5CHXitP 7grDC1AVnvTFckDtIW+vN+Tthoe8bQ/ZlnPBSApzfSsjcv9Rr8Hzw1eYEfnOa/WY5xXOMWPgRuMr R7SOL+2HiSuBvHOAlJdz481CBtY4hCzV72on/wbG3cSwNzzqRnjg3mfKA/c2zAP3PksewEZ9B0xw 3AgPNM0Cx5vlgOPPkQGOP4UMOPksp/9ks9N/0sT0Nzz7J59i9o8/Uw1wvGENcPxZaoDjT2IFnHym PHCyYR44+Sx5ABt1azOGgP4aO/GYC83eiH1mXLTdMBPFTnQLjSiKbR0RXlSf73KLSnEtgdsM+APY Fa79ule4sPwxT2q9uOTZGv/IU7PQAfTgDILyPn7zjY4+nV8PZm0DCH+uyGjPXiwyjlWqPbQQpOHZ T9K/0b9PyZ+9o1XA9X3g+ir8Afm3dKroznXkPRmxxIT+zYvOQNEZe0lahd2z+4vVp5oRsyeTV9hz w6eF5nzgs8H/OsMvn9JUFHIsYCh8JGAg+Dj29psfh85ZwUonedEGaSyM97BCA+O3as/Y9mDQ0cv3 7Ej/PYBXSu9gKIObNYYyYEM5ixjKQTNDMWX6ZDYos/UmqqvgkF9D8pd1K5aPk35o89pk4qqH29/Z +yTDrZzMWsOlC5VMbsRw+01IfvRu/xsWo+KkfgHl4g44TfYJLj1jSQuwhA8AEDUvsvlybFbwJwUQ cU7TMmknR4mTV4On0BAQdWYNfaK1Jb9y+QyyRoCrUbxGvevza9DPBhVIobESNasv2scqUBud4KGw uvd+BGfNuA2fPHVTeCQiBcIRS2JQwEwpocmDeVSMIjiZSFKVmLm2pDlNtAQmUGajbYM0TGoGjTKR iYP/4B2bMzDJJpPpFU0GIFlYAZrn/5tNz6k67yRbVF6YZOt0PFxMjE638gr5PmrxdDpY3vRXEAx+ fjZyYjoXHPg6clOe6Mah5CdfGiFUKsy7okMF//MxGmwPGd4dF1wA1QNS68s7sDVRj1u3n3QYDXBi ka/KiLF8GB94I3s0NmFQdagNlj/foZnYXDUgICsyi8N+Tnk1W3bqAbcNHrdmLi4CSpJMeAFiWwnU 2p3O5sV187zhCOs/D3OsxBCoYead8TuY8N4nEgZYhmiI/OGhyO9MYMpEzxj9GctytOXCEiiDnxo9 DurLJG30WtoAbXErwqHmt8nu7pNPvB2tsRlFSY1lHVMhcZHEhsLLR2uH2L2axPaeZziZ6gxnrvPV dOki3yFb07t11HmK5MPrAVKjH/2yEem0QlRWJ9WryLypd5N0f6n3k/QXcyE07Q1whlhBdpzqazoJ AhSvIHgd78GqXgOYqoR7CeJ8A+vOZau5teRJ9/79dDpmlgdML21NLs3aORsshpcGPeeLwSIfepel lHcNrMbQIsRyD0HppRm0pm0cYRCpvI9ViUsTHSwald7bR/9jnpJf/FubNCfoxMitpJiJ1b0/1nVU 0kJn/k5fLyfYSlANbJcRrUPaeD1H9GMHSQdltG6YrJoMn5a4OOtGTr+4EXEY9rHEcuT3L0158tJW xi9R7Uu3HW3aGC7ylz2NBmnn8S1WbJL84pviBrdiJ8EVW7nDqthXIbPCaEXR6Kq2GA6RU2Oo8KSB KRE3ep2geO8s1bk4ZUxo0MlEKrZRbvHRQ17msd1OXx5NKjzDkfTYBB34QdZGyFDJGbV2iXyRx20P K2c5uC1f6dpg7Fb+S5uz9bb2G5g0ZAu64oQhPoK9x49X9RGsMrH2vrWe1sTCf1o1p6dXf3o83Nfo 7KCT82jnSbORZOZzWXyKVGzSeT4eGyFjYGrMUj5eI6IC5GGwQ2QqIgPcaABe7amECuix20R8hfYz QXK8JyY5Rh7bpUWplBZt01slyUSB8Izx9YkDd9HdOpQBfGu8uMGWhhmAxqbYeBMUGO9OOZxm4yMd 05CFXrKujG8gYm3IMSHboXm2gOuFVOgm6An4rQdnHOMAvn5sa+HK9z5klztfWG+ptlnbTs1xWAPA MEdQvgNckXVCmdmQ4iaDwNXgYylnQeBsBKKImAzSnMIZ/oF8hWHYwVme1wj7A53h+AZTNYbPZwS1 Ud8kzt8m+zv7TZ43GBaFKhWGxWyQQ99+r+tWmeTzCd2tggMIZW0Y9aXV0bM0N4Ao2/VDpoh5PGF6 u3ta7fWS+/eVMO/Ri7JbCjr2BlUPiafqe4KnwmRpg9HLHsH07e3cwfSZLttiUH58W2ajnPoRP+3M 2lUs5GjUJytJZ6QIP5iKmXgDTHtLY62Z4NNywf7BnS1iO+9w9vuSBuOsMql116rHOIWzBczTHjDI +toio1HC99qepdwB2MmseHRraclS6iIA1H/y5HNYgxueGOP7yuts/amLWYurzOLj3f6drSE1R+Ps Jh9OL8rB7JIQcsyC1wdltrKMtDeo2DxapRRMDQ0ZmEAuKXkvurhvYOidZJgHkEyzXp/HYGLdedVz aLfsg5a9Ko64RW2lHk+IERoc4J/9x3csBYxLFZ8dS1WACd3kiBYZTXKcuDkSK1BcxrMA9LuA/TbO f871Yh8bIFu6LcAPns+VjBEC2w+C7YMts9iq/W9GT2zTcVb0Ek0AtQEWVpVbu69q93XtPqydF4sE BDiQ3fiQ3Raybasuu33FUegK4NLJZx/1ksnYSf6ifx+Tn4cS/WPR2PYvRM0SPjk15wSfCmQG4OB8 eLWd3fRWRyMY40P1QIiQPGEA6H6gNgrUqJbBLOIVbK9pPc7ni+gnIQfj8XSo34M8OIhuEAI/HMxp KlUJde9xVb3dFgKNfwSPVT7yVthtZTdEyBfJN8+/oSwjf1J3Gb1Wxyqm54N8zOWhZDV2lZd9zKfc PWF8Oiebr+DUKcnBFzBdQgiUZcFib4SwXVyW0+ukTad2sFiU+dlykaVp0m6zK+eMz9O0wyYcHcUs K8tpKQbD+yUlBY8JqYl/YBitmHOGpgaKDzVpe2cKGSdAvj4C7PjqSRWb8kV18CR6kUSsQka07IY+ 6A7ef9+r0STUBa9FSJaOsnNCGfCo/e6jGn2gj8S31IFPmjJap2eDUaq6bNOPHX7fHqnHiFRRh/qf VRW0BjU781EAzHh6kQ9TtmYs9TVHgY6mk0Fe1GiQF1eDcU7GU14saSRMVCOiey8WlzV6mS4X6fQ8 LQfFRRbVoFwWi3yS1eiCwa6D0lVWno/JH/FNlsWoqg1C4OmcSbtliY2crtwnO02uSFqf9JwNRmC1 PNqr0cR9KJmrbhlI9y47H07J/KTfD9gT38LIkcfO0nZ89zxdyHQVV1OyI6O+QFZKM2mW2XnKoMgq aXrBcUgnRNDdWLXIQhh+EImPTQTaAiS9jHtotGljL1o7nYizpD92ugn/39vTv7578eyH9OdfTl/8 PT19+fOLH9LXb7vJH+x7cnurkk3Y+OnUE+odgtuWebJM2pApKNvmqYONFgXWvu/AV4cPLFkwoCAO ZVmE4dxKchL6SeRG2drI2XMtCMzyBq+NM/ZEKN3msUysveogAYPNga+Aa9/RcjL5aEaNvr8ezBgC KS8RIVwyEtTlp/cs4QznVzvC0unFac9L7U6PZaPDQwi/LtvCY3BlNI2nxQUVV88W0wlRNSwti/GR huWms67ZghT9rreYHhZxhrFjDUBMqg0ZXqMXc0z/Ysvr96NWkG9i+0SC7sXWpFf9/ldQWALeOX0F CMIlZSsk7oCQMyVGvsiJlv7fTC1NguaTfk1mR6XRYPj7Mi8zPmVKWraq1r4rRiDQMhtnRDRHAgVr 3gAr32ftH9QcKKT/YLmYavLz1WVMy32L8GartlubI8l1Da/CS1oq+zX9+dChrUo7/W+ri47ZyiSe aDUr8ysiQQ4VqZ1XYkyg9wUVra78Val4uI3M2AWMkYA1ku8f7G/PhttE3Cxvti+KJQcxYHImX3wE tvzuGiB2W9LwYNJViLHraTkiIxJiWsbegY8td1e1LJbzbET3VOQj2QdcMotyUBDjeDRK2lqvATBU ME2yidy+EVu6w0RAmV3kcxYRBStDaUM3hBPSM2kkAFM0vuF644b0OE7+a6f7X/1vvFvZw+Sbp+U3 Sdu+UoDW3GEVKX7d5JvJN8yjTxAPtiHfp+XHbxh/OPLy1qYuEwAVVOUzF6An1TUYPYPUUsTqhYhF BpSXHiqYo2XrYLfeOnBz3/ViMj4pdxR4via75h+ExIJvogiKU1LzaBdWkQiGtvLYFlaU+eGhuttA ILeNBPgAHPs9yhQ81gVX/By0BAvgjYikWtDLPTPxoja3wvqPa43bso5yIqHM93wmrDpvlMraxgMz QDaaNKLm2HQ6ESAEkTpHWheByoQZ7M5oUyIFRuOs7LQ76Bs1zowE5gTe9pH01V5zjiKbH+MEZEck kOdrHDYxB2e2RC8VJvrlA3vqw5Of6NcdzstMTznNSNerNdso0efZQhJekLstPqbpeYfeAmnjFOTN p+NRh+bZD0yfJoy/DgNwjpCQwHcvToU418NOqr6oSwzTEL8RfHaOKvuRGWMqehLWgLsagMho2YSd fLSmha0CjIGPjHPFoyOtV/6AEQ4uxMhZM5aCi5Yh9tlzYq6vrgOhMcEfGB281uFbnPKAEtO+nuWn GIjatb39enJSPn+oNQRXlil7oOh8QHOZUXP5yWri15dl8BmtbUrkeU7aZEpLKUGMSUZwWTIkGCXF xBQXyV/YgR/L3NQRSBweKgi0xpa4PMoqdeCzLoGunQ59PVTAxgWnuOKp5aYxRM7C7Ji50D3C5imL Bo8YWrh78BaPpxMHvHrOpr//aF3+QThmlJ0tL1yGkZpbPUxWLCfJH0RMZTeLkuZ2PbhtVOtK16ta 2DxOuIPy14OEP1Il0QFLf0v0QloCdazTBKCJ7gxg6yrkiuENxsxfIodHfmx7ECCyEIbLs6ddieFu jpCDE4wrV6Z5MPmNt8U33ViG6ib9g326At6+e3F6+o/0x19ePz99+eY12T10k51OB8wAyti8W76E vLPH8sHs7Na0Wvh747v7q60NGpjATwSon0LublxTl8j3AeGWaFtXrJdnr17+9FqsFuPDz8/+nn7/ j9MX78nHXt/5/PrHdy9evHr5/pR+B5W/SzjIW6XWl0U+panHzv7pMJ3+tEXdGNQ+TOkpPj3L/HBk 8CZ7Qmuc0wvXo8Fi8GvvNzUpR7bsZvD0HvG9BvwrwPu3I9uUF2vgfUp+U+YkrY48NTKytUe+yxX2 Pr3MBrOU/nSwM71CtG4xHQmNyO6nA4+SBVh6wd6n5XRJMFjOtMg6+7jI5q6Kovto/omytdjFiDna 7nWS+8m/21YxWe89THHYONDxs9nKi1F2sxomCpHvzBKGw5G8f+WR25QOmbjZpCSbu0PTFzxYk+Hl sviQWnbsnF1cI2uLPRA3Pfvn3ATEvYKvuDPQZGJWyjxx3KYTK7XjmVncuyeB/XsFaK7XTyyMJORS UWlpSrKoRsYQHZY1HFFk4qflMKOmJP7Y9vr72oXYv+gsVZwaoGuqIHag4fyHYUTT6hfZIiuu2t/8 9Orl98/fvk1/fPPu+Yv09Yv/+aZj+66ge4meBOh+upQPjdrZeJ7VaL7d6xy1jPqo0jTGRiPYvMrS qVlHSe7tPIpTksC84NRs88uVWlYomd9J/vUva3JOKDRrPyTsHLkBMS0m0LNFX3NeTdkuNppKvHPH hvppzdIDRGhZEgOsaOGtZ5oWJnuGeDATjSyw4YL5F+HhE0TryGFNXdfiYoNYSrxBgU8xrubIPxxv 5pZLKpUb5ySkfd05tDemZsis+TcwZhfuE/BNWK4NMCdgSmRL9Wl5E+O636l9zn502DHnKgxMgGDz XsW9GBv9foRM/S2IZDBdUQGL1jxnSbxm7TForj1ihnqwHWBVdrR9Wwd5GLQSFwHvvhNDWBuC5Yln we3WldZVB3TvcxgQD7ZHHrGq3O4oY64Wb7RqGn+GV9Pc+iuTXzZfTBdk78hMW7Yc6AcW+cBAOdVZ xXScnQuRILcSNELe3HqYD73oZuwtMNCrz2MKvf3ulkZQRH/gr0wDuEctr1cysd2SXDZ6cKVj9yHJ iETlGd1yG22/Ew1Nx2octTdOAHz86BitmV9M0wuqSI0l1WdDgGN7YGzz4I4yOTlJ9kyj0iW7bVbY BkGVsnLVP1BeHnWl+7dN3oSqaK6vIME7K6kgTAlh0M1Wt95ZV74ur3kKJ66DnywYwwpSXrFDflRr TvDaUv87uSXV4rDb8WMWVuX4KWYy8W8PntruAvfA/48WFhsfsHo8jJN3jlBIs2pW0LPAnOMzPCrh D8/hPmbNzCLt4SArqegztIUS+U9tAYSxhS2BTC0m1Rd0W2Ctb1tVJSZiO0etyJFGrZlWaDFq0cYk MGxqCesg5XztYglnH7TVtU3gmWo9u9V1YxkGCO9Iasq+mhppmLBhcZKYIyzc4cUJGbC/BcpOlg6X ZclSX5790/5UZDdGuaCRYcyIa5TA0jLzhtEh6Cjf+uKkAPwGD2zkjsnoABMBchC6UVsS+YGxIxQ5 namw7R2xK7H5gwc+SwdQzejlyNqLOn2DlSa+PUjw82TOItuJoHBeYQMYKHlUsSMHzgj/fvDrVscZ EdULRg3zDm7bSXdKc+U83syhiht/m9TY7LAljThrGZinZBNUI/S6xua5BUVCLVwNub5zBx2aeqZO d0pE1upPK5jaHYK0wjW6NITsKuzjPbKC0RweiNRb0N2hD8ezD0cxbdiGnDea58XFOJOnbQIEzWy0 u350CDyzVIsDzRCayjiVZ3IM9km+dWuI/wd5PUcnHbey89sVWQzEbMpiYuxvICk3+zP11GPJCok6 5914odwXULw16bO1OjW1Up8oUXs6a7Q4ximzM6IMtR5SYBXNj1m7ZLq4JGMAZ6iqQrvDr5HSs6hb 5yMfiPp9H6lchaoXGEcNA/lvD3bis5gSiexoRBTGvK1ITFjqpiOmQDmi7pNCcNRpzK0FyJqxMDjw /LDnEEy+3i1AcG83OA5A0rsX7LwHaNe/GPkKaV8n7WDAE4/aoUHLO643HnfDC2JAR7xAvTpWyO0a HitLWPKRyMENk9FtSVU1w5ICvEWbnlt/B6ECoCwCkTWnC8FE3k4nSiHzwOZZhxaL+G59gsqAjegR z/QjBMWuXaSz7ZN/01YwCArKPVTW8QM/b+Rb4zKNs1VQqPEqQanGCHGn4giLlQWdGNl4TvuRLnzY HZEwkiNgcT/K974qJvfWwkQ5zWlyrN7GQjXVqxe4guZVk5TfaR5/JNaCNBK+KuaVVwKgNlsLXTkl rooGVTElDT/LYxqtqPlj8aJRS15wcSeThh08dIuhuq0achARc5AoWisj9m8vhT5HQ8GwEmrZCH+0 wvYBah04lHsYMhTAVOzolNiGsVDDVPgDmc+HNWwG02JowF5Qg1jfYrCJEmc0eN/RCcpjZkR0jUp/ /GcaEDFis+KpJ48WjIgHMLruQlHW8x6Y+9v0nTdeBj1E0HHP3qCPfAq9Fl1zlPd8o0xWGWayyjjv hcfpeOep46ZWOAd+7aki4CHUKMJwXCFII3g7qy6ileEYVcIoKkxGXdg4lhPfTUJfa1nc9bh3bWSA 0X1w0N+A0U0RNgX9Mz5n7Jky7BE5jj13XL5X8V1jYnoQ28BIY+m+56K6PDxUT9Bw6UpX6snhIZOb eiMCdEIdGaoHBZGFA4OCgdVmbk84GP/ub2a+MdLzk4/3Ym8zT2pTFWYX1boHXmYT4+E/ThQWiEY1 sDnxkjo0escr7h16hSDYKCkqeg7RyNUgldBqs2zlUUOAqNHHuxslcF0skpokrw9/XbkRQ3lHZG+Y xkh/temIwQgs/Ei5V4NnW4Fklo4JXbnW/oOlhjUBWojUEyAuzUOLDSy0TyZQupuTJd0GxQijZm2p gk0Htmb/jJJGZKBV5qB9YsFevzqKqHhNa6aLQN2qI2ueQGf/SRMZnpVLByRSflyrEZ7N0nyWU4yL HgPIP80zAJ3c7LnyMZHqW6aDqW+/cEfdTO5NMebAm3Wo76nXlg3Q7TDALBqd+K5FBpcnBzXpieAH HkXUmwYH2VQ41PhLt1Yb/IlF8UU+K+m+pRv1pGKS/iBcefe31HtvPH1Nr/9ZjN4dNfqc8m2ARWae fuXQZXII7tvTvlxRAF2ahC67e3dFF4VfXYaoeJTWeSrcRgc+G+6zrNK/AXdn1FPloMWJ+dw4m39C r2np7e2vaHVwaGTwkPPsKt4cPKTKTh13mhDMy0JnpRwB4bxfuyEqoMPPuEDbAMyq+dAu+CAWoNE1 f9mW0VHBBSwHyyIeUraehY16/tb/XHrVU/Fet1ochb4E0vjenragDZclcpt1UX4EkTcxKoK/YUOg GXdKtXaleoN81a/PYKnWSAX76Zkhe5zv4cOHnnhiJfzAs9sUCxiay07EsAxSvZ1VVtsGlpbLPZGc gzPHGoLdEOpCep/WFd6nXHbn8/Ttmx8EpJfsh5OE2rduvC9iS0jmC/HWK6YIPZFnZ7BXZ7rWPUed o3mSTSbTq8zgNANJ6y1cNIVR5Qu/YvcQHISsY48DlAfECqhVY4ji3Fg07iRbyFjqD7u10jPjrmVo koq9YGsbieEXyMPS1DgAv0ENS/vdW8m1NwFlE/ua+icYX03tAR4L9ysPWtlSHRH6gpFwZaWg5iNe J+zvNaUTarKxO8k1Jtiaw89fA/iZGllEqNSvt6res2tu3lmoNOn4s9ihZadeyK56O6lanJhaUrzI DQhTwHVx2wwhPi0FNiFwaDKUnSP6cAYl2ArypinTtL4U6vd2NiyF6q4HjBcq+eCLk0oeuxSyvr0K MdlEs8g+bnxrEfH46nqbeWvjsdaLrI29yZrE7HGsKpN8RMQEtqsCb2ryQSTWjUpbnAiO8MPqd9U4 eM+dJvawEE5AUtQ3oVEeWkEVchKgrglkNqqm2FII0ZwV2BubDIIZVya5TdFfkwmgtfK5sECVS2KV rRUTE5x6zhz0kEno1VzbakW5Jm6/Hg9VyYd+DQEh3lvGeQPlLNqBIRfW3sRI6dKP4gnmp+414aem leu4p2V9/7GhSrJJb76zC+Jn8h08nrbNKGc5cem1+CPv11mZXckneMJXbp2uk0Nx9cyPzumMves2 WAyO5AsdTx7HU8HqVNk4RifhePXIaHVZ7Swf5WXGnmIdjHWHi8GFtrDoRYOLaflRPR6IEZ38OoKf DdzbbhO56A5l67Zeh+qxPAQSPJwLPfYnwbJcy+yv7RPJHGhj+BifpzHjHYlcIJ7XRfs+uNFixXLL nuhO5eahJKW3l3tr9XLP6UW+I7PXr8OmlTEl77Jz+PPtokQWlUTeXlhhvjfr8EsBRI532W0dxbVH VW20BtB/kvb8TkY0FDZQNjyyk8nG50fm85z21TfjG2ll3hJRXwhQ++KdiQOdPR4Lm772rbw2+2Qu NWxpViy7dvireJRe/Lwf0ZvkPguuGq/B7lttlJ+NW1psmCdtCZYtVSaC1TqHl84k5O0THPT9Nuhb 31Nis3vfgPDggfV45+Iyn7PeuSCy9olb9LP5GCiFaYOkSf1Mc4TWUi97AihVHRqvdvoGsb3tGwQX iCsMgoBcaRBoh9jTo/1es8JKRdTL4MSX8/eMwYz3Ahg38yAsIJfgZXTP3QF/+L4ZZWaYrHYAWsst ZEUX2cK4umldmhSLQlc5MtexHo99zZp1wW+ZmooadKc+/iEfTpwuiDGRjQ4tQ4HJqi2painOTOV3 UC2lO9AXLXvIjUGqkZcCkt0VDM5ywdoXKHsiEKe/V8tYS7wzbWITP+vIfLVQUmqbK2zKhq6ZoGxt c2mXhWOefBncbrYAr4DGMbuPl1tR4w3OOYhJNVN9wVjV1RaNhgAymKy1XiBEfKnE8aQTPRf/6hUD LcRsYtuHOLdWeg987Oneowqx+xoo1MQANKRvrx95uJB+sxcXvqA0VSOEPX/uXQn4liGf+MZIs+SR +VlttfQGCqtB91N2DWmy/Rsgaz+RPhxng9LoVPO1MAI9ryXDpvyRoeoHuOqbEmRM1o01yNssZ+Kh li9gWgye4E9Yk2YthP+c2pJHfFwb2Ijo8i18PyLurINqyM31T789Y08REpbKynmmgZktTlSyErNa DCQNI9xaE+q+bxdnU9STQ6VRV099iQFVYMweVL9fsKQZ8WRHxvq2v8iVi3+VEoYu1b2dg3rGGd8Y StU3LDOycLmUcMnvOoHl5nnmk3WmZxceD7OcFWITGunPBYCgNKMvv7ZQ/+2tvU2aHcEcvK0KCmxm sHc7TvCMkhxwdjMb08fK2Q/KDX5FB4W0MBdd3ceMQcJ6+716rMe6xhPSGEzHfgGroT62iK5m2T7Y pppYFFm5aJ9lF3nR7qhjaH0Jhgzt8W69obkkRjPcSax8WAdR1EQSLhiC58GjFaaA05P+CZY4JNnN Q2tLUY3fzUPjR1aMFJKPdvo194+Bkzi9UxODMT9hp5nwAk/LOe3aIFsZ55rgehWz5Bjycik96vfr z6PpsnrqTCtVD492azKIsgqJUZZfFJHLtcMdCjwCjTfUq0qywaOdzbABSDcp+67DE1oIa1nrGAcv 5+yJ44uM2GEmEkQjv6RfygF1kYm/jqBA50ilo3w+Y4LfPfCWzdqdjp1NcwXnFrcTrFom90kTjZ+m cI6N8iOrPUznCL7MZJqTBlQLu/qwDahMrji+sSpceCvcCWi0tU1YXugQyK7W1uLOQiMM0MIIb2ID DyBqUceBJPq1YIUwBZSz7wehuDo9GMd1ZEEvPnpnAuyPn5qz4+ZsM/K1KUBkiTFfgRbCkHYRmd+s jG9U9G9LN+j+3sGKorTMWCeGKM2uxbMRuNXNEmXv7zTfYUfpK1EJ4uJYGJDh4EHUeTktFpDVtgTF 0SWAtbTojbY3W54NxIOmskl7ezuw7pCmdp8GAHorsb8ivWfL+WXKR4ZPZ8hwkr3v7q7a+3SW6gnh /ZDlOM+M1Uh62Hu0zvgYEeOGx6hqDO7x/hqD49NnvmSidTg/PGNdmodnnAY0dplUAYGlj5/s1UPG EIliiACB2XSe01CR0Fo+6D9ZkQBof1ZWTF/P+qiHWWYClICgY+B5UrK63LGCeeYZy+dlrnEkobkm yBVltRFCPt5Zg7040yLcxdnoSb9J2GJEeehS+/Ulffy87dxc1TF3HKyo8OCBe1bNbiup5fdkZ9Wl ML8ezNp6f0M4m7kkWbGwF7owksfMaAGztHJ/N10awqmmXOBQleiO6eY+w9e8tY3+A7xPdI/thLnN 0wGOHHGyvygHxZyoqTYE59tJG6GqdVAzpjf3SlH+lJB6M4xe9dBvL7E3gSRc8SQQfQ/XLvxnR0y6 E8XgGWveZa0aGl0MO/OxeHm5CmFrS+/Du8zYLVA77S/1L6nKiPx8W2ajnJ4qIrKTg0zz87auBqDB O3C/L5mPMtDR93kxKD+GuhNg7JpYj5OsvMja0O8Q6Pk9e+b6f7LBhzflKCvz4gLpHEDsYk0wLMRW hK9qfRwktyhtNbOGZDC5bUqUUwPoMzgetK0jdL8mZdoLAY45FERtodL1L8JyyN04y98MnTZwd64s jBP2FJr3FNdI8KMTj4iU1o5DI2Q2RA836l4/vBF31EKCW42Rx/m5jlqtVWfNtisQKwifxZtg0r2I yTXtvmbn+KbeDHsMw2rytCKustR1AFcl/EhqZvCAFyNNmjspO269/Li+vd8K3eLUONq7gRvzXrCJ mlKHqCpeSQcr00GrYWjU86KHdmSEEUShYDy04ikSiUlFe9gFbGvD9TQ3uoBvkyKR/XybGgAd1b+D NdocreBijLbFa7DGKuZUX5ORgfI7Tw6ajxg5aUXkCadg7Rz4N3KBYB8/VtyhtdscHpoeZTTawnY7 k36I4d5LnmobPlSxzyp+lBV9NXMJUHrLvBUlQKui2swRSGzZMSTv3+dNZEmflmzx7tjDyXm/A0Qh lXd578j83fceTefiEVGjK1nS1/vCXq+/vxke8nPRcUNMJAY7zm7y4fSiHMwuibVMb3hOZoOSn6i6 m7rKO/5ySX6EjT86O8KGX2pYmRaSCvfoePkMf1Su9yZQPGkKQ1KSHCfg5ZxGeKlRAgoEm6Vfw1N8 vO4Mu54d55mPm26Cln/U2SNvHnIPkMCFuXj7lRc3W1VXN5msWQyH6uLmXlxt99pmPdpos8uMaVTq yAzaxB89xWPRrLgmngok7kTWViAyFRG8tWTsPWQn0u4B6T+ScN/0m9szuM97n0F146vs8Cnt9tdq qZFY3HoTGrAsDPes+3nFAwc8ik1MhBnxBsPwNFUr7WtdVRmHlXZttFUNzMwqSxhU9VzvusOJ8rvu zQlx9wbszXIZQY4PWd/fRiFQilRAMOZCMkXhXYQ2DMAmqjNz3tQodE1VZPGKBKBqgqVduAvbXNaF fcKgog/wkSgkOp0VGUOJZM/Mr3DA7/PD54RAltEOwY6zgj89bu/xcyqNebQGs7FpxWOAB3dT5DyJ E/mo/QCml5918BQGDDjnPLkKqxCfsvE8s90K6ghYwmGpCwn0mLxb3olwbJPQrPgj4xxvBHUOUwLe B+GQWpfZ7o2eO0eJ7fHo2WfSyC6NZ6XAt3RIdZYJA9tR2od0Pe1SETsu0ZMq7kNXlXRO9R48SJ6q X/0HD8Dg9KmJ2Ls5UIxTQJ38AyBpsAnwP1lJQlTSj45nS2nftm1yJa/mFa6xmP0rVnjpxDK1nHVb HBjrzlywrFnHv/xUECa2WD1Lur7mRC6zhbz6HupHuvv7iL+/361w4Da0iNn8HSXxKw34h3td/Te+ AuH6+3xWX+PaEhyOIpH/3uXEPe/OtFmTZs9ZVQADyiKmi9f0dUFTjE/OlsLtqTkIZHI6jrNVGU+2 c7VhusuT4WbJCw/Un2pPvhkHUElZMUmSvMFZsgi+xZtgBLc2kNYS8JE/8WK5oYmxD9CDE9SrnCFH akWaHDGmxhqGBpy3PrFNldDDs3d5WaYPs3eZkRpa+klhJhnKSPllkMGc+Vsfs2ghjjA+PmATtwo5 y31opl8MC2PA9n6dQOYvfe7E+xlNwatTKnjK2Pl3re296SCQ+25rT3mrWYNWYvSY6dzsTS4XHqbR MoIA2WTYrh3tn2LMaX3G6rnSht1LTsmWsqSpvuzS6ZJe9f11f+83oBDY623UioQ7NbV07jkBYUbO Ot7TQxH4JH8q/z+zfbuJCuw1NPpCmJw7sJh1S008th1kaBFi3NPIk0+/uVFqJlpJYtXnIkugZ6AB xsBZC7R78OA3o+5tK6aV2YYvu5zrGjqcjlib4zFcxqbBpmnT46a3pIWwtzut6pHqwu0eRMlBmMKF VW6bs6lDEVtemxqLHONOmFG1mRxhJbtGcnXMaJSkP7LkrymqVRwBGYdSLJ2O19oKKfzbVW1dbJKq g+u8U+WJuiP4nrGSTU5alCEXNVuVxpw1/6xjMEA1m11l3HUMCeOx7xylHZryJDCARtkhKmTQyxGW bYiGQzKRNZltbM8b7bK6A2cVZxY6XG1MdoEt6ddgcQbliiZl0Kg0FZ3Do65p6Tcu6xmVG+bgKEOt il+/mnCfgwnXlXPyn2fKIUOPNulYrMGjmCTRT5JvKEMU2cPL2YyUBqIPrjL6ZKIKO3hUUW23MpLh fFkMF9nNMJuBPNTh1zWtJqE817xWPi3om7xkgHPQx6MafbCgDCfjdaI3wywDCtnXjlLVZZt+7PDI S6Qeu/9eUYceFqoqaA0qCPNRAMx4epEP06wsVeZX+QLaHAU6mk4GeVGjQV5cDcY5GU95sZxk6pZp uNE4Ky4WlzV6mS4X6fQ8JdrlIotqUJLlkU+yGl0w2HVQusrK8zH5I77JshhVtUEIPJ2n54N8vCyx kd+GnnyWy5DHFLViEsLzJiAl/KP4FrtfF/vXxf51sW94se/HL0i+7qsfeF8vzfLfWH9fYqJlGsiD JVp2RlSVfVMkWzbhsURMXVo+XwzIbmOH/yCiKZ9fyl9k/0l5fU7qDwi3i9PyP7DkzFb6Pxd/+aLF lurTLOI9m2Vm/zLtKPkoQw5UMlmR0pAe/QeI+BAkny3wlLYwQa14dF3eIdL5yP6QHrQO0oed4lZ2 5WRWTmqmVnYm/k+aXDmSwQ3mboaJm2DP2qQG+ZGx/M3x3I5mbl6Z0asyNzPAt+vkZpaPd4j5RtIz Bzm++hZIUyma10Pjk6dpBvSNUhUgXeWtC0GzSDepBc1O/MwWGQ+sNrm1BS7h0kXH64A1mbiLD9RJ HlDkjIzN/zZGIHLuQYYWTRF5QaMvxdcOfODmoF9n6xG9MsK5njlIM9szGFlUvmdffYzdeH9mNV4G svp+2vTQ6UWxTIc3NzQVSTEtJ+DZqWPRogtx9uaMDgEyEDDBxV1F8z8a9zX59N0nn/YnlpYSAU8f rSUG/h2IKPsTNB/sb4gZEc5EzPmvvW4aVirev036u4/rSTLV/woJidfNHcuCckECWagj8FeCtWR3 kxX3957UHTo2D8GExaxbf9biugNAUhn39/srTqCYMfbDm9CYp3nkt2+9yY39wxAvW6LXeE3NSkby uPZ8BOOnjZwZfMjr5LxYhXXxxMeby8AmCb9C0lyVYFmQiplJ6iVQaCHxqRaTtruztxr74VmYITey FzV69cXTxjIx7+72V2XQr7mY7zgXs4paaBtSZoXMy9Z9Ig+8ULZloy1YPbVTLyOoYOC+ZmP2Z2Ou m4k5NoWyTnzMO9tOTEArJ1FOvmO/p+dtLbPkKwb93ZWF49pXL/klKnlJ8ViQxb71KHnkgQF/tWuQ wBQBWWn39nqbIAJnwMhMz+7kDgezAbETP3oeHFUTbK7otrMdcBkpLjW4pPtTGZQW+zxHiFZZeWUR i+novYP9ulDx51l//c2CDnNOG5wkx1OdPcnuGUtz7e/fyXztYoG8bAT9rPwwb3iZDT+gwLFFlZw8 FQk17UWFnkJ+I/xCv/6WDIbDbD5PyOdkep6wz990kCdu6MsZvfUmbbBwJ8saLyeRoF2bxW91fiWF v4mHLXb3mpg9FxE5a3XQ+awTtkuV0ls9ZbsJghD/8aOVRUFVWnOXp9X+kMcbWjLOTYKiX4RSTc2n r1j0p+lX0bF0hkLRKRIHyxsjw7pSIY+erEELPM/69raDHdxMSatNobDfqy2ZG8iuvl/fA2LlV082 n2B9f//RHey6mkyxbuzDGt2JrZ1oXXDbwcFa3BZOtv54p2HontyYrK/+zsoczKJVHfcXcssP+OBY jnSx/cMqAln10F7nVlVTCKomlmxE3uFD0rEbxrbxegvi+vY5zn6clteDcmQuEvjYvXEKnQ4K4d4z V3zoRMTuAvCs+8XNfypwId+IMboch04PF+VHNMgc9U7a60aAN2KuVZok/s298+I8TmhlFDYO0DkQ cYqOP1UI7r+tnjkZ8QcGcl4vs+qs11XHtvGHs/Yhby0H/trJsT20iUiQXfEqczCZhqMKpExT8QEa bZ08K6VUvpgClkaSOZO6z0U1g77cAtbDxVx3oG3bn5e6wslu0tftFtekAWriTnmiqWlOK024wYUv f3NMxmlty1q5pm/rSko6fnzkPqlXwUm4SOzSAdLyAAkMiUyWlnrfC3+IITYeI3JZV54G2fxnatTb 1ooSr5EU/1BbNJDkPzbL/ydO8/85CCoxDrpL25SI8pCOdbluNnxELB3VFSEh/OqaThiOqOT4kp94 oKv4kz/y0Px7Hiu/9pDU1rIeJduYdBC72kZNGdNZcDeiwug77o2NRh7Y2IRYWWUsTYifFUTQWl6m IwQq8AXWcpYJ2caiP5/0ehuJ/gxnIX9qxkh485Djn/HE+zrCR+Sdl7/u3zfnL/t9ORj7A3l0qn3g 03yyu/MJyHTcPJU+9fMESSPvE6xFkKg3CpImHiloBE3vQwVJIy8VNEZK32sFSSPPFTQ448drTzjm dkVQq0Cq3qsF8I5xxP3iM+eC8V6NJuj7BcJQWhbUks5GyXjKYn/zhYpqzorlhB+FXE+JXiSQybY5 Lxbtg2RLRn6oBp0Ou28jr87QYnX8xw8dVNWE3VFi2et0GSmZDOYfVKFq3DbasXw5upEkP7tqNWO5 77sSFJsIdp1K3wSwQHdkwx3QbEdcL5FMy9jYPbi8d6+9Rdsm92VLcQ3D7OM+CCTkt0G5O58Lcn6s ftNJOKh/PYV04MeF4tP9p8m/jW926uRw1+LdSus7OPCC4GhOITpmuf55UIer7jFwWFAJA8ZPtamA DsE+rgn6HoR9/74Nm3m+zsf5jJ1FcEr+f5rIdJVaTKusP3oPRd/4UvcTiIU6mk5SHs5g2Ir8tu8J W10Yr6uVxvKd/JxOz8/n2eJILQ2jZ5frzeY+xudANetr59/ZcjJLl4wQLXD6zRvQPOFPjZVOz+Ph pSheD+axYcfc6mGGRNNbdjaaXhd4d9vbtLsdvAMLiyN4bm10B/ojUrBs6ysaNGmMgG3d1hBuR5pl 5gGcBPkmQfKAJXtKvoNoiM+iZZH8l/tRxscc+0bVhvPXYWAeuGCsYcJ4gTAwlZYzsFINBrvPiSSE GpQojAz8ReCHXPTch52rD5p04VVcp9tj3eu//sUYJoDKsYlJB0Xl3iokuNcWcpB1jQM+WWWMLLmR IbJNuq2GLADrwXUdIhwDGlBpKawmtdpaspftYCfKuMM/f+TLRjODkgFbTEXy+d9m+xH6Jw90u9HT r79JxqQWISbawT1eBxXDNrKsGOPeGF7HuDloVFGd6+tstuDn5oirCna6ibRJzPrxOgLRL8yS0mpC D1NO55Zr8wCj7Gd61br3y6vk+DgBS5DxnuxJGyAPHihFAFWR35JR5AIQmKz7o2Vl/uMJjMELEt4O 1ENCOI7b2w6OXIPVwJLAqIkl0kUFng+etl2llgPUmTKUazaMOBh9ECqXBEQ3bqsX5eNmDQcKpU2I SJAgXDPnftI32NU26ApdG7/+5qGWDmsUJOPC0xSdxnJsaVpBA6ZAxaUwhIE34UaccCa2tLNuZMTK PKY3UEnHviA3aM3rtrSWXwpWvLsqJZwVex4pF+2I9aakIw7eOztBqA+54DQ0lxTBFm0xQWywqrVN 9khksV5M7NeQzNYU4vLZeeloRSntw3oFWe3B25TY8XhXyW0vvRuQ3l6qNCHDffNbLV6riReQ577p abzbbaTbGgLeoJsp5G0LGZEaUcLent6gyKf/aKenSMjkZCBL83k6FznIRJ3vr+zkMWRw2lNWkS2I go3NzGQnPXBycq2YcgwZQlUamYh8Y0amJk+iJu5VhCmaLIcP2beI7IVuhq7qHGBtxzvA3DHfgQLo 3zJDOC2HCxsU3zFpR0IgMRhsEXVeFEpMw/vVT4Z4Mk9J2sUyFJrDzdxlwaQXzhd9+8GaNjvhBcsg 5V9dgbV07CQ/+1xXlyfdWfTiAgtrnQVUlZ3MwyMgE1jLzWwlc6yssDrRnGUbXpi+rGZ11mSN5bip FYMvGGexiLRqYGPiW0U1M5nB1YOlMjNdPKt2Wq9PJ3laSBbEpg4ySBlQfUjutH+bbdkVSSSdUFtt XZmt4eRExY5b1QErTA1mEgiZdED5UMo7Zs74Mng1ksEp5PSr3gxHOQbxPbOVTMwFhrgQnTrVG+zP I5WXL2kWwg2VKwHJ8urReVaIEd6bndoD3FE2k3LKdFkoFKhmjqKq+5J4+eojSb18VbEkX766WNIv c9z60E1dJLDvW0uNZrhgfueHe1r7VgbxkyYPkgili1wW0G6g9HfqJwolbyTQLZEAULu1xhwO0lNH /PgtY36KgV41BkGs9DICu/lB4xHbEDy8x6cG8iCBr8Ju6fr8sZ7oi8kAA/eBch59F9CJf0n6IiyE +et84crQUtIRtFV8Qp83Rx8loq+GsLsbIGBNk8tmApNMOXsd26AQ5A5xJURDUyGFuXmnzFCX4ctm kqEpTeNYOoqpb2FOUcf88tyIsu6a8YwNjUQG+wOEsTSr2s2LrVH0q0PYnaPGr1ihpAxer3KJ2VRo cihCea2rVcblO73EYm9D1Wc3Jj05deLCu5uKVq/gxyi+gXc0KM4sHA6G/G+5bxTS1uRb3EqtYC8v 8biAajV3uzkAK8yE8MlB/UigR7NEcSmHCbIWyXRLNBeNYW2EVafO7KjUJqb0javVvlvYIKlAkri6 48HTgD3hvklsDMCneQm6k8FNW2easjqvp0Gb0aEJbIyQKffQJ1a3BrRrg/o1SsPCFySdnEUGPZ1k dspUF02tLZonV53dStW3ctBpiw4HjyaYMxqh+e7qJeXzZ7lzcvGZW7BwRj5gf7tw6+TiC+FnECgK O/s+iZlkbaUsfCaEyPx7bkM7t5s9oPjsbuxofTuxhyoTvNVJ7mbmkfKnNFM5e5GUZriktma2sgcQ QFy3H+QevT9zWjNZ05jL7OQbk830KJ3kYjDncXRyMYx+nrRlK8E3clOvmx8ccVkol2Yg/7fYk7sp v9fI+u1DxX5LwmNg0xuEll8/QRPvMKTJ3vrfO6TbHZMXbLJ6031jyOKDawxzC1VvXu8AMd2s3l70 5FVBewNTldxbZ3Xw7GTAzXBkl1edy+HGzOTQJGfceLhixe0/kqRhfQ+AnXUGH7/cLSMGpH03Wz0C v8KYP02e9Whh0VguttXTrd+6edaN9Xs/mBTd0Hr3xWVMfjHHjjMCV5/ktd4TYLx0vPmpOp6s8pgM uI2RBfabzXCTEjILnN7cId5aidHw5BWGirLdxtR0kOmLAU1WlxFoHmM0gbHXNYxkT7bTJq+HoeEi YYQLE8yTHP9G223RInGlBPcbWcErZLW/raPF1s5G5JBdTE+HQ2B3HTvgjYKKiajEbuXEQZUJfIJa ZhWt2mTunkrHJfDjDJelllqVDnF2l4q1uac2a9RZSUq6mK98S3YgnZxHiMvv6VMn4SiXFwJujfTq mDdwJb9p06mKarriuROv0s3JqUgr+xLW4142qcAw2kI16o5vQsjzNLEmM0kGoyuBKKnQTSw15/pE WS1bjbrTyapZY3YlPZ7K3VCKwMdxbPt/a5w3I/5IM0lp0PMZskqqXYmNnHXf4m6BYFpwbLcfkQ3c 7KEqCTjWSVzub8UG+lxu9fN0ILhkbfu8t142boUdTBNhhDVZdvBnl6dX5wIDA9GTxLar8OdHPRYx Dzy0HpCQmfm0qi74yArEVQjFoTp4KZAPXM62TEAArF7fPW4V67Bta75IRuF6UIdMCGW4Jv8YQRvA qLb8pOaLoPXcECsmprsJ79l97opgNvQ1z4N9gwgj2pyfIuCjAEeu3rRuzbopKGkCa6S1Fh06G3I3 IGnfFfPHblyMPXJISuDuXWTvzHNM8CV31Kp7mNzkUTLfDxtkURIHb2w/KhF9ulwzoit4rvwJ4rJk du00dwRMjUPk6hn5/OK2qlZ+Nd9jYlrxGyarubGl3gkhlhl8HcQ5efa+rWCtPMDaPbW77Ng7CFgL zB0SW4E8WaIuw8nq0ErzY+x5r8GkoMleXGqZ29KOgwbYRN0a2xn/U2YBY6f2E2YIs8vXwpp800wN TKZUgk4GU1jMQHwtM76OWCFmgXG/w8xwNdDm/6b/dfk14m0Jlg2z1bJeCxe2OhdeJwmVY/wLu97w beJ9ggwma2tVpWsTadcWw2FcrjZYH03UViejnUpl5yarOzwMPJbmvIvk7LKdTLt8LwfBTMcjzjxS t+gVrN/HEDsI7LUOLqOw91y1TA0+++p71ALW9V6OwjfxYCPjRI/zW8xg4Ku8NAFUQK2ZVoXYTBuP 1nhZof7LTMFU/tF7sVW2YXfxAtdKe7a7nza/GkZe7GtWFdd5Oyygoz8HonksAZOEwJ5th8yBjksN ar+aite6eSL+3k4EUJa/Ksa6qK0T3LylYVrhh7xORlSX3dih7z1x6BuhMG74RkSfppoxv6KCcTKM Pp0UqV0oNO4kc0+CzdDSOC2ztp4JaZoIHULH440ppgSEW1taGacexuXhw3IPsVyWt7FC+8e71NJW GaIYAdFXXNDWRvyPM5e3uIr3kfs2dOrfuM0WCBzwPXmBP96KrCQ9E+KtVsaH4IX5rn2ZEhpKtC7P eqyzDzpOCCeUwemauUfs4xf5dkedF7m0OWBGNUBIqCXA9YMABBhRUsHaRtWa5fDDDjWYAD1YDp6I V71IZZ4et+1jvD/f4fFacwbOUFecNQABP3uu+0SO1yKvPHZ2zp3D0sHQsW2PhhUK1uzq89q+YSoV l/eIuEc1K1Csf2CuUOpTEdlQKu7VoZQC7V31au5Hdc2HPKtDQOThoQENhwXgkxN+gg0ECmDccbtJ LRv3BAtputHXpLfacHvQ64Q3tgnFh6LDCGhfaPYfYsC7Hxzidr+DFvc6oevlrNsoRqvlMXIry82C akRovCOunYPSQ50y3FmGPEGR+Y4gXb6do4qFC5rDV1GNx6L+aJlniro5zuqQ0hxyN+42p+cME8PQ ZjJXRNiuE3lnVVc8qjmuMJN1VhsYsvnSJjvywK0zHaY85QrFC9p9Flc1kmRzb1Q6r+QauwrZv+2t 3ojSs7GtrTB8x2A2YFxRUmf67s5uvNd7YzumGsdpER5PuZGhggdR+cIuECcw+LQJZkPvLuu+veIc k4vZOJvM08E5Vd/CGGe+JNPr5kg3KjCldEOdG3y0EPoJPAlw1xgmC4Aik+59J4GJu/T0SbfxJnNF bhQwJNUdKLO6CR/Jy/NSNgyP2LH2IGFy+PaoBoU9Xbo0sRseVU6Eh1DR0+DtDKGjAT5Mwyj/UA2z Icpw4CEPusC9Tl/fbqhnOdi2g807MXoWi6yoqVtDZkMFCipOA25PkIANF5SDY6UVYRxPo8wKFyVq DSAErmkRrGgTIFaBie4ncjb7TYQaRsKqZgKaTaEZdxry6nvISqj94GgDYYdNPhPfaEaappxjzc1B QKo1dJej2quGp7Rx6L9iYpu6FmOkivxqFK5kFNZK+BNtCcZfvkE8bQa1OxGGXoUD7bM3KHFPYtUU fDUkVzYkEUfUCnakEWu6mk3pW30hm+yu3VHJ52+GJl/t0JXtUBYHuh/1aG9/J/lmPqMvfTy8nM1I KY8MvRqMvyP/52U9Wm/XLOTViHQ5zy/Yg760zp7VsN/S0IpsuSgNiDvuBxQqBqAfimDNp4QHssFE hq7u7VZWDIfE2vD2qurtVqAXgxlHqipQd3g5KEX6dv2u8t5ejSasFydk99tkv1cLiDa85b2g56TK 6Ym4r8ee9AKN0KwhvImoJvPDwwrmO895sQDJs2EibzoLdCNB/h+oMT0/T6Y0lzpSY3JG7xiyROz8 vxAdcP1QlIigFoU5CyzoSX+sWdzv2IDUE+NE7//extqsAmq8WA8UIa9KPjKZDcrMBkdPrOYuOFbc l65pYUyYoPkniWdWXCwuUeBOQ7uSyjdE9gYYAIgFOu6B24UNfDK9ytoNDNoBzDT7JgDb3IiRQn4L 00CuimmqigSd5eJjzIPxjtVelqA8GV4Rdluja0Uxo7RfhRF99r2qTjFdpLQePmCmao/4fVcl+nzi 7pj+fYIKPfoFijzzK33l74uVczp7CanEbJlhXyUjaUL62VkQeT8RHdWVjWhHx55+GhScdr+TbDJk gY20Oa/NMxferiph7R4Iy5DqbSZ8HagbEL9u/zrlvg3ypE3Hf0lvILI7zAM+egzRpoR4ED0TMdaF PTMxuK2qB2rgNmR7yPqo1dYkNXCaZ4saExmriaIQoJnrhp0jna5gZcUV6k62PGnDUmXDMpXAEOlU CMWVFGA92Yipx6pRtVlQVRWokBa1caTUYLemaPed5C8JTapGysB1yDh1e81/4BpXfPQr3WuGZYXe DWnV62rV/FXxflGK93rzmvd6OP+kmvcaVa5N61a5qLxURtXoHWrRa4+6vAtteY2qxQa0ou5C11Mq cC0FqCGrejjgL0Kj7dyci3+WDas2OGbyvRvScUDD6aNp5huDx9inTNUZKpBVEjownVDfvZkQm/vX 0p/T4REsMlq0pReODkrMMXsYddgW862oAqZUXrdsd5z2A/jQA0f68JAoHAqyy90P0nN9xFzXe49D XtF+2LvKvJPUrT/Ozq9HsT5Ro0HYGZzvH+xvz4bb47xY3mxfFEvhEH3wgAPRXe7urwFiN4DCkFdT QzuoqodSzEa3/8RbASIzzs++uxhS5M+QgbDhifbzxYhYOqKDZI/F03q76KMjBpMDEH0crrXbyorl hOWdSNNXz9Pnp/94+4K+r9WVJa9/+fnFu5fPSVlPlZ2+/JlW6quC529evXp2Sst2VdnPb16/OH32 7h+kcE8Xvnj//tlPL96Twkeq8NmrV+T3vvr99tnbF+9IyWONxDPW4YFu8sMP7wgoUvZEY/Xi1Yu3 fyW9Ulx3QJfP3v/y7sXPL16f0g96FC9/IEUvf3z5/Nnpyzev6bc+ffmUkL4XJH0ru1lkZIF+8/yb hHr/H/UDzCCkzZgs8Sv6gCp9JpV6sbZG2TCfDMb8/c8jVby4nC7ng2I0T+fZ7EgmlObfLsrpcpYX F1YxlZXDZVmm84+Ts+lYw6KFWTH86HyYTIvU0z/9ZOEAP2kUZCk/bL3KUqrPdXGRXQzcYorqeTkY pqP8gjCiKjfKZOEsHc7TWZkNySbAKCZYpWdkVPQMRpcXePXCrg5pN2Po0QNjjWMBy1oQcw9C/BOO FP1W+JsFkRNwHQRFQ11OZEEvJJD4ZlBwLZ8eYjnxGkmbuk1TlcmOahltvNBwMl6vw4+TE+YJlrAg cydbvCL7u023Y7AJQXEvhKIAKHvjJmB2jeNIlO/8gw/R6rejYR/0mNgcGorKaDmTqJjlgwUBsMAh 8Px2hN+zLL4xVeqPdqqUVF8cRSLpg/hzr4eHbFKOQIGaclio54zbE7uP19DDAiskpZH20FM7f5hK RHDz7fTqROSr4XtDNtFX9KLeeTmdpFds18DugC0XwP6lOwgWk6PZglY6n/iyQZKO6GVvdc1PIXa/ K+DRVUsUw3bPjBBU/Y9pUJcibFtqM7YXWY71FXTZYD64og0sPxv18Ynn6aVHmUDusHderXzRBIAO LyG1xe5rcCWCsnTeWAQporDAPWA2QGJrWjeD2ZBPwIWXhFejeBezkjQ7bwvKpyoGitJYkIvdn8cv bUfDueocgbcUEg+FKS3UxXWyyNpmkdr5sDHqaA+vyexatxX283BIeVaZlo8rqnlsZfoxYFmq77u2 3eF2CKoqq+7l++VsxoJCyZaNJvc6IPuodruXHB8npKBD/3tAty2w7OSElLFQKdJ+PL0W7Xt2+x7S vme3H4xnlwPWvm+37yPt+3Z7Zhew9rt2+12k/a7d/kYD2LMB7CEA9mwAXJjR9o/s9o+Q9o/s9ozb Wft9u/0+0n7fbn9RDmaXrP1ju/1jpP1ju/3ZeFB8YO0P7PYHSPsDu/2wIGKJtX9it3+CtH/ijH9Z DPn4ew4H9jAW7O24PEQYmoNwmRDlQs2G3Kh//KhyYUmDQh07zC+nJVctNJ8FrZ+eHdm1U+qs2O2n oNJiytZMXFW2PCmGT3qVGLIj7jknBjWKoO1gVaFrLliFz2qwCl84wSpcOASrcPYNVuErJFyFMVGw Cl+nwSpcFgar3OCjbpm1+JpyKxnVBB8o+9ULT3CBp2LL7nwwH+a5r7IBNrZmCjHwkCaFwzGN+35/ N4p3yQLg3JtyzusCM9vXayq4uV4Txt31mrB5r9eE0aNeE7Ya6jVhq6NmE7pa6jVhq6deE8Yy9Zrc xFDZbsQWW1Ubq5VgVtEqSbkDFWy/xt7VmMrVENmYutn2/fwf3tIJ45D79Pb3K21I/45PLK0jq4gs HbOILQ2ziE2KWcT41CwSSg0WMda0iijrmUXCuwGLhNaDRTcOFkqPwiLRkpnyT2qZ8n5LnuykCPhK /7esxjfffnCTbDItP0pwj3Yrqom9fJWnfr4Yp+XgWga8sxtseuMQTjrsa+vykxk24HtxieyZefnp jO7V+Q+7A5Wl81C8nK3uYxyTfZ99J7LLHCbuv2FgwqycLrLhIhsdtnw3rX5mQMWmFj7Yrd9PlRtE BF3sxagbcahD67R5/nV1rIPBuG+d82wZj+ewzIFJLQAyL6fIQ0QvUmXFIphd6P6WQLgLGuhbENj7 jEGUjl0GoFNvY/rgQdtFi+Uwyo1rX03173afY4SpAVHlFDVwCw3CSDlmHM7t71QsfOZfcK8TPO5V CgzcbyYIMhvk7ObtVjeZLUqaKl6G96Qpze1ImxJilB/TsyVNI99WtRKZ0o00xi7F8rRxqnq739t7 vHewu7/3OPmOnd1Pz9ukbcd48ZrfovNVVe6n68tcuEhZJzv4zVeKmZqjNsOTv5EkPGht/mASf5qQ w9oyMHMvt1JY9wyHF5hdlJa8EXbvivf4HRmue+UoCJEPZQc+pEzUwc7uepyQF/S6EujS4ocYbhB8 oNkdbSQYR8zIDjunpucSj9YbgArr4r0j/XJ+mEks2fQLb+BMYtF/vCoWPSNmYLBcTFNCHvrQmRkt QGpuUR1BPiqGttQNbNwWDQiKh6IZw5dFDAgJQvD2moOR1ONqWXZs6NH8ijQ5bMFFBbGXitO+dXQ6 S4Q2kVF40E/rGXEbNpFvRewIC7ottKtBAjL2J/2IsRu9yD9EIAUCffCwJKiwm4Gyn37UEoOPOWH8 geJxzL7Xw6a3V3PUrq2Ak8HViRmPnoJYVCloerex1zC57qsSdwgYBVGtEB4MPhwxoEexA/q3mmA6 WyPSDzGPxaLhoPZjQcH1gFmL3NyTLKNtR92buezg8rLAbZ/44RnIH+yugLzsjaiEyG6ePF6jGzW5 Xq62JY3KD89EG7g8TH5TIVRlzdFgkFhBBEKQOT+GxR6aT04/mUMQ9CfZMLnPzrrAx6be0rEvPpMx 7e6uKlyp9jqGAzthJ2zn9rCAnCNfH4oBwYi4agkW25dNQt2hfJxg+4Rx6LoE1YDxnBTBbU2VQJTj NwwFLgHbiPSTnSG1+YiBJFwDiXgEwp3fVnhspGulH3WVm7ozzqmfKZ8WdVwgsM0usvPq7fTqgXD8 JM/KC+UbeZfNl2NiaQvrcVlQu1W2T2BgBG2WDMqLJbCswFcOiEoV8h/xWdzwwBDoKQzIj74PnbM8 jE8vYXk5Uj9aFHoyp9Ejo7Q28iGzPJbY1M4Vo5mNl3PtZ7LGxtNQ8f+fsIFSQxbE4Zp5nq28zx+d d4zpsycP2CO4NKbgCJsGgNokL+4Yt+143Mic5MRoz+4Wwa1oBEf5VT66Y+y+iyffdLSMZrxWM9j9 VzR2LAYz08gtUdwi8HLw2KZJajkKZB0/3m1uHWe/LwfjdDGtJimNqOe4s4cV1yPq06fxVKU3GT4N lvfisbwoswHN1na3CJ5E4zfO5vM7Ru64LvH4NN81CZ/WouEnwfEY4khP//vNCYDx9CIfksU1KEZ3 PCr2xE0k5QWS07teYP/6V20cibwKqoBY/Bx87kEl0H+8ruX8tsxGOQ3xPmnxEo4rV2KtxDsGvZNR EA4PDXOUP71LrQPj/FDXZ3s88uOopQ8MpS/TQEOSRLW8D84HKQR1PuijZjW2JrGB85sQHHRCbWwf FwBSihMAOIhj+J1wRw8dFe2ow9hC9O4D0RZ16QavFTGtYp2482ovIJRUyJ4kGPGPAsH2LEEo6/CP Md4NMRBCFS5TkEEFwGB0gbKolfgZssvq1eNKgzQ2W/bj2NILA/Llt8luOFYkQj69YTNBvgNGHmVl j5GlWjip5vXZDwUC9tMuZ6p6hH/kZtyBgDANf5ICsrEapJwNBQBhMJu1wp1xzlL+wumM8X6X49Bm XMfWQdXwW0lolVTQ3S9tCT4ME53g/paHxtRCZ1OI4EtM9WHE5+jVxqfyGPIyLfVN7znyBBZ0E0Wz FfMnKdeQXrkuPm3eq27AmMKnXDxrsl+M6q7JmnplQ0sSYwzfmuyrdBarrkm/uL/DRelTXb6lwFQN w6bZNbk+HisvSTKTzpL0ze5KSxJlK+a+xdekhRBYk31rTdK8rAcbcJnzn+INynQxTS3nuXdDw4BJ MM4iFL7otjhJ7bRp/Q5cW94u24LxlV3nrwm6IXTifRgn/9LCkxVhRgh6EoDttkBj//YPI6WMAfKh a9OMniWRb/gooOUVC1FsV25XO61wOME+t2Cz5tmCM/Acro8nfFzREwxvcEcSQEQyCM4idmWEuqpH 5Az1RgH38EyPuxD4mQz0Hli3IRVAba8nIXaqmB2XuWLmoBXgMU2FBOe1mA5CLAdcJOnLERGH+eJj pY9cnizcN+ju84wIx0gCJXW8X0W7VZA91CAvNfrvszHhY2JB+fGnDWAmHPpbKjtpqCSB7+aA6Ve/ VqRPrqv3LfTwI4HL3V6dLqJp1IfexDgaCaXJiNTCiAQq1KUSbxomkw98NJ1gJ8xH96i/rqp+ly0M M4b/OckmtGEa9DNu0cXJxa/rI1EQqERYsCjSw0P68ux5py1VJ70uTn4rzbmwliIPp7QXE220fUIl OwVF1xWIfTQ6EzU8ohAfOessrR6/WvFBKljQMFrwOjEU0V02Qhfevh515EjK7DzMGzGswYCswR50 rZQYGcqHd8Mda1EBAdUQezRClzrcAQ0Ki1N6kEDIecoWU/MR3NJDyQMN8Shpwk0RVEkb60ca5UEi ia3GqiQyOCBIKChsKshlA/URbVWx4xCwZeewXYWIjXGbtSTRE7xYhvOtyTpMx9ZimOnUqvwEPNcA uTCIDTLdZggY5jfEDjrmtxfZxiFoErH7jVUmEcsjVa3zWLWgSRTU+UYvYW3ntX9ixg2kU2D0timE 0MDPHjYlfKZQXXrU5QPG3ZG8EMMKfLWszg6Wqg/p+Aa4oanRY6ZPM+ywHj2quCFs52jCcHF1EmP4 VPNIDyWOVwf5ZAYmQquUtUuioPaJs3IcMoUCBmzDJ5apAkRbVcg0SMC1+MxahBFEVFo8htl8q7EO w3l1doWy3gS/bYZcqNHTHMM1TECD32I2u8IHrK0AVoOJfFFmWXhMZbXMp3rspvTMid8die3ftkVi sBDUhrh4wdTHyNSEDj78InAcZSwQ61KnHkaVVFoVO3NFmlTrAYhdriG98yjOply6uUDWw81RT7Uw rKJj09haYg3HFZ/zAEUxYI1SFeugVY1tNXXDmIvcu7sRF9QqbqedDeb5MOUNYrPq22128ZdGezsH 9aDUeR8Bljyj2TRgFgEIWmQSQFLs6EQBDGIiXkvAXvWxez881A9+sLgKtBVHLBHPEU/LCtCstswH QiGrvyrb0BwYGc2fLlpavyvbE27j1RP1V2UbzrC6pfW7sr04JpXHpZH9yVbGL4fw6UWxTIc3N4eH aVpMS5o7XuXSEW26BpecqHRPtWAZWFgQa7/d7URCpT6cWOKQMrvKynlmIyN/nqgJMavFwdJQ3PZm Vg6aLX237jqHb5u8y2bqbnQLxqyhXKBkdpnR+B/+AOfh4XRxSZgifTe4Ts8+LrI5f8OeJybprYKd 9UKTXpTp+3QyuGFZoI/wuvI5lvcpIdmE2ODjIz0wAOjnlD8jdYR/HA6INM0XH0EqgGeL6YRgez0t R7SGWmtz0AF4vIXdB8/npJvBh2zUhm5tM00OBJUcJzvgEjYKcE4GGA/wxAIIcg/w99azhUIRwDKB 0MTmlVAoXoOzcRaEYyLDJ2sLQiK1abr70D3yMmMrfkZ+8tToAgy/Us6SoSO9uOlDfv2trV6Rmgf6 M7D6ldT9rWoQF4QQctvFlg7LTEL/UM8wWeV9X7oS7o2+Z/HSfQ2Q30i0geh//iLwZ095yVeHxtOC xuZxCB2Y6KRlLysqIsDg3qdDdudNkM4aTufIzyOjfD6bzjOXLvjQeYaG7IbImOIio7e80sFo1L5v cFSXZtynt8ysnFy0u4zIlSlNej8wB+jFTzQwByTZ4qiKawV9Q8lnCCpchmAD6WF5aCDroYNAcOGT a4yiC4UbgchWogIonseCaoE1Sy/zEbsYyn+6WQRBLfFA1RZ/rQJhck0RCY/NTJcFmrVZKyPphxoa qwBRNbJOoS/66cEW9LVI8x0F9fGEPrVpK1T5+t5yQUWZSQjKI2QmaAKBI6dnQ0cRNbn4SOg8k8kE f23LzHJkNdH3GuRPNkZQoMB0km3CEt85xb8pRjSnXiBnqQUowyTuLDEJkGA4HD2fM+RFUQsaTyID pS6UGoyJZz7M7rfbrkCnrU9UP+1Op/Prdu8383FZI3EoV45n2UVetJ3DPJ2zU8EDqCJwsmIUA4VM G09iQqfHBAqECzM1Bh88SWjuSepsn5gyHgo0ASIlUzLSgiAwguFlNvzQhoueLARrAux0QlNqLBjj MUQXE2z0GY50ep6WVCa3v4H2G7HQRb/fuOnB4OQ84NiAUXiHcT4dj+xRmLJsen7uGxa7FUfwJmKd Piv7lNcmFhYcI8uAAbAxzED6sJBsKsH8RYA5rAADloo9cvZfDhrOpZN5RzhAZNrRE1szmwqMKGai gdiTlXO4ersaAvn5oWf99hge5+Rr+4g14MkEPvSPaGpTBoD+d2YqXLB9PzwUT3Zusd63aBtMebmj CIwhN4eQYyP4wwbABk/qPzxjGYbYj774gTxEGYeJudET+LiFd4yV/sFmWP8CeBhzxMwVhQtHgnHx h956pLFQccrWRMgUrFRPK1vUIyLIPq/nlPS1QeeKaiVnW44lfF9TQSn5tqMgtzwajRh9iHGghwfM GvX4EnV8yqdBgbgF6FnJNI1arh2mjT2kIiyi1clfaunGVTcpTScDc8UYQpbIV2qnbb4jzCw9ClBD c63FUgXalwOcKg5u6nZCgzO6qQ/EGqJ0gNCXCCqA+RROMVsuXK1jdGpWou/jZfQij11KDCnP5cg4 1P5tsnzLcCtIo0luLFX+vlQ5fU2JanCRJ3U6tgL0wuZdCP0mlkc9+GCyA3Djoerp9oFjslQ8Ho1b WsI+cTd40nJ1zBrMoratUlMnml3hWwGzRZS1zix1B3EM8xpmfNRIwB4hdhyB/YLt6JXF1tRoF5hZ XfA+wwmCxb3QFvDQIGI78nVhzE8F9gKdePwrpyC2IyuJtZKo4Hcbu2epZZBwJgPDyYLBK6wLRTq/ ETjEwCBbMOAfR22mMmPNvToDNYuwRlTayAye7CsAZNmx1hika72CFsoD7xtHVl6ZOJX05KG8EL4t t82QiASek1lbjjtdY0l2RUJ69y12ZrW5KBubwKfSv21xr3DytWz3c1KxQ7ecN+3Or6zWb8a68wF3 YNcQ706HuES0Ox8sbB4JORwKmsFsHX/DYPFNGPXCRbwS5RCyTaAZR3QD8wg74EEt82U2o5Kzlvny IMp+UYBrgA0ZMByemqB2rwNsGT900S60pVmjtbvxMPcGNaD7NxirAXE0rT0vXXPPLZQSbRlJ0wjF scJ2Qp/NSVTtjQS7yotsMEgXC+TITmomgsgwayuXbjeBfyqgHAquaGbL+WV6Nhh+gIyqPRgR/fTi eJYb66vybEXrSp51xJ5z8k7B0J/MG0r+fsil4RHqRla1awtLNhAoMMWYtDO3YBgULEunxMlxv7ro F9m1Qp+D+QsDcxgC4932PYRGvaCo6sPdQVTOWUAS+DWSwEsbhRi1+RpPs7Ik9m8ltRls60RCBRz8 618sk+ixgfIJDc6mWOvtmrHj9zfybIvYi90GEMM8pCstnQ/OM+hatxY2mwzhZweDM94YNyJecJbh h4cU0rYenZnzHzD9UzhbqF+cuzglIIVoYcGkaGrAQYiT6VUWARHZZPBF5FQDFgitITcVOpYGefnK eiwFviCxAvv7dJhafGvoMA7Dr8NalWoE57fCEfHrKUEx1saVII59jBrMC7LfWrTBCcfMdokmEQqS u/dna9GM3UZA8Yl3SkJq+VHkzVn9Cs4S6FjCQx1/YPoc5zUBSDYXynuna+jc5rGxnLRWy/4mrYX+ OuYCH+mq5kK/IXuh7zEYsMl0DYd+bcsBn1/3rG0lK4+PGSpkr4nXyIRxmKxb16BhFC7qmjWeTu7e rOHjWsWgAVYlUlgd3VzDBqqygmQERMAK0v40gfQOaoWkc/7EFqAPAW5V0gfKTmXDNAe8wwfJk83P IiwwLt2rbC9h0tUAyPHwgbXA/OFMYhjTGVsLcwuwtx3Bpa0bcQAaPVIMvjowb2uZeQ0JqwiNKIix qv3nQ6XajtGh8QZOMtCKG+rQqol76cs60MCNGoUNXQ/Sv+4ghu1bZnzFSvFxFDkKxN/WQncSMHbc owLDgV/+qSIUmDtxHdSz38VjB5BXK3Eb2JowEWOmd/CdCuEKN1v+s0/7rJCNBs7rdJ7TW8Hhecz5 LIq64ckE9quo34VtHzA3VAj3OnNrz2pemwBiz5Hjm5gQOVjLWFoYW5sGCBA9foynJVpV8qfunsGY eiWEDFuz3v7Bg6gVRVXU2FBU7Sj6YfdmHOV6mAUcwKPofwYGsRhaeAvT43uYHt/ERDo8qWATLQWQ v3Agh14gwBbf1hB8Znm/rl2OjPXLNcwjbHBP6C8nq+2n7MMrJswM5ci0XKiISye4X4C9tmL3DP2o rPZSgKfcJrOoTrZi8jt9aeNiWn7EtGWzSz5aSvbWNCejUTSFTj2PY5W9wk00BrX6kEnCBWo3N6Op 8/46+idnJM37DemfIJqtqgu8MY4Q/0BMC4MPi4m9vAc3j83Ruw4HG3Ren4HD6G36yHe12Xa8uvxm g13Y993nxEgpw86t3rzCzhqnR9rBux2rz0J1gP/K7Nyq9CUF4vGbY/vwbYEvbXQxF1Y2Oibjeoka mnsNZ80JrHET5jMYLkhqtbbcAmKkYukiogobEiK9CCxalmrJM7jwi90fp+X1oBzVHwC3citGYUEP jAOpyaxbv7qgVZ37bc7dZnrzqOBXlNPB8qYtGoKDPvGTXjtwbxgE+IiYxwNicvMrtuiFOCcnBqIM 2CgQLZCkp4ML7HY3GFAbHjd2GbqsmeGguP2cKUighgiIjdlzL5thU+WIMy516zRAtDU9sO0mnov/ DZCuLtkiOSp9OU/ptbGLrATcRP4iReVgnKi/KliJzyzCTrK9zVPrUWYt0vgmGRd7XsF3PVphEkUr har+XQvXcy7tPDIaxcRcBEYI++8VN7g6R1FXFvgxkP/+GnJesKMSOrrhH/PrwawNtcixTA2mMoKJ RGD3xSGVESluDZ8BsW9utFq+y4G46w27cWwGMHXd+KVA1DUe425hDlMsIPH5wHI0846JQutumgcO SzDhvz9xnlfHDyMRntbkBqDGxI8CfsE3qwwe3/RrF4A8wkM9ASuOMxoThUDMdhlFBi7MiPVjwyjr 07jwXwoRJvT6dC43w1Bl/PzFj3KtOSwjJhGgElwq/GQpnZ43vWY04LUXj41jw9KiDvj6Q197tQJo Ucs2KDyGAp3KTuk5Y22uqOR/A/T6fGEi2TRbxENfZejr84UCFisIwjIpmjU4PxbTDUoNAbwpyWHg GmQT71ZtVakS3fVq5GlKukiI6xkGmi1X4Y4aS6gx/nCRXYk9cO5orN9VidOQjIliDszgcDIok16W Z3TPFB8QteFcXxwf5P6tkbCDRb0BDiuQSKliofZbk9mgzEIXWfExRUdrGFGtweh0K1sQqUe2j20d NTAVwdqargXNIlrSrs1oTD4m5yBU/yLgrXiIe/SxGWM+So6ojMuYmvlv1UueZQR1Vw8+spi0EvRG w4UqkUFuK8smqxIHDTaoS5X1Y5a0mBSJO9fO2y7fmI/x7xzysxMkL88h9F+0zQRZD2GO1K5O9MMz fjYxhijkW8bdc0TSBN1a40tnampCKC/F2f4fiKT3tuRLpM0QUKKCixF1s7sEn5Q8IDXks92bIrFs ESKwZu1aFLRAS/odfaKxKDVOB/Gp0K6zUptmdnsyv2xmvltKap++QzV5DFSDeqRGxcsSsBZ81IIb EUZjo27M7NjXAypnq8npkgl5VAK0pw1I8dXFuB4wAftQWXushk4HdBfjDwrZJgZYGgMc3/kAG5hg THbFzeAmR3jvc2FhZIbv3cEM3/uULHynA/wULHzvLlj4+FOa0sHhH29+epsbfO3JvcPRrWjEr7M2 T+6Ac08+W8492fzcnnw6zr3D0X0Czj2+C5n7GVu+x3egVY8/pVa90wFuwi6qkLx3YTScfMYMfHIH 83vyKRn4TgcYYuANCeANMLAKh6wXDGkOeZWB8glkvQpvS6MO3Zxgkw0mNjYn983JPGlXVKf3BFz+ jA8alTkuGxrWNGpYx8ftiursvG1dsdP04KxJMMd2kS0ow64wX3XGA3yao2ycTzbh4f4MhkmGxV57 3ot47bkVeO95ML6YlvniciJfed5/VF2Tve1c9Yj0fDFOaRv9gPT+Xmz93Rjgl9lgBoDvxtbfdZ6l 9snjd4NiNJ08Gw6z+VzeGoL88QOZ3UExzAwumnGGUWI5TVmuXtp7G4Wo0o64l0llB6TK5XScvSxG 2U3XKF5MZ7L0dEZ+sxsnpicfVqfKqFgkT2m0hYLInvRLvktUvrjry3ycmVVOQF/0mc8tmcWEX+Zn YDssDwTHAMRBmFUVyA7BAoUCEp8ABJ6qCvB73HhkRqgAJgLv8FEONnu4Lo6d8sT3Waed+aMVe9ML Re/wUF9CgsEbf6Olp6HTmlj41rviLYR/eT8iGMH8j7k+FFlgy3ab04Mn/6AV+CuUdrUd9G6WHml7 SwPqdeRlo9tGF7+JAdA23BBcWTZ4ZEFQZKCyoatwoaFf5K87EBa8oza62rtKZPznyIyujzE2IkZs JgnO/59Iynxq+dKVBN6EnHEEyWD0z+V80aQoMYXBOCsibQy18p9C+EdIzXlG9iuj50SAjEjlfrJl rN4HiIyBLY5FlKIVRmouWNCAmifwowWO6wQjvhF83t4+qi+cYOd+CQVqwUoucSyEH4C3uaW0Epmy YNOnLpkiB4ARKGoYtKqNGb4MDbMWKizBZOstHblMbLFKIx5njctVb+Uymy/Hi8DqaUoo6sUlqb8l e6dTK0al42cMmeFIByrvwC9HRq4zSx5118CsNK7ODCXmNWEV5mZuR7oSrL83bY62UPuTWKYR1uhd K5Eaxugn1iqoCQvle7dat3xVLp+VcmnIPgusrM9P73Q3ZP1/WkXUwjO/NDnL4W1a3Ky2omZNpATG p8na2zSt3hpUZ2vQ3VJLk8GH7KsvLcqXxiW0uTyIRut3xKmkoy5P4V0yu6WvNnSg0JbbpIPv+uqu kVCrNO8S1Au+VS7AdZV5YHKU4+rpuHmOBT7sSqs5UO3v0Tr2dnOCoBFW/Q/31/wJeNhzr7iSsy2Z eYccbonc+bRcNCZyLUllG9/WTJ8Q5aGG5tND29tNqvNmhx25fJslh6ttb0Nnuc6Baz/uyJVS+mx5 XudIFzRxD16/TR7XAyCnOvHkluwmopy7fuQP0mpaDsqPKQFEpBI98mUMOVuUVE6lC3pHdFrmFzQZ F13CR/ZHUUbgbtGfHA4XXuzhN1ImMmhl4mNbCg4LNH8+SMBLNDB6aV7IH5F9nlY+SdoKj06739t7 vHewu7/3OPmO3b+l9/hPZ3prKVqRLZ2npuhBspvsZEdLOYgQbbLVIWqN3YsVtbeMno9aRsZ83lSz 7FmZDT4cmdh991TuwamguoU0zIt8kQ/G9CqXoKII1Tqd3e8ayRyTP24j2yVE1XXNVJpisMtCt6Op M8bjtNCD6Ap8uxQAGydBFeS30/whXh9w06bRWeYD1JXL7PdlNl+QDr3NDE7k7Rnjyfz5sK7gRFCL PaCI1KGq5mcDpLUs2kiGVCln3C9MxEtBhlz1o38qI4Esx8PDy8GcFORXhOApqTwgu0Gdb1C9ySJY 5ZRXFPy6KD9CBuU8PtI7QuutSF3TWZQWv0r2h9lnXWba0j0IvNraX8firgaL4WX74cOH7tMd52WW gZVhPOsCV77xEnthlrHEF1C7swn8tzuDSub8QFisnH60uNliBIEMgiHldJmTGGUVubys8vtwXaq7 cuHaNF0A01b7dbQV+cfVJgc1IoxQu4GrDWHWaxEivDeTbJQPCihaWAJT4/eZ9XtoKXxo1g2Yt/Gs Y1l7Z6x4iD0Akp6ZT+YZgPAWQ+8je6rKQFYJgQzWPvPWHsLaLd946Pz3egdrz17VTq2ZKa1yzzhu Y57nlsx0B3Mqsx4o9WrMOATrabjixPsgxzQ68zaqwQaPdtZkA5WvHHLDj8tiSJ8c4+ygfrZEqtw0 GxABrptizxpr55xsTWuhc08gJu3kSJnx9+TO9Ch58ED6LcEO7lypGPfO+rm+se6NVESHbB1/6kot nTo0asAtO6yfrwNqV7VCqZENT4Xa4VgUoQFC99Tw+ZECNbg0eRTFXNLo0vrkeVuStU9tgyoqpfl5 bULRWVUd0C06+dv8vBa9OEDNNE0Sy97bYizlVAIsZX8KbJtrMVjJGqcD1jpAuHhXFXZwQS3UGZFn S5UxKRFeIitC6OQk0f4ivd51c2pXkqLtbVjoRKs4fI9OmDWzfxoQVl6w+XVO7WiX2JJowwFRObuH jfXM4PUbhtdrGN6OhCc2TYeu/mSqxfb+rbbELbHoX+lMLK612KuF5J9yzTvCu/Zi+2IhNLHe1+gY W+7rgus1C27Fxf5t0j94sgm7+Q6MSMyCbpnWi0hqbL+bmwrXnvvAmSK/3ljs7myEQHduRkaSi3Xn UozJ2GiS9dclGfAbyp2XLmEFg9E/B8OsWKR8jsFn3P2Iny4hx+BA6cJHnD0LyeqiyG4W+l1nI2Ks TRcu+65s8pBVt8Uro1t0SyKoVgIBO8wJQZzN0qOD5mYJsvb3eTEoP9oGQUMTiMYKWj1SzwArCTD+ 5zLnBqrAYyznf5MMcPB4k6I/4qFJz4E/M39ivSq2WtBR0sgar7T7AqiJfNTKv17PWYOa9EvjgW3G LM7+u9ATttfr3YEqWnPe4vVVPR31iebM7zKJmbC1nZJA1PQMv6Qu77sCtsfjErJBSc1k+EGOvGcK 154gg/kEotGLbGk9ntgXLfvo3Elhi4jbnpa3PfrMuQSvi/uIHOZN9YNcNiqLiQpz6CufKJ0n8sE4 w6MFoa6g6aiCF3tdFYVqPAFpYzFjLWZHINK/p1VEnzPbrHeEtadTMVyWIs4IjBjz7/U0B/fMiCNJ 46iBmAzvTA+qg9gXsLkjA+I3J3tQMWEjgb1RQqg69ToUlNgyAJBfs47xMKHsBZ9tlLncxmEUXSSd dxrBvq3nVc/wM0vT0O/fgfjATbfPQ6iYLTV2Ql8w3fGFCx7ArP61Dbz3bMxKHxkL2dZNNj97GP32 MxZkcbWgqo6kjxVj5CPZ7Z1NzmcjeyslrjVUAaLLZe+fR/g+2d/M9vglfxQXPR+zN8lc2tLwshX3 x7I3FnGwLJD9Umi3ZIUkUE81zUXmE4/GCf8fyPY04I8DVojvCNNkLTAyHsHN8QPXvJC9eu5u1CV7 5LBAoZCbJ6i0L5qDmOWyYeDU4cwfBuEdiAnz7hew6NaRXwWP1Q4sENjeCs9ACJ37iXwb6yDe39u9 w3XguYcaskvuaqHYDQxrpJ6/aeWlFLc0Qn4lO0oirAmrFeFnuzwdAuRq8J9orVrdYoOwUfPMZY7P IzqXnhHeeiSHVfF2BYHx5PEncXr0VTpL/sjbfI1NSmCnEtxuqG0H6m6CRiNwOBGM1N/AOqJ+rlTk ydS7d2uHYXJcX5svj3f7m/AVvlkukNJfKHe+YXG7OlZOVxWx2INiTggyWeU0ywAH7yibPZMvS7ZQ pjOPFK7hB+SzwnvSswJvJOveAnF4vDaYmPjrNVUT0zPVqSjte+YrpFlXmDtjQRml6HIC+MFNPzar LfR0B06yEIeeWV5/EcZMvcIB3+5V88Gm9hdOlqcyIy3pfYfVTCPDDpqOR/KCvFFeZNfVhy+thk5O FBJQ/W2Zp2DXZpa1b5OD/qPN0FsdYsRMAjsdWfms0w17utNZCJ2FVJL/0f7d6SO1n7bkmJwE9nLj SmrIp4ncap9m2VRLLs9SSv4C0UkOnXQbXkF2cHBwdzOrF5svYVH1zK8YUVNz/j/Fco3RW+YSXn3a n/Q2FD7yU1agt8sveHkdPQaAkSICILg3rycQDYFHQLdBANSTvXWNb5z737MHm72kspleUoy6RQym lSSj8PhDyRWEQmhU8Fdv2E65W4dAvrsFhGz7Tz4HHTGZXq2nIvC9Sr1AldW19D00zsT0LITyKkmH AVzwqMfclgi9nZ3dT6AJKqdxPXnv2XjWCF1ZZy7duOA7mMbdJ5vdmTjeWz5ZKxrGq62rqEMJlaQy xlNpSjV9WsVULCvzJHhR/xwawoc57SBC0IML0mfSGXu8u+G9TXDi1trURK4kdNoCwcqfbuIoUv65 A7jJuzYriUJc6lGPVP77cs0dTrSJO2XV0As2taL2YF45YYm6As00Y8H2UrnSlRAFDnVLNSrwGr4l U/0IMCS0SHXRcISrLX9XmPHqSPim5txcJ/5JP+f1QrMe0kvxcwWgwNnyzoZn6+JOAk0asPdos6aK ea3DWqYNTBi2RGP0XnVmNjCGw0PnvgfBjRSJHGyhGHrcwADS1iCCK8SVpSX7a8MrJr3e4527szXx Gw2fVvaGLz2sJK1brc9UbJsHoCpF6yeR4JT3nmxkn7rWdZq71gL12a9ab2j+a0SBOMfmUqQAvlld g/Tv8oAV5YG7VS5IrdWvXX0ZWqgFtJDB3T6l1N/f3fjFR47wqjcewSUoOB/m1sq6mudJkwbIWKHK 4ck4p9OTnU959bAuCX1R6PFc36pFYovdbL9pDLVxEOH9x/f5KC8zlqFoMNYcCPLQl9lVVs4J5Zyq oF/sm/80RUQtwTaBhA12kt2WGyplb+J1hD8tpO5qU1XYzGyGSTkxlp7YnAcPrPURJrWTXsJL6XUz ZVhDjEyMgcT5HScY5VBCKCKDJb+7t67N5GFPO5n2WjyKCEtDQirg7rKLuhnf23281zQZ6viHBP5C djS9imttS1vx0aSSn458B9rmR9frXe3z3l3bpH+xHI7zUTYo3uXFxYtxNiHSXUwC9kms84shkf7Y d5pksJv4PhWepF88/NW4CeiBwDc/k+S/EiPSlRY9tYt4AK+fmpOI9GCOYQOF3XThPddthbYnk3w0 GmfhOhjThrYiWpeYyoT31aH6RGaegeV2IDd6JQrcNVMtJVVHUzBrTKJuAZGqAssePMDvaxrIGDKL l8FbW3IercXXB6vvyDJZTIzRtdvHF++dDMXIKmlf5+u4Ri42AREJsCIsJMHKftHq3CJwK+JsHSuR q20p5E5CQ7yOKUgxmgBebZ0PHEKQDaWOrQAQUCiCb9itAPE34jSgnJqYrAosmVaYT437TiuPwRSw zj2qdam7Qo43L4d7DdOK94q8/B1nzlZbsBvj7vqPmsQ8cbUSVN87g+6zdlGvm5APH4BEDNcccwOB VfpgrYsPQuraCkDdyHAZV9H9qIVvxG6xYY14VBG1nlj4UvqhY2bYg5VzlgKE/UF3MSP2J9E+cG0p KibihjbiPMZYdAbPky1t9oFvmkzvtIPdPyV2/+TVvxMY/tPEEAThspey9TswY/fW0BZHbIvV3mZ1 7DtB7AubLPtiUMsL6YEgtA3nwVPOC/i9oZb3ElQVLT5QWrA7Y6zIT5BjyOMfKuiBjcI3Di89Ei9p ccKiBNmS/AOSBKCJD3WW6/1e0x5GZwMdsMY9BnhEprVoaQfxq/D8KrUoMMaEi9ie4/7aRwcbinSq 3IczjMU2vAahWxXnNWK0dTfhYidnexQlFUW5Q1QJGpJ0v7fusYgUB+YhhyyVVgg3A4rl5Iy+QAIV nuXDEWMb0xZ7B+2O3PGKwXOkd9f1yuBmk7O0ONbzy+X5+Xgl517AyPEefhjJrzDAICaKvuDKNaUV nJjjFxPzrqGKzGlhd1tBetYH+rVWTvb9nYbJDtcg//aaoeKLKV9/QvCYUbTv+4JAX8Achqcu0s9T J5CQvUa3yOn2ZZ1ckBV5oeN9P6GTRNPYM5KiYHejZBqTWIAV6SXdU3ArwaTnyhbPJmlYRoZrRqec rMwEsOoTAUHXtc0hTmWXT5rxX0fwTOzxlOf9R8+JVUXu0YiEAlWX8tD5Qw61rKQBrr99oyMAQe6s fcdJxWAiUz0A51QKObwOWdmP9w7uJJ5aGje2NGxAFtYLq1azBHpeKwn0OioCFprGIKI28oJf7CPV zsZZM1qk+hqf4Q/JCkx/sNfYnsJ3ODWR3St4bPN66LhdsE2AG8A+GF2JB+2AiU5fTEz6vjB49iYg T/fhJaCzEagilJ+C3qCw2PYVw8mKUdVgrN1L61OMRD4a7I5HbWHZxJhbWDK4jjvVoiJ4zdBs4d62 Yy3qHdUZ63OaFzVv41auXnue0sFoMFvkK98FWnH9xsDgo6dk5A8jVjcBffA27OlOn6w4fmrVg95J LCqzhyVLAnjyWvykSz48azjesJtoCXoVzfdGxR+2a0xjhoXewqP5ni+7EpIpaQsOpgpwHwcsfBjq VUtZW//Z6yCZMi1kfSczcXI6TlIHZHVguTQnrBuQ11BkrwlFTxhcG15aSUXgp1TSlCpohlCOSlgP WBW5YvXMSpoG1zWGZX1wR5a1myCwafuwnoEd+86Ek/zPeRi4rgfdc1S4KjjveaZxAom8/XtszpzG 5YQza2CrJnLgLc8firevT8zEe4p6UfLR2M3UW2zGYAVK9sPcnbowGRTxRrdYuGKcneqnWGOs99UH HDXeTkMvyIUfiaSR+hdLwj6kYzDKZsNjCQ6UTvnVdFHHsbMFY2RBa68LxutgEc0JoC3XmeK2knda rQjdmDdj1nKRrDzD3oeWP49J977QHMMF4jljmGqV88LqzCDeRxa4Yf6xz4cniHJ/Uu/dr6xYTpI/ 6KPyi0tiZ19Ox9R26+0nt0fryhAQr6Q5iPraBiURmfOsXLS9rCIYAqTG9kd/KOc8nAOWEgc8w6Sm k4DkK5u52QEHbckwJPkRRt+KL/YHu5fblg2LdXi0sSXbDI0rltz6RBdriHWFHYN8XrR3SMspSW2Z +dRD0cgj46hTxkaPGU2jdaXgNrZm2NTktj2oVpP1+Kfc7adng+EHanBCacbOOnN2nHnky16oZs70 IFgmWIDrdX7mhhSnb92tzxy+zU1oTf55WMiSDZhb6zPhpK6cibVDee2YFNh708JmA7GtMWxVFfxQ RXDVK8u1bh9qrbd6N0v+6rOs0ML+c0yXtVTWU7/nOTvx34gSNoOyaVAvsITNCwU2AloMqbgd2PYI pR0OxGrrmPy3LURohTBCLsE2pvCamo7gOolQfhubOkfOrzGFHp1RcyrrLCeaT9SMbKAlYu7GF22V cNQy8kXxBzPKjd1J2DmSr3r0RNbRE3qozmTEB+eI88OafKcHYFhZi3JKSZOOp9NZk1aWGPcomy0u iWib5JvXn2pfFM3CnOMBjvzhE8NKYs4ZsjJ9DORJHIEZR3RvBToL374YLgk2HlPK7wutPrrVKiVN J9koHxTar7PS+cwWWKsO8Tvf9TurgxWwep1Ox5AaNttSYsE5gVyH7nlJ/Yb2L3beYv9+5u5WWvfO baFPt/QQrfJ1CW5iCSpCm8AQnV5jdaI2QWiVfpv0e/v7d3Kj4TPcJwaeMAzkmEBmxF1KFy7fJFtm 6IbHRPX40+GMrf1s1sp70JWt6DsUoXc/q+iyi5ndCl/Nyo5g46R3gxvR46T3KHYPYxl29s3dqjvg hisQmYbvkr6+5odSwI576lTVN4N/QPVJVl5k6XW+uJwuFyJoIXCnsCIPjnOVurKBGrsxkA34jBvh o+CJau0NdF2WQ9bmp2c9B6k4FkSafWasWFnf9A9EsWrPvaqnP/aj4okBU3OCBXYOvQBH9yro6KIH 0xODKN/5IpshMb6wyuJ6yqoR7usTJQPaVG8TnoL2dr4RkQuL0QH1MemOArOJ1zeKJQJBKOJe8JHz BPQDOAY3wYPulI4lL/TFXneBdg2CS1hRBPAXu2xgDeZO2DtGjH9mHO+FFDzc/w9dGMEqiMkZWDkN LJw6K6cVRRT/KrJLbcWhQ4KGl8vigxzRYxYSVNsE8qoLDnzTxwiAu/VoPIn7MJYGjeqeKMC2Hl7S NVxuij3cWXlGYiTcJ5ykuDjATc5at0ISrD573dXsNeQmWEgnUdtVGa6Nn2M7t7EacDwEEnVhSbCy YGItGz/truO/ed6mrEBhQ1luSEK9QcDXhjvRiJxXzKu7ORa3WA1+dQwMJEe1umziGmKmUtp6mvSP gsCdiytOOus6fdyuy9s1TbA7ZvdNON7+3PwPpN6drANUfm9oPdToq9F14TWvgLcD3MBpWnMjiyLm xq3Lxa4ip0F9hgMozoskWNq+2XsSuNjroRXm6qm8CemD5bqbwqC86Ud9As+PbecoprkPwY5r23AY YUIJID/Y9xXhHqhVZQ+2XYdsFeUaXlYeJ4FPG31mi271CKs/1wKtjsjEZPc667hujw0ud1QT1V72 3ri1z3T5+6GZG61vk/7e7s7dHMs3eUjY5DnuJgzU0Akxcg3ZFcfwLnLoJjKVGOCyLg/GMbb4wVMi A5YVg1klZUT2cOOmsHE5F9waNhiu8TiQ+KiCNQ8Y7y644O6Y8jPlSkfibpA766knxsSPdvobkZqK Vc0YusjM9mG7I7Lyp4iFmgw+ZOllZl7ztaInKu5tiJczVEp1PMfoObsan8Nbekag4Gw68+AhL1jh N3F4xFJ4CJxx9nbuSvp9JryEVf1UMVrV7ObInabYTt/Fz7v409ErcJ+DbYALu5gYe7yRZ2Nx2YYn VIDMueZLsT4u5Ad94UCTQLtVBKLvTWJW3oyeh2B5dvU7tR/cfxubWEhzfiUXUtPOZmbcmw9MRZkR TlGOW9iHccnejcDkD+04UO45iP3hPuhm9OrmetN53nTFyuQUpgwyGBTBs3NU42k6oeNkFNuWCd4U OIPRP5fzhQcNw1zaCVhJdk4eh2zb1mSFYJkrBKT2i6AplH7RNLVZ0ZpEJif3d3fvQk7WzEXzZYjO leJwvkpYVMJ+FbGbErGOJRUrap0cS7bA/WIlbqCJ7VJtRCI7UxAlmQ/2N7sRLxaXacbfKK2zd0Kz BC0u4yrezRbcsNr8NwF3jcOHr9ftatx4FfKB0IelUibz30FftzeuzCHJWPw362qExpHF8rh/cOfO h0+1fsJzeeceCFOBf11tDV1uXQkEeiE2TtF9Disac+Q83t9QEmOVAtXOXjyeXmdlejZdFqMaiYuT 4bQgIydg72MJDRvNJNx0HuFWCzXNW4hJpuIEQIZq/KjEbnY5GJ8H39pA7h6weAHziXUGh4fD0a8n Sc84/66VDZ6CspbAloJxLKbRSAAA14H5orUn4WgC4/dE8nE2gm2IeCBdmWwMyXcbfBSKLJqD3v6m Fo1/J9/MOnIkl72u1j6r/JQL7T99eek9pa5GF9mXucoe7d+xalrOZv9xqumrXrJSsIqj10r+RZ53 2fDCqlwxT3Z6n14vrbaIvuql/wC9pNPTikX2Za6yvQ1vmWaD3HlixHnqPPt9ORjTB24vsq+66q4W E3/j6px7ofOLy8XXTVVivN/ajBalJCY1jR0OFpUC05Kb9NLznRUdc2Rs3gh0qKcoETRY1diGL0RC 1fpsW0zSqRQyERDNK7bAhbO7s7N751r/LkUU4rr9c1gCX0XY57hx3YTBUkOgofktNyDYAnk0PzsB 96i/WYPrbDod8z/yggayz7NBObxc71k9n6GFbQZa+ILN/Swj3flQQ+mH1MzYintQL+cGYQ/uXnPc Ba29e0WU9usQ3x96YE+CI1GMmej1HjUVJ2aka1KlfVjKY5JAgK0uaIH8ORqknJEejAqTmZd6cEpA j7JRv2uV0kZG3ijQv05ShU0ZNnHu2ShHVdO/xyOMODK6uO8LfuyDKP+eqYG2QB4mVR1VQn2vfqmC 10PhofpKxzd5vKriqWA1D4L2RnmvqyZSU99gzrUvXq3GnDG3hj9H1o0TPxYTy59NMbMVXtbvApb+ T+fpQBrS7/NRXmZDeoY+GEcn4cKTXDqwopJWos0iklei7WoljSImZc95T77veeS9xy7nJf/6l6hm 3dUzU5iCVg9AfUwCK08Gds+K1cNedrSufHlTqHqnhIfHOMlfsPrzjNgbI9XA3IjY9Oyxdz/wj/0+ /AhodCJJb+zAJDhR6TuYdsXaIKgM7LSJeR8fIm/aN/a18y0AzMzXLlBHX9HWHVTfypeABEd4RqQh dmUbN5WYGJFx+ODusLZQ/CBxsQ23SwUlkeQT5AbVg8RAWarIrp09NIzw0cTQNbuV9K+RhdfAH/RR mV2Xks2dFm+HEH1nZmPy/zLW37Z7liUKhfVlfHzWrD+n2F/7WakNqQjXU4TeifyqKT6RpsBf+Phz aAzf2L5qjnU1R3zi+I1rkDqPxDkzYuxvna9xueARqELfcKYBaSvcmlW6Bm8SnjO8TfCK3srqBSGa zlUU0Zs/V14AcJoVo4Bw5Ttu9tfx01B+LQ2NLEaxHa1MCBd4l9fzvoe9E3YyOREEbEe6JVPBKOsP KSZFnnf0JlLGUCANfGPyvucJsDZla5CQzsEKKhlZIxdn9OraXcgLp+KuT3LsGpaqpq9fcNC16l3v Pd+bdOjiUh4a9KvjSgvC23Ucw3C5CieZesG716niL8d75Lz0ACD3NeR+HGTU/yQh0zfp2De7oG/d IV2UywxxkbCq3EPCB2u63yg06IAzuoqiWQTdqJfORzl0jGGXIYZz34MzPhsRMyJx7lXg3PcdZ36a te0PvfxPWO6+JtU70P8goaA3xQJxJRq+yobPUjZUeZzCzxIENgAV9n99L1Nd/9LKpv+qSbAto/34 qW21h01cPMd7bXsXnD16bddqYxguBNtS7687jIidCK49ohIEY/Y5OiAL55p+tlW9bRE+twjPW5T/ zfFyeDxx3vAun08OAl7/HMdCs5Z/zp1adHJjvHYYFcL+OycecL2zH2y64nx5GBUqnXRov45jp9ot GHeD3efu6ncrvSo2IDxTP66Wqt2DCqEId52BbV1MKv2FLo1iUDL9hdW4bdBIqJlc/6sJ4c9zHtxV fPGGBhry+2cwOGpm84ihwlcr5RNaKSij/gdbK9X0+Gq1fElWi2c+PyvrJaAsWFDwo511b8E6PGeZ KjLZv9B2teyUmkaK10Kpe7XMHRO8YNbC0mYdrQXcunDWQlREKH8+cJ1xz5lY8CxmRy7+pwYxYMyM /+6aTx5Z4TdIS69kF64F/7sTiAENH55g7B18eoLV8D4+UfMle228ct3reY+ixjNABrzgw8uB5yv4 R/d5ld1Hj540vaCrY+g+hzWOVl7vhumXIwa+yoE7lgNV79N8UnkQ+5p70I9RddnHugcopM18tUs7 de7txFzDWfn6TcRNMvei7fmATP6Rff1YNe+B5sZxFnaDxkq6pat0jQs8aHYTeGwWfgCyzk0u/N7n 3c33SvewGuKA4PWraEawoPS6gB2+PH6ounY6zxbpsmBZaFdkjdXu8H2GV1DNld/k9Trl4/tSbrtW 9XIX9wU/8aXWz21hfI4XXE3ZuJEV84Vdqf2TLRz/0mBnEHNu8K++QtZdKJ9YkUSokQiDIc56xfhq kzyL8SqSqA9W+DyE9mfPmZ9GksfL8ViWjTW3/+M418+b2mW0Jmeux5efsbxsiil809+4yK1vBSCa PhCl/HkI1c+YcT93cXqHHN2oRP6yGNvPuvOPk0m2KPNhc0zcnH3wVSLfhXskCoHGef/L9Xt8sUum qslXRXEnXpUvar35jtSc1MrOqwuTwY1+LS82lyaeFtN3JGy9DmumPzGBq2lKkRdgk7YiJngd1Zb+ AgSeB8zfQ60tlSd7afh9i5UoHZ3D2pqKz2Au9PqUNq5OuLOBifBRPS/+XPztPLP+2fD3KpT+U/C3 /Q5zZ70pib7nYR2QF9nNIp1l5WS5GHDHoT8sqjpysQbvt0KH0mhHuUsNSu/cDKbJo/sQAOEz3fTi ba6Oqc+nZfvoyEhRguLF4eRaVwsw1iLMRVLs3Mozj8H8p4Ma4LJ7Chrt6J9WKrI/YLQ1zEqWUyvg n1YK9ivqMqYfc/RCpSAcvQaO2TMGybmYNsam4ePxT/6gBOe+85pBgA0zfL0rPXXk0H/YutACMe+K 1bH28jBhfl0jYQ0wIwh81QB3owGkCmhAAzC2luC+cncNDdAMw3/VAM1rAKECmtMAbJF0/4PWSJUX Fa4Odx+sqrGf53kxEpfTpufAC4o6QUM+UGxj10d3duGoac18STs5ShBf5BFwqOn5Zg3sF1fof9R8 9I9kkXZgcli0sGPdyd6COYu23Dp2gGvP2byBhES3K06Zm