From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 35149 invoked by alias); 18 Jan 2020 12:54:19 -0000 Mailing-List: contact libstdc++-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libstdc++-owner@gcc.gnu.org Received: (qmail 35135 invoked by uid 89); 18 Jan 2020 12:54:18 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-12.2 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_1,KAM_ASCII_DIVIDERS,KAM_COUK,RCVD_IN_DNSWL_NONE autolearn=ham version=3.3.1 spammy=colleagues X-HELO: smtp2.wavenetuk.net Received: from smtp.wavenetuk.net (HELO smtp2.wavenetuk.net) (195.26.37.10) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 18 Jan 2020 12:54:14 +0000 Received: from [192.168.1.212] (host81-138-1-83.in-addr.btopenworld.com [81.138.1.83]) by smtp2.wavenetuk.net (Postfix) with ESMTPA id 874E1600118; Sat, 18 Jan 2020 12:54:10 +0000 (GMT) From: Iain Sandoe Content-Type: multipart/mixed; boundary="Apple-Mail=_963CE16A-0532-4AC0-AE2E-5E40C23779D4" Mime-Version: 1.0 (Mac OS X Mail 10.3 \(3273\)) Subject: [C++ coroutines] Initial implementation pushed to master. Message-Id: Date: Sat, 18 Jan 2020 12:58:00 -0000 Cc: Nathan Sidwell , Richard Biener , Jonathan Wakely , Jeff Law , libstdc++ To: GCC Patches X-SW-Source: 2020-01/txt/msg00104.txt.bz2 --Apple-Mail=_963CE16A-0532-4AC0-AE2E-5E40C23779D4 Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset=utf-8 Content-length: 25865 Hi, Thanks to: * the reviewers, the code was definitely improved by your reviews. * those folks who tested the branch and/or compiler explorer instance and reported problems with reproducers. * WG21 colleagues, especially Lewis and Gor for valuable input and discussions on the design. ===== TL;DR: * This is not enabled by default (even for -std=c++2a), it needs -fcoroutines. * Like all the C++20 support, it is experimental, perhaps more experimental than some other pieces because wording is still being amended. * The FE/ME tests are run for ALL targets; in principle this should be target- agnostic, if we see fails then that is probably interesting input for the ABI panel. * I regstrapped on 64b LE and BE platforms and a 32b LE host with no observed issues or regressions. * it’s just slightly too big to send uncompressed so attached as a bz2. * commit is r10-6063-g49789fd08 thanks again to all those who helped, Iain ====== The full covering note: This is the squashed version of the first 6 patches that were split to facilitate review. The changes to libiberty (7th patch) to support demangling the co_await operator stand alone and are applied separately. The patch series is an initial implementation of a coroutine feature, expected to be standardised in C++20. Standardisation status (and potential impact on this implementation) -------------------------------------------------------------------- The facility was accepted into the working draft for C++20 by WG21 in February 2019. During following WG21 meetings, design and national body comments have been reviewed, with no significant change resulting. The current GCC implementation is against n4835 [1]. At this stage, the remaining potential for change comes from: * Areas of national body comments that were not resolved in the version we have worked to: (a) handling of the situation where aligned allocation is available. (b) handling of the situation where a user wants coroutines, but does not want exceptions (e.g. a GPU). * Agreed changes that have not yet been worded in a draft standard that we have worked to. It is not expected that the resolution to these can produce any major change at this phase of the standardisation process. Such changes should be limited to the coroutine-specific code. ABI --- The various compiler developers 'vendors' have discussed a minimal ABI to allow one implementation to call coroutines compiled by another. This amounts to: 1. The layout of a public portion of the coroutine frame. Coroutines need to preserve state across suspension points, the storage for this is called a "coroutine frame". The ABI mandates that pointers into the coroutine frame point to an area begining with two function pointers (to the resume and destroy functions described below); these are immediately followed by the "promise object" described in the standard. This is sufficient that the builtins can take a coroutine frame pointer and determine the address of the promise (or call the resume/destroy functions). 2. A number of compiler builtins that the standard library might use. These are implemented by this patch series. 3. This introduces a new operator 'co_await' the mangling for which is also agreed between vendors (and has an issue filed for that against the upstream c++abi). Demangling for this is added to libiberty in a separate patch. The ABI has currently no target-specific content (a given psABI might elect to mandate alignment, but the common ABI does not do this). Standard Library impact ----------------------- The current implementations require addition of only a single header to the standard library (no change to the runtime). This header is part of the patch. GCC Implementation outline -------------------------- The standard's design for coroutines does not decorate the definition of a coroutine in any way, so that a function is only known to be a coroutine when one of the keywords (co_await, co_yield, co_return) is encountered. This means that we cannot special-case such functions from the outset, but must process them differently when they are finalised - which we do from "finish_function ()". At a high level, this design of coroutine produces four pieces from the original user's function: 1. A coroutine state frame (taking the logical place of the activation record for a regular function). One item stored in that state is the index of the current suspend point. 2. A "ramp" function This is what the user calls to construct the coroutine frame and start the coroutine execution. This will return some object representing the coroutine's eventual return value (or means to continue it when it it suspended). 3. A "resume" function. This is what gets called when a the coroutine is resumed when suspended. 4. A "destroy" function. This is what gets called when the coroutine state should be destroyed and its memory released. The standard's coroutines involve cooperation of the user's authored function with a provided "promise" class, which includes mandatory methods for handling the state transitions and providing output values. Most realistic coroutines will also have one or more 'awaiter' classes that implement the user's actions for each suspend point. As we parse (or during template expansion) the types of the promise and awaiter classes become known, and can then be verified against the signatures expected by the standard. Once the function is parsed (and templates expanded) we are able to make the transformation into the four pieces noted above. The implementation here takes the approach of a series of AST transforms. The state machine suspend points are encoded in three internal functions (one of which represents an exit from scope without cleanups). These three IFNs are lowered early in the middle end, such that the majority of GCC's optimisers can be run on the resulting output. As a design choice, we have carried out the outlining of the user's function in the front end, and taken advantage of the existing middle end's abilities to inline and DCE where that is profitable. Since the state machine is actually common to both resumer and destroyer functions, we make only a single function "actor" that contains both the resume and destroy paths. The destroy function is represented by a small stub that sets a value to signal the use of the destroy path and calls the actor. The idea is that optimisation of the state machine need only be done once - and then the resume and destroy paths can be identified allowing the middle end's inline and DCE machinery to optimise as profitable as noted above. The middle end components for this implementation are: A pass that: 1. Lowers the coroutine builtins that allow the standard library header to interact with the coroutine frame (these fairly simple logical or numerical substitution of values, given a coroutine frame pointer). 2. Lowers the IFN that represents the exit from state without cleanup. Essentially, this becomes a gimple goto. 3. Sets the final size of the coroutine frame at this stage. A second pass (that requires the revised CFG that results from the lowering of the scope exit IFNs in the first). 1. Lower the IFNs that represent the state machine paths for the resume and destroy cases. Patches squashed into this commit: [C++ coroutines 1] Common code and base definitions. This part of the patch series provides the gating flag, the keywords, cpp defines etc. [C++ coroutines 2] Define builtins and internal functions. This part of the patch series provides the builtin functions used by the standard library code and the internal functions used to implement lowering of the coroutine state machine. [C++ coroutines 3] Front end parsing and transforms. There are two parts to this. 1. Parsing, template instantiation and diagnostics for the standard- mandated class entries. The user authors a function that becomes a coroutine (lazily) by making use of any of the co_await, co_yield or co_return keywords. Unlike a regular function, where the activation record is placed on the stack, and is destroyed on function exit, a coroutine has some state that persists between calls - the 'coroutine frame' (thus analogous to a stack frame). We transform the user's function into three pieces: 1. A so-called ramp function, that establishes the coroutine frame and begins execution of the coroutine. 2. An actor function that contains the state machine corresponding to the user's suspend/resume structure. 3. A stub function that calls the actor function in 'destroy' mode. The actor function is executed: * from "resume point 0" by the ramp. * from resume point N ( > 0 ) for handle.resume() calls. * from the destroy stub for destroy point N for handle.destroy() calls. The C++ coroutine design described in the standard makes use of some helper methods that are authored in a so-called "promise" class provided by the user. At parse time (or post substitution) the type of the coroutine promise will be determined. At that point, we can look up the required promise class methods and issue diagnostics if they are missing or incorrect. To avoid repeating these actions at code-gen time, we make use of temporary 'proxy' variables for the coroutine handle and the promise - which will eventually be instantiated in the coroutine frame. Each of the keywords will expand to a code sequence (although co_yield is just syntactic sugar for a co_await). We defer the analysis and transformatin until template expansion is complete so that we have complete types at that time. 2. AST analysis and transformation which performs the code-gen for the outlined state machine. The entry point here is morph_fn_to_coro () which is called from finish_function () when we have completed any template expansion. This is preceded by helper functions that implement the phases below. The process proceeds in four phases. A Initial framing. The user's function body is wrapped in the initial and final suspend points and we begin building the coroutine frame. We build empty decls for the actor and destroyer functions at this time too. When exceptions are enabled, the user's function body will also be wrapped in a try-catch block with the catch invoking the promise class 'unhandled_exception' method. B Analysis. The user's function body is analysed to determine the suspend points, if any, and to capture local variables that might persist across such suspensions. In most cases, it is not necessary to capture compiler temporaries, since the tree-lowering nests the suspensions correctly. However, in the case of a captured reference, there is a lifetime extension to the end of the full expression - which can mean across a suspend point in which case it must be promoted to a frame variable. At the conclusion of analysis, we have a conservative frame layout and maps of the local variables to their frame entry points. C Build the ramp function. Carry out the allocation for the coroutine frame (NOTE; the actual size computation is deferred until late in the middle end to allow for future optimisations that will be allowed to elide unused frame entries). We build the return object. D Build and expand the actor and destroyer function bodies. The destroyer is a trivial shim that sets a bit to indicate that the destroy dispatcher should be used and then calls into the actor. The actor function is the implementation of the user's state machine. The current suspend point is noted in an index. Each suspend point is encoded as a pair of internal functions, one in the relevant dispatcher, and one representing the suspend point. During this process, the user's local variables and the proxies for the self-handle and the promise class instanceare re-written to their coroutine frame equivalents. The complete bodies for the ramp, actor and destroy function are passed back to finish_function for folding and gimplification. [C++ coroutines 4] Middle end expanders and transforms. The first part of this is a pass that provides: * expansion of the library support builtins, these are simple boolean or numerical substitutions. * The functionality of implementing an exit from scope without cleanup is performed here by lowering an IFN to a gimple goto. This pass has to run for non-coroutine functions, since functions calling the builtins are not necessarily coroutines (i.e. they are implementing the library interfaces which may be called from anywhere). The second part is the expansion of the coroutine IFNs that describe the state machine connections to the dispatchers. This only has to be run for functions that are coroutine components. The work done by this pass is: In the front end we construct a single actor function that contains the coroutine state machine. The actor function has three entry conditions: 1. from the ramp, resume point 0 - to initial-suspend. 2. when resume () is executed (resume point N). 3. from the destroy () shim when that is executed. The actor function begins with two dispatchers; one for resume and one for destroy (where the initial entry from the ramp is a special- case of resume point 0). Each suspend point and each dispatch entry is marked with an IFN such that we can connect the relevant dispatchers to their target labels. So, if we have: CO_YIELD (NUM, FINAL, RES_LAB, DEST_LAB, FRAME_PTR) This is await point NUM, and is the final await if FINAL is non-zero. The resume point is RES_LAB, and the destroy point is DEST_LAB. We expect to find a CO_ACTOR (NUM) in the resume dispatcher and a CO_ACTOR (NUM+1) in the destroy dispatcher. Initially, the intent of keeping the resume and destroy paths together is that the conditionals controlling them are identical, and thus there would be duplication of any optimisation of those paths if the split were earlier. Subsequent inlining of the actor (and DCE) is then able to extract the resume and destroy paths as separate functions if that is found profitable by the optimisers. Once we have remade the connections to their correct postions, we elide the labels that the front end inserted. [C++ coroutines 5] Standard library header. This provides the interfaces mandated by the standard and implements the interaction with the coroutine frame by means of inline use of builtins expanded at compile-time. There should be a 1:1 correspondence with the standard sections which are cross-referenced. There is no runtime content. At this stage, we have the content in an inline namespace "__n4835" for the CD we worked to. [C++ coroutines 6] Testsuite. There are two categories of test: 1. Checks for correctly formed source code and the error reporting. 2. Checks for transformation and code-gen. The second set are run as 'torture' tests for the standard options set, including LTO. These are also intentionally run with no options provided (from the coroutines.exp script). gcc/ChangeLog: 2020-01-18 Iain Sandoe * Makefile.in: Add coroutine-passes.o. * builtin-types.def (BT_CONST_SIZE): New. (BT_FN_BOOL_PTR): New. (BT_FN_PTR_PTR_CONST_SIZE_BOOL): New. * builtins.def (DEF_COROUTINE_BUILTIN): New. * coroutine-builtins.def: New file. * coroutine-passes.cc: New file. * function.h (struct GTY function): Add a bit to indicate that the function is a coroutine component. * internal-fn.c (expand_CO_FRAME): New. (expand_CO_YIELD): New. (expand_CO_SUSPN): New. (expand_CO_ACTOR): New. * internal-fn.def (CO_ACTOR): New. (CO_YIELD): New. (CO_SUSPN): New. (CO_FRAME): New. * passes.def: Add pass_coroutine_lower_builtins, pass_coroutine_early_expand_ifns. * tree-pass.h (make_pass_coroutine_lower_builtins): New. (make_pass_coroutine_early_expand_ifns): New. * doc/invoke.texi: Document the fcoroutines command line switch. gcc/c-family/ChangeLog: 2020-01-18 Iain Sandoe * c-common.c (co_await, co_yield, co_return): New. * c-common.h (RID_CO_AWAIT, RID_CO_YIELD, RID_CO_RETURN): New enumeration values. (D_CXX_COROUTINES): Bit to identify coroutines are active. (D_CXX_COROUTINES_FLAGS): Guard for coroutine keywords. * c-cppbuiltin.c (__cpp_coroutines): New cpp define. * c.opt (fcoroutines): New command-line switch. gcc/cp/ChangeLog: 2020-01-18 Iain Sandoe * Make-lang.in: Add coroutines.o. * cp-tree.h (lang_decl-fn): coroutine_p, new bit. (DECL_COROUTINE_P): New. * lex.c (init_reswords): Enable keywords when the coroutine flag is set, * operators.def (co_await): New operator. * call.c (add_builtin_candidates): Handle CO_AWAIT_EXPR. (op_error): Likewise. (build_new_op_1): Likewise. (build_new_function_call): Validate coroutine builtin arguments. * constexpr.c (potential_constant_expression_1): Handle CO_AWAIT_EXPR, CO_YIELD_EXPR, CO_RETURN_EXPR. * coroutines.cc: New file. * cp-objcp-common.c (cp_common_init_ts): Add CO_AWAIT_EXPR, CO_YIELD_EXPR, CO_RETRN_EXPR as TS expressions. * cp-tree.def (CO_AWAIT_EXPR, CO_YIELD_EXPR, (CO_RETURN_EXPR): New. * cp-tree.h (coro_validate_builtin_call): New. * decl.c (emit_coro_helper): New. (finish_function): Handle the case when a function is found to be a coroutine, perform the outlining and emit the outlined functions. Set a bit to signal that this is a coroutine component. * parser.c (enum required_token): New enumeration RT_CO_YIELD. (cp_parser_unary_expression): Handle co_await. (cp_parser_assignment_expression): Handle co_yield. (cp_parser_statement): Handle RID_CO_RETURN. (cp_parser_jump_statement): Handle co_return. (cp_parser_operator): Handle co_await operator. (cp_parser_yield_expression): New. (cp_parser_required_error): Handle RT_CO_YIELD. * pt.c (tsubst_copy): Handle CO_AWAIT_EXPR. (tsubst_expr): Handle CO_AWAIT_EXPR, CO_YIELD_EXPR and CO_RETURN_EXPRs. * tree.c (cp_walk_subtrees): Likewise. libstdc++-v3/ChangeLog: 2020-01-18 Iain Sandoe * include/Makefile.am: Add coroutine to the std set. * include/Makefile.in: Regenerated. * include/std/coroutine: New file. gcc/testsuite/ChangeLog: 2020-01-18 Iain Sandoe * g++.dg/coroutines/co-await-syntax-00-needs-expr.C: New test. * g++.dg/coroutines/co-await-syntax-01-outside-fn.C: New test. * g++.dg/coroutines/co-await-syntax-02-outside-fn.C: New test. * g++.dg/coroutines/co-await-syntax-03-auto.C: New test. * g++.dg/coroutines/co-await-syntax-04-ctor-dtor.C: New test. * g++.dg/coroutines/co-await-syntax-05-constexpr.C: New test. * g++.dg/coroutines/co-await-syntax-06-main.C: New test. * g++.dg/coroutines/co-await-syntax-07-varargs.C: New test. * g++.dg/coroutines/co-await-syntax-08-lambda-auto.C: New test. * g++.dg/coroutines/co-return-syntax-01-outside-fn.C: New test. * g++.dg/coroutines/co-return-syntax-02-outside-fn.C: New test. * g++.dg/coroutines/co-return-syntax-03-auto.C: New test. * g++.dg/coroutines/co-return-syntax-04-ctor-dtor.C: New test. * g++.dg/coroutines/co-return-syntax-05-constexpr-fn.C: New test. * g++.dg/coroutines/co-return-syntax-06-main.C: New test. * g++.dg/coroutines/co-return-syntax-07-vararg.C: New test. * g++.dg/coroutines/co-return-syntax-08-bad-return.C: New test. * g++.dg/coroutines/co-return-syntax-09-lambda-auto.C: New test. * g++.dg/coroutines/co-yield-syntax-00-needs-expr.C: New test. * g++.dg/coroutines/co-yield-syntax-01-outside-fn.C: New test. * g++.dg/coroutines/co-yield-syntax-02-outside-fn.C: New test. * g++.dg/coroutines/co-yield-syntax-03-auto.C: New test. * g++.dg/coroutines/co-yield-syntax-04-ctor-dtor.C: New test. * g++.dg/coroutines/co-yield-syntax-05-constexpr.C: New test. * g++.dg/coroutines/co-yield-syntax-06-main.C: New test. * g++.dg/coroutines/co-yield-syntax-07-varargs.C: New test. * g++.dg/coroutines/co-yield-syntax-08-needs-expr.C: New test. * g++.dg/coroutines/co-yield-syntax-09-lambda-auto.C: New test. * g++.dg/coroutines/coro-builtins.C: New test. * g++.dg/coroutines/coro-missing-gro.C: New test. * g++.dg/coroutines/coro-missing-promise-yield.C: New test. * g++.dg/coroutines/coro-missing-ret-value.C: New test. * g++.dg/coroutines/coro-missing-ret-void.C: New test. * g++.dg/coroutines/coro-missing-ueh-1.C: New test. * g++.dg/coroutines/coro-missing-ueh-2.C: New test. * g++.dg/coroutines/coro-missing-ueh-3.C: New test. * g++.dg/coroutines/coro-missing-ueh.h: New test. * g++.dg/coroutines/coro-pre-proc.C: New test. * g++.dg/coroutines/coro.h: New file. * g++.dg/coroutines/coro1-ret-int-yield-int.h: New file. * g++.dg/coroutines/coroutines.exp: New file. * g++.dg/coroutines/torture/alloc-00-gro-on-alloc-fail.C: New test. * g++.dg/coroutines/torture/alloc-01-overload-newdel.C: New test. * g++.dg/coroutines/torture/call-00-co-aw-arg.C: New test. * g++.dg/coroutines/torture/call-01-multiple-co-aw.C: New test. * g++.dg/coroutines/torture/call-02-temp-co-aw.C: New test. * g++.dg/coroutines/torture/call-03-temp-ref-co-aw.C: New test. * g++.dg/coroutines/torture/class-00-co-ret.C: New test. * g++.dg/coroutines/torture/class-01-co-ret-parm.C: New test. * g++.dg/coroutines/torture/class-02-templ-parm.C: New test. * g++.dg/coroutines/torture/class-03-operator-templ-parm.C: New test. * g++.dg/coroutines/torture/class-04-lambda-1.C: New test. * g++.dg/coroutines/torture/class-05-lambda-capture-copy-local.C: New test. * g++.dg/coroutines/torture/class-06-lambda-capture-ref.C: New test. * g++.dg/coroutines/torture/co-await-00-trivial.C: New test. * g++.dg/coroutines/torture/co-await-01-with-value.C: New test. * g++.dg/coroutines/torture/co-await-02-xform.C: New test. * g++.dg/coroutines/torture/co-await-03-rhs-op.C: New test. * g++.dg/coroutines/torture/co-await-04-control-flow.C: New test. * g++.dg/coroutines/torture/co-await-05-loop.C: New test. * g++.dg/coroutines/torture/co-await-06-ovl.C: New test. * g++.dg/coroutines/torture/co-await-07-tmpl.C: New test. * g++.dg/coroutines/torture/co-await-08-cascade.C: New test. * g++.dg/coroutines/torture/co-await-09-pair.C: New test. * g++.dg/coroutines/torture/co-await-10-template-fn-arg.C: New test. * g++.dg/coroutines/torture/co-await-11-forwarding.C: New test. * g++.dg/coroutines/torture/co-await-12-operator-2.C: New test. * g++.dg/coroutines/torture/co-await-13-return-ref.C: New test. * g++.dg/coroutines/torture/co-ret-00-void-return-is-ready.C: New test. * g++.dg/coroutines/torture/co-ret-01-void-return-is-suspend.C: New test. * g++.dg/coroutines/torture/co-ret-03-different-GRO-type.C: New test. * g++.dg/coroutines/torture/co-ret-04-GRO-nontriv.C: New test. * g++.dg/coroutines/torture/co-ret-05-return-value.C: New test. * g++.dg/coroutines/torture/co-ret-06-template-promise-val-1.C: New test. * g++.dg/coroutines/torture/co-ret-07-void-cast-expr.C: New test. * g++.dg/coroutines/torture/co-ret-08-template-cast-ret.C: New test. * g++.dg/coroutines/torture/co-ret-09-bool-await-susp.C: New test. * g++.dg/coroutines/torture/co-ret-10-expression-evaluates-once.C: New test. * g++.dg/coroutines/torture/co-ret-11-co-ret-co-await.C: New test. * g++.dg/coroutines/torture/co-ret-12-co-ret-fun-co-await.C: New test. * g++.dg/coroutines/torture/co-ret-13-template-2.C: New test. * g++.dg/coroutines/torture/co-ret-14-template-3.C: New test. * g++.dg/coroutines/torture/co-yield-00-triv.C: New test. * g++.dg/coroutines/torture/co-yield-01-multi.C: New test. * g++.dg/coroutines/torture/co-yield-02-loop.C: New test. * g++.dg/coroutines/torture/co-yield-03-tmpl.C: New test. * g++.dg/coroutines/torture/co-yield-04-complex-local-state.C: New test. * g++.dg/coroutines/torture/co-yield-05-co-aw.C: New test. * g++.dg/coroutines/torture/co-yield-06-fun-parm.C: New test. * g++.dg/coroutines/torture/co-yield-07-template-fn-param.C: New test. * g++.dg/coroutines/torture/co-yield-08-more-refs.C: New test. * g++.dg/coroutines/torture/co-yield-09-more-templ-refs.C: New test. * g++.dg/coroutines/torture/coro-torture.exp: New file. * g++.dg/coroutines/torture/exceptions-test-0.C: New test. * g++.dg/coroutines/torture/func-params-00.C: New test. * g++.dg/coroutines/torture/func-params-01.C: New test. * g++.dg/coroutines/torture/func-params-02.C: New test. * g++.dg/coroutines/torture/func-params-03.C: New test. * g++.dg/coroutines/torture/func-params-04.C: New test. * g++.dg/coroutines/torture/func-params-05.C: New test. * g++.dg/coroutines/torture/func-params-06.C: New test. * g++.dg/coroutines/torture/lambda-00-co-ret.C: New test. * g++.dg/coroutines/torture/lambda-01-co-ret-parm.C: New test. * g++.dg/coroutines/torture/lambda-02-co-yield-values.C: New test. * g++.dg/coroutines/torture/lambda-03-auto-parm-1.C: New test. * g++.dg/coroutines/torture/lambda-04-templ-parm.C: New test. * g++.dg/coroutines/torture/lambda-05-capture-copy-local.C: New test. * g++.dg/coroutines/torture/lambda-06-multi-capture.C: New test. * g++.dg/coroutines/torture/lambda-07-multi-yield.C: New test. * g++.dg/coroutines/torture/lambda-08-co-ret-parm-ref.C: New test. * g++.dg/coroutines/torture/local-var-0.C: New test. * g++.dg/coroutines/torture/local-var-1.C: New test. * g++.dg/coroutines/torture/local-var-2.C: New test. * g++.dg/coroutines/torture/local-var-3.C: New test. * g++.dg/coroutines/torture/local-var-4.C: New test. * g++.dg/coroutines/torture/mid-suspend-destruction-0.C: New test. * g++.dg/coroutines/torture/pr92933.C: New test. --Apple-Mail=_963CE16A-0532-4AC0-AE2E-5E40C23779D4 Content-Disposition: attachment; filename=coroutines-initial-on-472ef1d34bb.txt.bz2 Content-Type: application/x-bzip2; x-unix-mode=0644; name="coroutines-initial-on-472ef1d34bb.txt.bz2" Content-Transfer-Encoding: base64 Content-length: 84404 QlpoOTFBWSZTWff1itQBixd/gH/yCQB//////////v////9hXx7wAAbve4Pv I3vs2sq+4Adu71u282HvO8+vt7aPX3fbznsI+Yaql1lS4+Tu+9deq9l757Lv ZgAAAGRr6AOqAT3vNpXd48fXPg0BToH2wAPXPfe3vt9F8+7c3z2y+7gwi7NZ t7aO5z0oc97ve51uV9p7yD4U7u9PFF8WVvfB773zj0b2enda23ffY96fQchy Jd9XPeY0M9emq7299b3pvrd26qoOsg1e3vaCU9MtHpe3o3THXtrsO7D1gKFB Io6Z31n152ddISmct7E+7veKu6lZe5zxPMc5re8Xje167s0732aAeuWl6W3a lvbgod2+nkeqH3ZngHtvrXe3YH0X2ABp9ANHVneT7dvfd5960ex92mNnfPro 4gSreL7wegX3vfbu97X324+igtu1YAt7Gb6+veUretenbvXnRoHoFCgpEJK3 oFtt7rd5a9mTVIPXuGrvY+ADwOcoK7MjVZa1tvPrnQCR9sW2iXyNaG9qc53A DXHdzkyHz7dH16Or5hbvdzwUjvh2+2yM3bNlHvvu49w+7p5777nLedt3ddd2 9vvbb0dffWaffd9b7rF2m+9te3xzQ7sl30++47xajM1oRLtnVNF69qzuvNNu +Khztlehbr72j3u5feb3WXPFNzXrrvJV1xzubrA7u1dSRKVV2ZePuDvvr68v a9wtsJbHvneYIvQA1O1fXvYDXy999w0etsb57OqVMjWeX3vfeCni0e99rKBx 6k+tvbvmNvZ13wpnvY+vvivu+Zezuqh3Ddjkt89jRrvHC5bRWACmzagbe3uR 7uEIEnbHPrV7PZt2QbQpiCbd45yly14GFNRMtKrMNzkiK7kuKdG3aPvdKveU LuYNbc1g2ys5ndzqgogjsAL7zgB0a2GFqmAAa2e7W9m5j2rMG2plRQdcq6bZ tqWnhu4ernSWx9eWuvR6azHfVhobaCKO23qO45zrutfZ57e6Hbtu0HUZgW59 T61Qq9YGj7Y5vu1G971i73fduzG7c608M7tOzvY863r3vtu8rw6UZADW20da Z3cNu30hhxtbtQ5aqe4D3sPbLSwLLmzrBTLbNG2uzndd13OQtncLSQ7dd9W+ +tahvIXxHYBu3CU0gI0AQI0AgENAExEwBoEo8mU8oxoamRHogSmgQQgiAU8g mQKm/TQmlPTyaRPU9J6hso9Q9Rp6mgAAAkEiImQTQiYRiZNT0m02pD1E2Sn6 pvUnqaaH6TU0PU0aaPUHqBphCUSKCaaTITIyaJ6mETyAmJo2mkaZqGjT0gNM mjE0NAIUkgJoE0yAJkDSbSATRhI09NRjVJ7RTeKeo9TanqPUNNJphEiIICAJ oAIAg0RhJptCZKe2jU0ZKHoxCBoB7+0BH03QBPdJ/1gItAuSCBkKoBQoIsKy LEIhQKMQiRCpBKgKUKih4grAKmFBD9CDoRD9J2y8hEzyz/qlfA5EbUMtUx/w TghkPVY1UQUNSNNRTQyUtKaXJ0sU0P+v/bf6u/GfT6DBFJFSDBER7k5xcIRL JcsEEyRBQMVABCtEE2tBEwwMwUNARIhQBFEVJTrTTMlEkEJtg1mKExIGhCIq kpBpcVjIlAU6cTEpUQtAmMZYkMQ1FppKKRdAbZDnAMLQxXMZcOIcZEn3jEBy KUEP1+rcnk65Gn/B/N64I/AYcx4wDi2v7PB0pyNY2miIgIk2wRe8GjgWNjBE uJXQaBpORyK0nGIkqCKYiZR5sI2wVoCgEJMIBhMIBh9dNah/59+3+P/x/vQ+ 6HKkSMCLwhWDckKE26l3EmoY6lszh0uJ8CTcOxKE9Kf8KLqNTP0W2SN+RdPe nrXUbY0NsA+v9uL9vjgm6VoGigN8PWn+v/z5H/D2+jjsnGRucIcIxk7MEUwH v/6f9JHWqhHHz/8/9e25VuhOwKGsYo0/7O8cYDpL10rSWV8oXVcRBX8UtR2/ 6wyN3F4+UIrlALeW8Q2Xk3KuXDU0jFh4IDG7fbLA2XH/xnMnamd/HCpMq7jl s8xZtZA0E1Ar3Uh2RevkL/6yrxyye56NVf99ow1d20avHDWKQhDYJpNQkmwU EpPtfhR5ctDsx3cQHkQkVkBFkTlE05Wc7vyxZ9Xn7L+VLjr8kezF3YOg9phG E0MiOLeUpS/tq+ZP8t4jSVkp0DpDoiGb1Pjv0rDNxmCBKExn+q+Rr89eTIXv 2efDTQJxTpFH/bBF/CB2EUe2HPevOHxLKUqL4wn+JQcCXmgzmkSw/lSmY2Tw esoqQ82oSmOMnuvcj2eutDXWtsJdsghRgzjOx/72c5xSfTw+lzv9PZBqdhX4 oh3O4RNBR5Vh5tmk4aZTBhpjehowSnn8z8fseF3efb8fafPGPnG1j9jY7M93 LVs6YigcSQ6sm1QRUUzuJ47xfPhn48ZEMDKF75RXrn2dKHcTwj421ob7wghC QOh4QgQHjrxeQ26EibX0RH1GZ7Edv8efo0g/18E6C98jKw3IN+WaqpE3GAiD sa5w5cr68xw5nT+FpfchHtrbTZjJvglW2GEhWDY5HK6x7zY7kQaqDGmV9ouz 3cuMWju51j3cupYBsBCTMyQMMyTEUxi2euj7KAmhB6QMYLQ8dTt1I+OmuXQf Nd+nmLyh5qpAyMlUgeI7u+3F7/lcFwqNM4xZPVbzaEGSFaAcEQ7CpC9MOMdX mi0ZOmjD7NH8Ou615znMOMEnDuwIgoiBc5zfITvsL15wHfNKUessn5QGtk5Q 8J06KKSqDSfKreP68856H7bj7hi38aZOc9FykzJBvuh3AaqCKomiTshpSCOB 2E/T8MH960HiepKIoISvcBiWIoClKCqGhjZA0D+9Dp5RDpCgiYPuzm8iJqsQ 0UgSQwyld3F8z2r+zYIB55wNxMEHmHdxpAoJiRmCNIaoK0taaZplPW5BcdRF KaNEEDQXCyfZLkZ9WjyxabGoDVs4JppdATVP3L0TEBmaoLIc+CyRJGhOC/Jx +zSMcP9MoVREu/KDV7uWDH2phqrvijgXw19M6N1S/Xw0GkXB0iaQNpjJCf4d fR9/9Phs03ik5i/7rlIxo1rsctzBNQ8vZB+ba8PObxOcCpC8efH000Qbg1+q UbTyh2yznSZipqGEVwnJfn8yueDB44cGCnzwxwvkThH4zC/C7dv6up8vBoN+ USI1ykhNESZGSIGJ1en1xnlufZv5Lq45lGWQ0kVNOMVzmSoslPrveEfbcXjQ E9y74XoY29GPnKZCIGhnW1Lxm2PR4cGwwxqMIQgTcPgbGh0eJ5TWZqSEJmbb 5DK/5mREi3ywbvgCYMm/7xcg+x4pQWmm2iD2HWKZApOOANCkDJ2/HI8jvx3D 7xUfnG9h0NsJw2/f7k70G3STLZviRjaOXEw6dPcZBNBGt1G5VtQTtn8p/LUt PEmxjTmyLq+tjec7yUfWeG2mpsRBkQoQXCVS7MSwaM4aRAsaYCL45cQwY1J8 gVdRjOPs019OO+xB5BSmjLNtxMkCEU++KZNNM1aeqE6QZDkQQRKLyIFXIaWl KKQoHXfh2yYG84SMSnXAGgpBKCihD6wIlLyRHkjo8IOxZOhkMPeZ8Z6VDVli tUyyTwTBP/F4oSF/V2Z03SdtXWPCDx6wnKX0TO7rGSfWNboTnp/5f1c3ojP0 6g467x4gzf11x2vfeMbwcY5LSmjvT3P9GHOz8+di6DdNemUSuNIkLQiowlQz lHiprQ4Mfb9lo4S1XVd1oVSCkYyD+eV0jg2Nt/E7Y4xx6tpKRCTImZGwudyX ojtVa0PmHHQmGwIGU2k1FIASc7J559Fp4Sih0nfDQHDQRrHo6aojMirBnacU leuIoxIfK2J1I0i17tlNNGh5gEmgSYITwQg5E0WzrS0gpvMJmOsGMb8AHmRZ C1skjchDScYZHirl41payKalkGNrtCIeDjHldHzLkRM4qMYNDDGox8QKU061 5w3G6bQbU13lsxtHOaFK9OuqNkGOPqW3wm+YQ8xnTfGsMXgfYbyqIwvhY6Ac YLueMFaxArakKPs+NZYO20LRT8h4Q1CJTWYYcaRCEJJe8xsbHefJ7e+RcuiO xy+BZHHnfjF0ZqSJLj2lzxldO/c79cc+T5nb/NXHB3zhixt1kU4TwZ6RJAKu 7OQ+oez5PINE92qHkIckDmz04bkBoaItB5JoKA5AEbLtvEzQIp0w7BLifiYw 5SdVXxv08zS98G2D1rbeU5wITJBSZt/V1CBAFIpkDP5ebm7eEazyi3kkkkkk ihs3yGbYI0YkxwjMdOK4kZhD0SAaQ7oh1bEClAcDnJHyAyyDRQScm2MmzRFB UVgRsWvVcK3Tp4nV8qYiJiYrxeXz6ZnuMOkE0/ffa6li2ihwYNIfcYBEh0xW kpFTQx31eMWhMjIAtEV04o23IsoStcXEVaIQTGA/CGMSeH7KHDA7BwRjGREk dMyOO47o7uW7P8tC6U2jBf0iyul7Q2DJOwuVXMdqwrszF0RRwNOESNdYzDtw Ppdge1UaI21pO8/djSDBJ0216UnVl1CXNzha2kgTRERXMgB+fBqg5VWOk8Ep 4aI+Ee+JkIgmQiBm7Odby2ODdZHE5BQ5wMWPLKSTUGk3Fq7sepXlFWINzx9H DpScuXE2Wx0dwlByiANNAVryk1jFE2TdzZNOVJ7OvImjpYN4JImgnze+by88 7SkhFWsIMOx7MOWjWQ4fc8ppnPjCtGyl6XyO7kuTI3aPcP2Qc9UYLYzrKETe cOXLEQ0UxIr8oYl68EyxvUJQY8TyqNjVRDMMjK22YNUSj8TWM5KCbcKWUVAI YdhmEmaRn81ACxJXWDaXDSzbMuzMeZJuttxfHqtXiR03NjbnK06NTWtG2KK2 tmq5znI2NsVattaILbbNx3Lm0C2VjGSFslhSDJWiNyRSOkddUbnMa2xqrm0m 2Dly5QUWLQSNyOMbGyNtWwdsttjssjrjbtiY2wvaJLPAyNFAeorDkwwyRupJ NExVAX5tiSk+neV9mUOpDxCkJQpCCS4ORAYfQ9/s8DVbRujrTYjl3XL0m244 B1SgUqhSHAkE5VLoaKgqCWoXszGlZKqEHpz/mKFAycI/9zr+n1RxL/k+mzn0 8oNwr23c4SSJow/q6jzhqjv7Vh9q29c0kwFPx+2Lb9vDfwl3SlDhCH7ZSShJ 259nGB2T6J1xw1CIdw/rCImCif12RSBnDSVt1MSQL1w73z7KalCa741fV9e/ uJ/Z+l/Z9pm8br3uEa/yspvSEJZP1cZ1SPzMGm0qUlKUh+GwpYz9+QUx5vyc ASEMEOGKADrDDD79A9n5sIr8+6hv19e7AYXpr8e7CTCUtgfPft3GYQJijQyJ b0TINh0w8x9baPr2af/qx+7qUOGDDzfp4f+KPUOjnSQ4FtsZBtiUB+Kjh0PP Lo95xCOkOSr0+bRpN5oWGhjhHJCp9ScYHGKH2QG4zUd26eONh+EF+Gjrn8/5 N5oPSS9klRRLvhBkVDpCal3/PrzJxJ3dugHIvAWnAkUhGDqzOgwg6ISkCle8 5+vSmtZsRYVzIJZDaI3AfX2+tvv0aS3lTyF9UdAGIr8wgMVA1SLJ+1kxMydW RyT9CfHNi55ibQ9sdZcW5dTqaEGJAJhY7XHCZj5SDkUFNFICV9H+P+rz9qfC Dy0nstcwG5KZ20RLJBsiF3Lxo0Zf5f5+/8Ppy/9v/brzn4j1l+yn+lPjaU5z xgSVqYRVO3bhsVxxrh98c80c88wY7LiK445g/rjVzTzxrXHbGJw+5Leudw/f Mv2h5Wn7Q+ddamO4wHp/wMN+pAkB9sazScYqYi9LpAf1JXz08v0fjW311rU9 fzKzzrSn1xjP3vTHAefji7k2jUvpHb65T9MOvugH3/xldXeF+MIRq89FP2aZ 8r7y9L4QmV6yB0FyHQzidMNsz8IHAIilQBv48zZBXXmHpPVvi/Oz14xRi/TN X41vD9oA8n7Y7AHJBPINIaP0SFCfvD9R4CIqj61U9ZCGSgfK7k9gZtEn3L6v YcMZZM0wPVZZcHrYnsnv+0qh5H7D9GF2URVHhzFpRFUbARr+J/iwuF0bRnFg xryY2A/lMHh46aG/ySD4TSUFBQFJQkw8Ik06CoPI0iLBOyDw5lgpRGNaogoQ wYjKm2RNBkkaII2aOcDEn9/HTml0ERu84EEcpZDYwFFDumUwcM4tOiDRGDQZ 2UMSjMgNIrWxZNu8A9bjxiqp6d5wilThIDmMLIghCyooQcwHDnuFOcIKpwTo fJ87gLneKUj3mO1LT21zY4DIcmuRyIYo0Vo1Xe84rVaOtyoSIiqhO7scB7Jp TTSRJWzhNBiMSlC0FEVFIRKMY0UVsmkzOI3MgA8WWgBSheTo5CcigCJKOQDE tsqW2kklYgpAxHahdzMyGkzCYk00NCxA0RMVFFBQOnTi0W1nJMOIdUhSprQa EIsWnQU3Q4YOUCUjTS1QUkTqk0UprSDDKmxOraCoQiCi5q3TGk5znCk5Gk2z 22sHruDoIUJEElChIQip1CrAT6gPXP3ryA93kMJwwns4mQ5UgUROuXAnFWeY +HvdJO/vScON2OccWIacTVFJTjcwcCZ+R+CuPHgUVmZZPFVHIppHpK/ZCmSA Ur/vkfNrMgU74D+6A4QgNKNIjyyYqj4uzoNIatgoNDpTTSGgi/rkLqh5JpXb BEUul0JF8IA5BoQ4QhyMRoA5LyRoXSkSAF86qH75Uc/X9BP7/6K55ddQnKiN FBcZBFRUXOGqCGhOQESsRW3bMTeZKyKRDGfARcwBtM8Is+CmbTGgbYkPXA4X I2KqP1Kx1hUHiSqhyDhcNGq/Xt5YNoYsodIaCkeFcqtbk3OZnkPw2aNB3XDn WNzaz+u7dYcYchopALbZwmbWkVKTS6aUaSGF2DvDHDRmzoo/YkNLSUiBStAC /sw9IT9cY+GcweBCZqNLjfoXmuVLiilgHnOcGhLgc4cI2cUI78d+jhpTtH4z AaooOYhyJg2wRQRA3t1iaEaPzdmKAbSBtIGFS6RWgoWgoqhiA0mkAKGKhiSI oVHksqZCIabbVFgIFxshgzvObhsGGNBrONooU0KNRAUg6cROrKq621KGhCIY 2InVnIQVCAGjTR+4AQcgL6EnSHkSGZaQKQKVoUKQIYNLSUK5mhoVppBoGlaZ giKS2WIpp+6FPhJ2CkppAHsWwaARsh/RONKkSccHyQUzx6hALSir979Z6T/X j7P6tK7JJBSzIbowgEiEKdw/ig7Tce44l+HyILfoPDdoPKhel/qf/ovnTs6P h7CKOP6tHuu/dGp8/aNRmb15tqv70PBX+BzBDoTj4qgGvrOjzxkoWoOmaalG P29UIoUf2vkkbZQ8hqrUEgn7bX+uf+WlH2ZH4bIsyDBfs8Lv5ocbUrh6qLpY d/lMgSk5+xxnQqodmWSf5mDi2PESx8bfp5Tu8tnjfnXG8X0IaEq+ve59RyMp MKviEgRTIXgk2HcXWjMhNWRJ5uKMBUM/+QoNd/P9P2dzX4vxnWCIv/Ylcc4m VeWpZ2kWMEx16fgDXnY7MJA4nQzObnk6+gn54pIhiC9js1yhW4u5pibV+qaA iKdMN/+Iqhu355lyCBs4MYIZ39T9/L2Q5WfCfba59OGids+XUeQf7zAVOzlh S0AYSuJJCCH9qS+df74AGNjZ2bbDLFif4UymCcBTHmU4SMRXKYAKAIxkKUEI SRA+iBIaJghWUUNCuIlGOMWAshHmVQ5VyMlag7C8ochJtAwsGH89Ffx3TPZ7 +3yesFWcw0tbPJgFBIY9HkconHWgziB1/jMT+Ps394OrnQ9XSw8Me+PYKd+5 Zk7TiXsI9VYh1TdDWnZwev8xZhpcGvIf6aSMV2xC/MnMKV7utG9eyWKnCKgb wEOc2hmcM6W4IgwT3JoXo0Y9x6SRTOuJGGmZyUMWd6w/u+1vK+mY/P4z8pvZ raTYDMPlKSf427+9P+5dewkOzGZlvsBJm/h3HO6CGr+ubFBkBL7uzg1Mi6rF KTGxZSg/bHvY6XH0f1DMzGiHK8VQn/JwdoDc2Js3JofiSaYFSnWcCHyEYwHf /Ht+nyqE8R/lfxgOi7qQ81F4+PTjNu4o4mnp5R7IN2EJB0zqGByDwFUD5r5w Y2IZnjc3GwYNcWUi+2UeBPjAj54jQmm8OhnAH3TaDI6xTjOHhTGTyh6QO5MZ NcUTT6jFpdsKTiXze53e5vlRP/wcRoBn3ELj0ywwJY3ULfzy06/bfFd3u8Mi UsxoPZYakv1R4SO1hmk6bA8ovtwJNU1yEz3J2dCeczJvKLRk/fR87wjwtS0g /deb04ZYXY5B6pe/1cAX5qEijZ+mw2+MoOKlBmT/eOPsJxGpyjSlTxbCQH1t zbsh7MYXf9idqLnQUPOHjT18ZnG3r+QPbMabZne2/DRmkcvMge1cDfo1PAJN vHA9nLpCW5lfyPeM2zIA4DNw+zN/sQ6dR3LzwoQXj0ubrgMFXMmOFF9HuMhV GH0MPrNuGWHAl3obvI8X29fYEYbAuQz5YRbQ6Y9ewLy+5teFvXHrodOmPRCU 25s2UspV+EdL9aRoXLn3HKAYgybc8nu5RrqzrtCrUZzjOLHvHZBoN8ZrcIUO v3iyMy12HPxm59/vuKP09CHZulNS3bDnWbJuA/DD50zsJl9N5DIiPitEyE7l 52X+tB08nkKfdxjB+y8hbufLto/WEbkC45NG8ZmoJILMU49Ie1ZTUXt053N8 0Gvm3Sr7XFX06+WJQ5S1N5N71koFmavcnZt3b7PcDXnY483CEO/XLg1ESMEI /Thk0pw4vy8Rxj4jZnyB8d5ZV2x+yI5wMxmgHlcK4Yc53NlAaExn9Z7rMdfj 69PKdaLnkPBjkwmDA9B7D29l0O45nnefPkXuKKk0nts2xSxc36IaB6AdCJUS cqM9N6lll4WVsePd5azJOINM9zTeEX+RSVCkddOPx3PixGh7WvM4h7lp0PTX pQ7Ybmhta3mtbhoe23E0NmrDMjj1a9pIXvlMm7Drvc1hR3EJPBwlFaSEpBpg yGwmUrwWQUJmvb4BUbrcx1o3LD47dhyDkcN4DdjnFnEzWk31d+ORd+6jclnv x06NiTmEzVmG1TJhSTDA+nwPkeLROb+/jWxQwTlamJ249OszENpFC6OA7WEQ R2sO1xBwFTJUORHHh4c/lox3YJ4kPe6inWGKC/cUKcmYldHFifVjQWoQKSJB eiWjD7rMT3lipExXYK+PTLBjlfIL5tyC/seJIN66/rvn2KCiUzMR2oi8O/KF lLh5XqQ5aECAkKC964dkZpVKSoc4I1uI2PVdG+qrPvFceB0fG4JM5/5dswkH E0TbXt2q7ldmaJH4I4e6I6GyOSugCb73fkR1tegZg03HYZud/6iI/H8A/na0 gYf3/6pXWDcbmXN6P7ymcCbPRgMnH/LgaD7onxYR9h3MbsN9QfYmsm5xoopY Fnmz7Y2NozqHsg9sZr6dCf7baCucupSlWIB7JQ7v2WIf4W6Ef5JFz7sAyUCE E0nE3rh/cV5GF1sNDTlaFEFxGEUdkYD+lzLtlShB/DGBL/DhXXzJPcF4cSfn EgnwgdmjuHbx8bo1d3ZYvae5Axb18zFzCVt5YNarVSwdXSBNJHAnm1f1xIFU 1L3L7VjSjEhNZrdmrNImKxNmcPwhH8lYW+nvEyxIU1OzHYlBp2GEo746Pme/ 2n9dqFESSYZgMLay6ox/V9f2rqaeHin2W/5niH/P6lMyQJSlCIUGD/bH2w/K Gl1mfdKZL493M5Wlj+bh1o/Zn1eWVav2v21PhMfDRe5IgnD4meRDbc+/4dE9 Yih/ogr8j50nzihcG4i7B8geb9P4+nTHbcPp+j/darmcPNnr/zP7+4r+Onql nTvXPxPMNvy8vN9C3yxMlpDfCYToYyWhp0aUKdKhqhLGRIiZKWI0BEGigNBk hiRpSYD4n4uKoJP5mEa+fCMKMPhSJn+htSEDCC3QdLoP1kz/kn7bENQ0A+Xw tsJJFtoT+fn2cd50eAnGpw7MQxJyaqy/5UFY/fv+vtw9r5EeteR1gEFSaJXf KHJfZhM8rUj6Y2Sgj1H4KK+vh1SyRQIqpAJil/r8Pn26nXQ+c2eykDkH1MAP ukEMzozYBDTR5bOShBv9z2Y88P0X/b8/h8fv+37J/GD4X/d9f3SKfnujHhjh KeGGSYGZuga8j1JoDEDzBDcIAT9lwKl9Xx3Z8moxr8eusWXUXzADObj1691m 1GsgNQUqHPljRX2b0fDPLiG7PfALYHl7380JsHiBu4UVo2Y+uJ9LF+h8IjZ8 uTBHgR3mYIxECBMXMk/DXOVxxiw7GW6zzRsjG5AhIwDmFBF26dIWYhCHGYxy NOU47IkXrI0BRqGQQjumaFwBqk2PWziudu3WLmQhGrcbruSQmHO96SDexYIv BQCdY+LfHKByRyjfs1sEq+372/ezDFSfrXzEMn08JXz4ED7XGGgJkJmb4R43 kRihThPpnf8PFafjIk58PSBC4802aY8VgjP+0YjEWECPoQw2iY1OfamWIdEj GTZHA9Y0Bm1N6ECB+hG6WEeeDTgV/bTKdZUzMaOfxQEK1zZP+OgHPwNC5M2L MUcD86jmSG4MWTaQyhAjDaIEHF912Apm7MLDnTOdfJJGit9QFoEU3Xal299/ gaR7MYhm94/KYlRRYJcDu2V61FPOZfnvE/y1HLY41j0Vyd8xPajwuyOeHKvu SbgfR6I8XLYnAso5etWZkaUEcOwq7F5uesT2C0wkF59xELp9cMDcU03KcCCR W+hdP/Pi9GNgObQoX3COynKAXTtftDo07JjgnoeVf/2TBzjzgxBEwvHohXjt onLO4mTUyn3ogodIFpotYKSufsH7SfjDdaDo81t7GwJgtcoHSQRQ9Q/uY5NZ RWiJYZRK152V44GpD2czJcewkObqSHlrKbml8MKMBfAf/1q5ZyPCnRTbgbTb A/wazsxuzM0EA4gngmSGbjwba25tgCmroyhLv5YNYLmmQEOyEx6gHJMTJ1wf Kpb3cqrZ103r9CxoLbQJ/CWVZDl50OmAiI/a15YUcMcuI25HUoaJTnzuYGHD ohyw5hu1tRBDMFkD1enVz4QkHaVGGpDZ2mGQ9KqWgURJF8nsx3Y7r02EYj2f IkI1pGnyej1b+s46l2prsiDkkc0f4JmSBxFcVSwzM1VXSYqWyYND0puYb5Xp huqLSU1QREQU08DstcDLy8PVrXaO8747ZnYCBM3ZVtXnyveYp70zianBQWpK nnnZI/h2fSYn6F/qePRtRNFA4hbwx3zxaxkef5vj+Il+c/A/lJ/I/kOyhlTT dtDYbGKqhGMVm1+6M50+qzQoxCgjNxGbMmFFxNap3IrWHLsxl60YqdKsi0Iw JPaqaiEXFXJWJIdZRlRh4HudYxl9tLvfYybm98T+l9HAfHH4J+3JcSL+5ch4 /A8JhKIv2Z+lLjfkftx3JczqEog3n5DDpBLB2Zu6sn/l2H26A+HTN8SxFEUQ FEHQgDAmHdI+5i14g/eI/xEFTjt+r0/xpL1VyZKOnQImzSz0qo6hJNAXhAxk /+RLigoRTIEJ3J+zBe89vw8eT4tQDk6cjTBXm1lYQLzTegg0mUneAo5b/ysf q977swkydwHQd53eyET7F7Uwfp/Y0obA/c7HaneLcF0TYiJ93RhzmC5obtgw 6GkNNE6fLo0aFqBCkIKEI1U/AzfB2Llhz52PKsQigSSSSBIa63nSDVL+o3Xv RjgX/pNmIJKDju4rfHg3bBzmkCCwmCBxVqvo1mEhCX2n2Sxi7N0EdLoyja8X JYmg7Xf/T/5XF93aO3pD05j7Oc2IMTamhdQLTWaA/nBtmgBzVGYd3frSF36Q bM+vl64/vHpxNtkeHzrsTbhkwYP6uQQEnA81eAHaf3MBqCRNyBvzPjf47/Xz TuNlMECTu6R0g1Lz9f1dXdf60Nj87ydecDGdBPtkxJZp43uLUD84MDmm2v9x 68PFjfNGOx/cuCKsGHBxg/zl7fO/rZa8SnsUWZoT4DIn7XYz9yaPi/Mt9qef WcoO79PbOq+XcNO2FdsK7YVt3/xux3PhDeaZE58b9UOI4NAtkSAEIxokQ9s/ XoQ65e3bhpFyJqucCbErmsAt0RVIEiQsmus3eCIIa/xCpugUHEhIGn83Z+kK +rDa41yMxvLqcaUbMWyhH3EPPfvfjeFw6HoTt7e0/4q9EaJWKQSgKCT/KKIb FgUUfvTg+3lxvPQQP0q3bfiup273KfDUXkNHpo6u6cj4klgNEjkGSk5xslCd Ee84y1h7RthX9HxFOep1+zC1XUL84OncYGcEpxAKqjmBdJ+HzoMkAsANRiDq uVpTTGP7vg05IyJhCDdJ5gyxKFJBeSfZYCCIiqxUWxkkkY/4+GGG/W+OhQat Erj29ASunXW41FNJ+/tVw2qiNeXnTBHMFJog7Gii5GbR6jk92ZqKTuenCCIJ CY/Ug4zLscnfkgYuuKhKOLPDbdciA3q+/+88fr2T07xOuvqztnU0YS0ZRUHm sP0ZsSaowxIJGnLCO98teYNdQHml/vU9DsNzQTZjcDO5submKEkhYOz93wlK B5cA7015LrO4lGW2R+4sSCRHBkmPcvixWZAieMoKDj/xPMcSZCS7eHMNryL8 YQjyN9Oc5rajtwTXte73N/ezX8A9XFsOfGdGaipQhT4Tgk0FyeP+uAHr1KHA u2MqNsobB/g+8B0FBCCA0CyGiMH9Y/u5+BI5riOOhZPPw9z9RcWomH/j98tJ llf6rc5ztDfNfXO7luTLwLgX6L+cFe5pGxmk1HaieiyWaulYe92Mc5xAkF7h /59ehdn9ecsSIO0O3B0zO1a4Dyp6O9xnGjH9yM9YMkszsXGvLutlmSWk5r0O p4ycdY0SRa6Rjg9nnCknui16DfKFbSDHCxDaj1q1lm5MLOczzGntXQjJntyY CaiMGnOC+29qpd3jfGVa0YYTZHwkoBc2TD/M9KaCqf+SSSSVVVTVVVFVVVVV VVVVQotVVHv4/MzDScW47lno7g2DQbmDwukXtnNm2joZMbIAY9dZYuywbEZs ImC+RFD+2mY4NYRYQ4/gWbxesDJB3gMIHyJYMJt2TpCkKCIA7uJkn9zlkRjW 0OnfanYfmMALxMMG0rWpCPcD4Js6viYfLtHkwwGLrHBEMlz97ui0lWX2uJtX J6K9/WNntTaVK0JPQaIFDr0P1xa4Vo93UEzLU5B9T6CPnHTnz8XT9rgw3wyN HwT5Q/XbHCal0J2esfZbdYvWoHPZHBN02/tdIdcFd3n7YNnn5/X+fGKxMyuA sEev0nhPjQ9lWtDWMciZkzTzuz2m9GXb5Me6iTOMe/GSkCOpDicpj5R1538J 38Z8qDcTc0b7xxmWQ0HW8Qh5v0f8v3emwrQcY7/HHsz0si5VKPSGN+dwcBgo 7kRtadYmF1NYx4eLbKN0y3K+6I6hjORtWqofvw5x0EvRmZg1tXsBdHV1fZ93 Bh3sY3cqid5nyZF/wh2Ka3MpCUZeplMkkNO8QN6/K1fHk/rRiwndqHTxR9dC C1xKscpxerKcS3yd+k1vRI5xDjRf3wrST41HGqiRP8M/lpPrm9yQkdvsnjnt 1za66z931qx6Cvc+JoyvKrKVXB/o1K79XnHUiBmD4oGn6HhhIhELOEmSykaQ 8ISORHRU4N1zeny+FuX5pNWRiLlaLRRJGQDHzD7szafFdIMBEQUZPh+ziSmG 2Jgbw3LNrXHtdPdKukZER6vTXPtJr3a116ZuvH+GQlksJZLCXf5s2N9mPRkf h4XC8atXpu2y4261brfassqra32qtWqr/HduXavV/HVVVVVVVVVVVVVVVVVV VVVVVXlrVfx3Kqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq1qqqqqqqqqqqqq qqSUFFdFcsfpbN9TiUhnw5Okt2oBZnZ2lpA3LqO/HfXBv6WhhGKLcpxAIerm VUxjF3RikjGOjmrHhmZMJpyDVyEVbyEAC1iJP1tixHZnzdygR2blN0mkzxfE T89QfuR7Y7ZmiOvbTqfKGoh1CaFNHiNH7+8B0LsnXhamWEhrRcWUnlE/0yq3 3laXLv9TDM1O8PXb662YZpJIlcOBiKSaiZ1IZA45B+POnCPHd2/YmHulSr0s tbYJB67DUZMaX0UHyrEdndodLpDmTMDTQBHrzigcik0BVPuF/tQsQmCYGiUM kZJvYTHD+K0Qa00+aLRqP77g/N0c+xDN2eXJI4oEv4Jgzs7IflAYIC+c1cMI vY+mvr1YPebzMLFx227oOa1cpr3ZPWc6/Q7WUyZ3Q4lKxlIOfD/NYUyWfSq7 /o7sQhL0wF9zrgMKqkkowljOFftMUfrSFRCL+QUd3TaQl0ee2Q7dpoU7Cf7/ mve/eufyKu31vjxly7720pqJoIdMploar1r5+npK/D4tQ7dHU3+3FPxmeZCB JGp9WUbznvfd8JhcrxmcIjXxzPfh1/UvPKs6lZL8R8uR/D4kl9KL49vGxt76 MWgE8D3HYteJ5/OPCq8i2MY2d1rKKhzyc6n3L9fNjzgSnUgxbCRxY8uwaSeT fG6j9OyNLlqky/QVcRRWgXzhydHu6kVbZqDNs2O50RIeSTqiQ970JawIJ0gl alPSevvSjMKgu+hWOlBu1VRA8sNqCRjwq+7BC3lspkdnGpeT3l8Egmvm0BbL o8dMDaY1jPwU7tWGZtqFRNI+QecHyUf0JzgFW3yTJBG45Jb2bbBDeMuSzeoc QEpOMPVHSGTvzyneQrLOPMo7/U8HoQhKVFpz5r4sxRrtKAOtUYkA0PJWP5Fx k0x+LuNoUGVPPaJPC+FOV8IOr9SMpyHjraXeg701+xF9hulv1T9NANXybe5E dzmB13C6lw+kFgJHcUDuCsEXHsxAwO6epAtI0BUSUFJDK/E4rIAXPwunsIna OkL8ggoLBqr2cSSSR6Elr/TmGkm9QIVokHEMrtmr/RZkkmnSv6b9ukHysUNb 1JOtrPwyS2yEhDdlZ7H8cXzUsiKDb9n5Sc4uDIQFUbQSZx6UiRSEOP3puc/X AKQP58562zLkLImE4L3J2E/o/bsQfAaIIPdOqPRT2Jy3fkUoymRckToR77P1 5JM3yOW7M5EH3q7xq2zeNK034F+Zf6iExMhNgcnMVwq/beB4gccfRc9RGHEN 6ajiVCb1KvFmLcMQkIfL5m55egIFlAoUAvvCZxdvYYn6WZt4hufhuVj2iMC5 nAhzcMkslPFDnN7vZew0PieLDXxSwZ0qKBO5wTu6HSZO6CCWOeS3zk26GvHc R2F8CMe6jkW5j2vJNkzTbGPBQ77naXqc4kGbS/xNJD4FMk1efCCS9fGnChhj IMWAuu1rAMiHGDihk5PB4pKrdH0WRt/Ds2Q7DUG2xQhplPHdfeeO1Mb1Im22 31OKysGXwRA6P5uOhTPuQJBORkMj4wPL9xnnEyRzjnBuw6u3ab8hyA4thXsL nJ282nM4jbM+ZCpwu4Vt/xj+EcUodjuKqGwQWQxur/a7P2uyYCJtAz/BGIMN NiXu5xhwrwUFiiyXCtbvnZ5mWpB6Wa+b8/ob2xqjLhcFiTtFGMJktHnxunjl XenD3MX6Qcnjk0w370zMFfkvuRjTQZJMc1iWwhCEggXzTgmSM5ggSPOgo/Cf h4mOEWvcq5mZESCAXv/b8xq1TyC4vua6C9TTO1mYIAJJDDe4mdi4iLr06Lu3 LXfMuY9d12mlc+FUwx3PBk1XKhZBCJcA7VRMEIq3JVmcOBhYuomwLNO0dnKT Xyh1TQV+KT4xwnyJj6dLvWP6cNtg0pgeHhZS7J/0fHRTYHRenydyqggeIn+e SC/XjDnxoVj+sTyztD+cDs6JkhJ587Dn1fFI3GBsMYLPuPtr4kA0Ry0CexB4 dk9czPK/oVeOKdet/jxPP9x6OfCfJ4n21U1VIdjhcXcHbNFJIRBy2b+XdwPK VxoPpE4cOfmwMDxHRBWgDDt/L2brYuePngwojUWt8LK6k+htxDKlRAkkHDRw nSSvw3drL9ZaxM2Bj0Wdc6lvszfKkwQ4IkcHYSEECHTUml0xiR+H4uHHht+c zmKMNalGMbb9fkKUGC2o0xzz8tqZ74s2xlaxqIgVgbEIsU9s8sI5RqXVZiQ8 DtrhRxXJofE/u90Zx77V2v+4qo4xwNZxrWB/M9lEcIva1Roj6j/rPYYyVYO2 Pk512qpHjz5kj6ajPZxmZodzMcJ43KkWzeJucEEOow804vEVi3uCR4dJpyzx hyFTLVCceo+/n364y20bF2HFsfyv42l3kR3HRqj9rBwi3Iz4iYypPDyhSSZd v0+aga0N3QjrnrTHpb47Y7Odiz0h9K+tTv7gpgLy7gGh2MEHt/0lEylT8+ws rfQ9phu4kh8udGplX87a/OPqn7uj8KDVNsZRlz3y8R/H3zyW52bJlEUihSSZ aOIH3LRBkMOdYklM8CARul9E2b/PnybJk3eShS/+R2xzMdZlI8x3jwhKbvwq T7R5fIKk1vAqLdM/oho7zJItqEA0Pre09X7PUdoiL7uxTv/Z8XarpQ/VSGBX grarMzUzuY+cJBVg1NJkyrGEwZpeC5L0FS6XKtu1tz3HUJ98nSYIoImJiCjl mHAnxaDDZvUvX+kKxKfXYTJIv216EGZsmQdSReNMMS1vmvIGjbvLw8IHho5y WRSADOJAzNGMC+7o9DKbE7SqojUsmlnuzlgH6dHh3Ucgf9ED7b4nA/M8QmDR 0Xv4tPv1Z6pACPmuYYHTAe4bz448CQiYGC/t7afiIQ+zzQJ3uVMSBVl16i43 H6IW4R9W9vxi4pOz0PvjEtZtY0OLVfRjReHmvxmRvXAfFHSOFtN5ie0wgl23 F4eWEcMNJDIsHdk+DA0HMOgOs/sCQ28LPoXhfm8D1jvpHJPP/SBDt+upWJul y9fM44avQbb5sjy9gOdixY45Q8+ZzN133SPdZrAw/Ec/GBA2CEFiEIoqoShK GlVpUpSgoqYiKIqmRU4mY8eXbjtcs9tr93X6t+70E+KZOPJ2jfEw+XwhCxZ6 rNaz0x5qGMNZnrq97ip+SnR2mERUj/DUbeoYUeLzRn7r7mjX+r8KbClBn3MO xh7mhsDO2qRibLLrN/zTeiffohVMdFlx4Dipn3RHd3ARtcWfZWDLygf4kGOA 4i2ZSRtzfOjQZRWYJ5HIbT7h4bj+d55+zZf7B76B9h1agSR5Vvi3dkXZJRJa DwiEXgUPXjCgO7ePKjSflK/dQ6/GuO5R+S5eZ0wb6YkFiswOMeTkYTgGC8q3 09RVFeB+etmncef92HyyfDPl7YucwvfNWDY3fZCryL7NkJdzZeqCOvRuRNvu AdAJNto2nsMODqYEG8+kpxmVDa2cwSSg9baZjHKaQbOM57UUw5/VKe828Q4N ZalFHJItfMX6WKu3eqfsj+22P46vKvlyEkl/SqIP8fdJCIfIveJ44nv/pynK vLXbaRyNnrVyE3RNyXY8zCh79fg2itW6RBgXnD6R8qPSuOG4zz9XRgVFJmj/ Yc/OhpYOe94HJ1UNp3kyXtwlSqFRUeMfp5PGc+X281dZXP7MkXUZPSclle5z Gzf1mPKMsrwNtv8GEJMIYEwIicuzvf6EPSRUueHFcsq8GITJeu5QJENchVkH 826wLTrX2Kic+A/b21OG5DEww8CdT+Po8iYm+WdNEnUZ2iS9Q/3KnPcuKbqe qbsXhnkvheNrdYnWWLsl5X/DGJ2T9kGJ1cUcIGGyZyHBxKDaMwmZBEoRBChW rn1YQJKp3QBz9C0abewOLz1M2plKAjf30Y0q+UIQuET8b4bdp24S7CbOe1UI YskZvZoPPYpDDGqj/WrdSxKFcUQwcceELKOvIqQYPjSB4yGoF1F+HXvVsoc1 nSMz2U7HvwK8bffDEyTRm7EA5ZvhKQkZX3cVFiiSZAmQ7Rx0u9IbwVbeeLvs zMxXv01nAwgn7GOiFqT2813Jrz9Zs6oocUOEEO7phvB5/HvwUhgGrqIXXz3g WYZp5lcbnKYN+CLtbEiPYjs1I4yxjbJmIJsv6xJTpnbHU+TS7IC+CXGqx9lW 0mJfULxg4sFHrL2k+P11xN5OauyRVEIcOkTikKNDhcl2cpsFrXMQYGZprljm fbgXsVKV7YyQ35uwwO/UeRzvrywwidOnn2ROdGjDOjDYEuua6Q8Yo0Z1MDI0 sVEhCJVPjU+m6Z6+d6tY10amR6v8mabZW/ihphmQjRfHFF6bVUwcgUvkUlH0 p3EM1hXz0zx1NBRnaEKDnTxJgdMh9B0L+6E5XqEtcD2uHsUcH5gD1bOZt8da wnIzv8TXZ5ufqTwCaVGJifxrOzMDOma6msQVjhGXFzoRRVn7udetXhWhj+Eo mJv3SliPYlFiSDIIEz5eXleDxlNDrfuWKeuo9ykI4P83V+1+2G2db0wyb5qZ 7a0t6iPI+f+Kd1P3UBgn+rncXx7u9A4tX9uXowEDikkfVQ7+RKS5Q0bPyx16 F0m/xds2S+Yv8/01j7aiz71oTILcRLwSqYZmkc1dkQEBuyxWSDq1cSUmeQcQ mcces4Gpiu+MfaKaiNmDUJIRLnEf0oITcnjD/OaXZnrhuaQnaVwRFKEV5twi kX2d6WNup/g69fxjrySa1zpE4/FNKbx1c/W/bSf63o0PqhfhaXyny8CR7S8u uP7ttc+EKUK1c973ynKKdB8LroFCX4/HYJErzzYbI8olmnPOLxyXe8yHHNyB fSG+Hb3s3EN2y5+rb4IaIO/7N2ksZwLyztzsnwIiDnK7Qx111Sxa4gxCVKmH 72Qfa5q0K/TaNzYT7xdJhhnGMfp2dorNYpjZMxbuj3744Z4eHn1lPAnOO10c diiPDjhTejp+FpjRoZEa3KWeJVPRu7Gv1ma7fLwJZKf7jWi3uxgrdxHP1HI2 wQpNXhfAz/ldrTBIHDhuQgbtc2yr1uz7FNbZQqOwmJn+VjhmSyIsPeF7mROv rYMo+Ee21YVLhPjtFu+vsr9z9Uzu+DJZonOz5y0+XP8fiDsm0NvX6DnXpjEM XJ4g4/CLM+xTwOBfeQWhGqlIVUXaxuSH1ROP1UfX1/JADYR3NFJIdv3VFNEB zVrgw79MpmtZlzxzsxrqyem/7nIye5Jb97MJpfZc9+2JAu63/LzpX7cDYq73 XnjvXKWIa3H+vuL7Ro/3qIQcw0wJRL+EXjkneEr0HKHtzc03doLwKuyWP/BO 3korKoJziGz3piSZqWooN8vd88D0AHyfHr28+Yhy/TrVVEnYMIVmAzGB4n4f 0fpNmbOfERD2DF0G+QXBePUuWqa7WbfTV0JI6pvcTwC/6eJn4oqG7IRBrVGM h25Wt/gJ4GhDp5efebNJTQhVANL92yee7m4+BBdoWxnuo/p3qYeV9I89YFSD joaWh9P1UnylnBilyv38NSDSUQeQ5CGnjfWNFdNlqF6Cn82xuRoENOM5Q8kJ pD9cV1SaGMQH08QUD6/ZCMpNm3jCtKTDPJh5JKydDigmkvmg92fLNeriMYFB kmvU7j3ZsMxESJpvBMUWZ5mxA10uAbAtWM9FQREQkCDB3BCErIdbj7o9ah7A gQEIi5o8/77OOlHCqPu8OWiGjFiKlMPbghOo1odWiDusVKt16J3jF9nAnst2 gd9b3y2SpFtQzsu2q33FZvJctbnDVY0DsK49Scttj8edt60JpVA3c8kzNmab jMN0hho6mY1c25zeBxp2zOyWODhfpaF2sRhgeDrLF8H/ma3HIicdGAgbF0Fu ooMavzTOtOOccHxmbQdqoq7nBqzfwre1aeKb6kZJpXtimh07RvjFV8eZPPpU NaEm+K5aAo9TrFn0lNM6NZy6JHC+jVpf6nd3w6RnwIQxPWXl9wGM2GdmYZN0 8TMq7dB9irn98jXZqoYkGupNs7Hov0+Wbz1lPaHa4aRIChgc5E239kVvhuV/ tJPoMr4LiZ4QIVA0kN+KI1fTZ4iEISdVOppIOxyugu/vfQ/K9ZTvx8ZKlpKH PxkdjC82KGOZCEGEu3c3pfuvNhQRyFNc8cL8gvhHSIY3qRPh9KQTdl+LR+X5 tGnta6dLjhk9swTFv1/VMn8S5gfDhK9F/RET0e8jdUQROrX1jH1OQi7RXLg+ G90J5buM2R+h7XDsMNIBUTDM27ljvOyG654pztz0xFfKaSD+nHsUIKVZSz6t PS1cApLbR8/ofFXYMOc3dIiKHoTkN/fgeGq/Vd5DZ5WO8RcTysSA48CvxxYT YqydxMJdhg6IZgF9sjBApKNr4weDRmisXxjhBqpSaEDFGe+JKPmv3xwUG/bZ 2REQmyr2bzaWJdFMRYqRfPYchmOWEkibFIKlipHsvhqEUpNsS4kb8PBjqRVc MdIXvfxyUYZQIlb9nZ9rPimtApuPppSrNGum9N/QYBmlnGVMsfRDMzV30vOR +mRflH1QniQdfPh6L1ngbbCe2ehRqP5Ih23nA43isd1Nk11ZM5UhGOa5Zidi 10yCiAuxH2/8/nP1n9999zYd4CuF1hw0c9QsL7CoyTEPncOd1YmRZmoISaT1 elhw/DrMZ6uKXsO/fJnPGowsxzDvZO6PVaU3eHxCjUxKx3ziMFu6j9mmn5xf fu4R1rWeOJlKQ/j1pBTJmrrt6ROoerEjEOI9Tgy1WW+dH7S/QumgtjErtqfG Lj8q612x7Kjz7a3tXmHbXVc0p3T0dk+G2a0Y5IxniuNs6KjDDb0MPTnnHD8a SzDsWUP5jmn1J7VGvI+y+MkyTOOMzCsL6QWCd4VIWy86RbV76xblvvoSzJvV 7sb8InM9+8bycGzOyDjCwpjGsUyijGycj0hZZoJvEJlqXeVgVJYxnUVN62tY cqwsTQ3nMTJ2guvaP17HxFPcwQTXY6vpVGWOZ48WUwsOKjrRRwrIVkE+g5xj q1YXnHneM4SrZh4Z72taecyvFNlK9Z5+UMbh6VyhG7J4THMZFNpxuzwfWHDR YLwdQ/Y5IK6HFZ0PYqcqIUbJxzcgqFPDZDtTa9+NRfnvXJ20Z5FUNInHOBc4 6pyzURsXHJ3zPfN56yooR1fGvYtkDt3jzLZeJncJdTgw8nMGDtXaZe9S+cno 8kGTseMVrlVGKwZiPHMcmL8T3MxjnGjJvCOO/NTnohCWmW4vE0sURaxMJErv BlgTjrCBkqmwhzNX1uTrDBy2dc8MLsc6CQ1tKE7Ts+b6SKkWUZvAEspvBN+q jS1eJwCXnf4vBHv0QdFfCPE17s+i442SI7vv/J9b00Jkqc8xTzuvG3674fFG NvR/MMpzPdDiMU7xUSeeqvox7yTg+DsTt3DY/WcEXs/ffwzMWZK81r47aCS1 xHHo29O79ns7M2kGGBoR+Z9iGypE4RhJR8nzgxwtNaD7/MEHWnH416Kwq3v+ dUYreCViXeU8J3t821JNKIEEJAUqIt3XFMO5CXb+GGhI1i4OYdFFI2QT9ou4 p/j+SyUYHNg7HoTLdlL5HhXJ9GeeoeD/bvjl7L3uPJD5tJIjSOjSGnS1UmEJ w2uU35NPruNWNv43985Er9kFkx9dVPggjv/VRGeLlN3koZQ5XseI4xKNdV/Y 4MYV2Qd6/RF/rCfTAqQPh5CcRXom9iJB8r9qAyX5lZO/3Foibue7IfQa6SIR c74U+5hgek0kJkhIpaRwhwhIhH0x1pahixHpa1vOnDgtAEwnOOA5BVAeoFzN B8oMgOMOTQ0AFClCFCnD6XCDEk0ziSRB2Kzw7PK34WDxr2M5YZkMgSvWm4zN NgbPO2FI1s6Lo/EvD77L/jJq2wHbyNkncSWee9kfmEaXoRag4nZdRcUv9N0H CFHDesI9W0Nz8tGgIPVfRsoOdlnYvpjyTegIlkt2ZtOOhmEvui9vusz5ZvoI 8COUzavA5qA+fvxbL3iE3UPB+ONJvYnFHiF7CAiZEuRw7B4jUcFBtGZXDlhs qUFJ+Y59utnlkMm+H1SnNBwFKusGfZmDHvczl81+fntgOJkJkJvOp9Kv7mGl xiMCi8IbYkOGusYp3edQgzQWxho0YXlOC7PdvZxHeCdoYJhSj2UVnjCOj7OW MHb6VbU52RbIIkGqnMSjjKDabnHKZvhRoNQwTDYQpLhInhj++u1v0qCP5Nzo b6mzv3MEmv3bigZDA0113VyO98CAMD3kti69mGS6nOXB9JqPCkbTIQdkyTK9 OylZ4/q30PxixLj3GMGiRHCw+ShKDyV3VUS7TrNn6MVkesTpDfjDoTAmwnK2 HziBRodnTVzT2uFe4hMmhD8Os3qrfN5esTeSinogj8KKerlqKmSIaixw81+W 5h3qDW5qI+PE2HGBRn3sM8csxDDZYaJzjGDexT0uPxrO607v+aeJ4uHIt0Vf Yrpjl674EJxQPsoLwFUvo1I+dI8VLLoY5Ucn9VjrAzvZ/qKNWk8bEO6rlMXu QhYn+DCXn2fHt3f0OZJzVSUu7uNacmG7wOS5LwNXD+CvtGpTQYS4Ucg8AEfV B2UeFZ0ekvK3KdsL2IUwh6bdxkw2Wdcbo/lOeBjiJQi1/s5X7U2rFvUxLHPQ kksNYN9J6vhx57Zo/Z9l2on1gHINXlHtlsv/4TWfxcP71PGKPOCfmaifseS6 K+0uU4jzVXuFQqy+fs7uPBwPnfRz2D7t/PX6AALqehJEISTEFBQlLVMBMQda BuM67Hsnmon/LGyc4fXHk+P69tXG+eCme2kuPbU60+6cNa0TmgexCPkw7wY/ /mb0KSxyw0KfveAEC4BxM34Xfvmxzr+vB6JGkKEOQmJH7CRylgdA/DOc00B/ dND+Ecn+lOCDEOc+I3nbFBEhELIBUJOM2mnGtX0KXXbmljYp9OyxNvpNJ9Ow szEOVOeX0Fzw5Z5LqAWMBJEHCrMbF9LQIfwSEUMzQSISRKJaI6UySNAWshQE KG1geKKFtY02vrcKY2aIgS9NYjWAbA3+LH9G7T/kfR/Ue6qR9Aau3xb1uaft dr8peCSUHc8r7iHqhpnbTGzgzv8Qi/UhBIhIRGJECgmXX8qDFAFJBJMA8ZyS lO7p/wsbiKa/vYNK0JSR0yAYgjrZiilSBqJIs4TshngBgS3k3gYpDj1os8ec hkP5E/q5GgU2kN/uTBD5R8JQen5r46FRPPtlMlU1RRSiU0wS0hECP7PX5fV1 8Px2/xXqkFPZIBQqX/xfuNKh9v/M87p+N2kPb+O5D+39tP7i5r/FuP12l8Ze J+ePryxv7Ze7Hr4dn62Bvgg6x5cJwwx2c22QJCS2v/bI+ZHiQ9yfyNvZ04W8 /TmZarpKhu/77HWXx+y6kpSnswfm16sGX+ZC1JTR7xLQ5f87NdCj/y1XgO4S A4DyilwSEhflO3i+o5h/eU6lBWxha1gr1iBW+q28sc+4NjDZlvNv9YTlszQU WN4BWI7QRwGTV1HAlI4HLJgS/VNfx0n0swQ/EM/yw/Ph0zi4EhRIe+xqOPaQ wE5/g0Dv5p27BhAyJJ2lvZfLBMnbYwMAhKYFO/psgNt39DgnE2pTM2hAh5o7 4D2wSyGFnu+Hb/Dk5HhAG/E2BA/qeUKTIRCeIBrS3rYg0IXrAJG0Neg8fz2P winHFJH9fSPhWTEz55VV/nSfqz8o/7H9fzUwttRzJv7Rdv8HdmZtkHI4yvjD OhQiUgCHfni5B8IohiJfbmIPpPcgm3Z0uGwCB/Jxv5dPEQaAKKq/f+3E1UBR VVUVLEQ1JMC/1rTooAxAhCMwowRDS4jEQATbf37kT/Y2EGQogoFBaRWiQqlg hKZQgiCUEkCYkr0KuShBEyiAUg8f+iuhMniybxYNRSEOfd2nZfZ/NgvE+NZJ MVqh3BE6CxBe6ABxWYIf54KC/XAp/yUDzYc4jYQKCJqOHP/ePxQ/z7LyDn7G dB+KXtyXsaPX/dlBxH+9+J9xxh5gcH8htA0UoQn7LsNIEK/onsJ6ECR7JdyX 2sHzIGSS5e/oYHbPjKXZXtVbh5OTIx9wiKhqJyRV5Jmh9tD9NP85mehz4PxE CEwA4hpIdHNQVg/ozk13+PdGtrNjNWlLRYToCHCmPnGXDeqMO4ScJ/CEBfoJ QPuGlIAhoCpRhGQXEApglEAKVFP40iX5dhMOBt+Gn5zy/2OAg75gLDIgCZho Q+pcTr18d6kKpJQRTwkQACij2CMYBAb5wIyyX+bOed9qQ4GRxtJJD9hKI9Su RaYiOSI6wB1wHiaGUtcq6i6AkVrCwKqk3COwMM3h6TGjI0B5bmBMXwDy2yZF WoAJVShnzVKDRZPRusvZ0JOvFdjEkjEGOJsGojAWKMBgZ3wssnIUKATQAUqG Sofc/h0z2yTAAQDQr5GF5vUOniAEIQzIkD+5sPAErYA3wVYVyIMnT44C96qJ yoU9kQQ/ZFttagCFPXD/L2uejMRKQO3ztib594Q/AIV/3f087ZQdsm22yJtg Xasf84/skT0yB+H/QwQOqQ7Pgdul4SoHhCwertXn11DyYsftZFWborAYCOzm eB+s/gYMwRK98AhxJQDzQrzkdoUpAPV6qxE++CGpBEOkED3oREf3Bv/NMBgA N95VVVWED+8SJ7kAPtj9mUPXrG1YANopF1rBOcidCUA6QgBzhSBYPCUA48sR O0gSkcg3wA5Ig7snxpAON0ImsGHIoHjAzmhQMxANoEOJIKGhCVD+xWzgZ9Ui DQodxbVKIcanlmCpxgO8qU9zvwAA6d2e/j/b5JfD9lf5/H9uKlJ6/LGJ3aX+ WePxHw/yrAvx95kv7cnmuh5M8OvtN4jVZH1kzzlGLH7VZHjVv1TmMWla/V+O /lZV48fhLcCOtOxjD5HuKRRLv7LfOLOhNKMBQrGMeaH/I/qvvgxKbtNGyX/T SBytpl3XQ16Z+hd/aGEbD74Y3kBmXkwzEBmZtRdxmnhuPQp50vP6uc7LLLE9 DBg2NtifEgO/79TelKHmpRiik/Of8YyGmbB4nh98gYbohzd2YZBNj+PXwaJE RNhj/md3c0QaLQvizgUvto/2eend1c3S9aptEXp6RK3ELd+Pb17rXtTBH3IM rVIz9a6lHdHl6aQGvyz7x/ql3gRjw4mHWS/rz843MGhw45t+wyLz2y7uPK5v h24cQPXk154+6kHUfoRFMzDaJjyX8BCRyp4QGD3uX/MHNyZEPvhhVgkSR4/3 blszvbdqNqsJbUoY3UphOlcZrh898vh4dvjHtrMocEXhsb1DVNqKbw2R/tVg NK1oRaJ0H2F2/N83q1TfH4yC35NsjMshN3Gh85Ydi32f2Jwv3nEdRSeStHCM DT7Dzp9K6ScsBF8glJfP5Rj4fJgdb7758Rdj3yXh6j1P/BgMrW1g/Gt960VX ZpM+c3Ok3cnG399471zGiBJcZY6K117vbuRptphS95iL+2IKr3Y70YWFEY6B 9He6nKz7eD8hn7rthfV9B9auxXiNkGEDMQHVi92+ILYTDCYaCkaD8YBSi+ne cUf67xy/EvTGp4eGMfo8OviYD+IjBBxFW3yQNUoG+KyGkuDf2gHsTM3eJpkA dx94N5BiXwG9R244H1SC6NpbN6YNrPEGM72vTHqNQNFtFO2CUQf4PdEePq1X O5oarfviYLAfyATNVFL64XdKBvvsl/H+ndpH5R0ZGI7x1+ZKHbqVNjTOOQ0r 4QwP4m5oPvgGoej6vB2c4Xoz7KX5neeIjoWWZyNPlGBDg7JiYRrgEOhjehXn IzpgeyznWq7/v7u/7yRfRny9OEDhWlcd+kizRsbzhXPtxgx3kqeDMce7nM6f jYq3+ysG/Xgfg7VNuY8trljuCLoGb0/PBBKn61dPI3+oC+aOBeIbiqwCEDFb VvuftVPcrS2QWqXcrc63WVJYX3zmjJ/CVytFp6aNVM7YY5nWvj03DOaPjL4R y/D/DjTNdkH2zj3ZxHXfhpFAutxvGODRu6cKO2sXbpRUc5defjzfDl+4hKwX ZZVM7jNyHGkepXtMp6GA9wjLUk+8W+gFjF89N79ZPxtNmW/Y9XKzNwfn/y0Y tlxj0/pvgv/DHGpQ74TRjLb+OrofXKKhpnB7fHw9+uptqcFMCqbq8T3Gpsfs IM+U2Xq3wUNkGGaxuIp5Gj8/7b+iatzjH57vHup/tyPWnxETrGrvGqfWfJRg 4/MceyapH/1j9S85+DZq6+uZ7PPz9LZtiLt4TI8/e9y8OohzN2Xs1Ibefi8l d47Upr9s8K08KRK2Mux+/T2+56tnebvzu/6r2Z3bZb5mPPtz9Zdn6c3h2tkX S0UsMUYSMEbwztFt6ZK+NsumpIucxhfu4XXR6R4QjXNPmsVwI9mTF8JJdJFC PprAynywvswXbYYKGFXpm+EDmRoR8UbqC8PSEaVeGO2m1Y0x6X9RNdnO3x+T 12ohvZvvv+rVwsYT489pa0fnseLXfLBnKK7u16wc5ppTuzjSE3h2u9234tGM rONe2/hjDLut9URnURWTMaIPXCJqeMOyeTXZOxWrnjJ/frfC4Z37EXRV47iP XfIpe4/Dd8b/jc9rsKX969p34XFJNK/Dt19k8OHfoBwBka5Qb6KPISEIomD7 GQEGNb4DPED9bAAxCt4Eg54zO5UmvxwoV0oB00MHQ2co6S1oEH1Tz+fje3q0 SK0L3sV5HOXC3uugXKOcIuUlN7kyl2+yMCxc61W4UaQkMliTZcuHM7CLYHaW Rh+09Bhe3r9vnfti89net5sY9Q8w91JZjoXq622GMbzAlHjwXMwsd5bHi/w5 cZZFul0ud1j24s5amOFZUu6XX/CdYzOBPH8r+rfzz193RtHJ725d4f6IaIVR Xy6n4IqMV1XPve799N8eT5acZrtcrt83L0HZUj3uV48TBYJCFDY0K7WOnZEB hveyWrjH03OPcO6JHY5yTM2fuuC7gT9Pf7reuOZ3HZUd0tR06H5jqHOJCCio SUXFg8VAnWZAv1MxLxLuwjwfXtwxuZt0wrh2/uwZxe2JmIfmivM7oZsOfDs4 kwhpBccs4JMCR7rd8mAD3W3q1L74UTIQhAgEJkyEQ93p6X4Zqulq6kgYeu/K fHGvw872P+hwfzngQp+UVDKbjJhhF4mZiKDAzzgSn4T0zyIHgjp6vODc+VIF yJ19qeHQh3XRc0DPzSSQDgJDDNmpE7YEPD71Wl6AOSGG8hM0PeXdY4Wivb2a wM+vl2ackYUsz1qoyQ4kvxg/dR5OYPmylDOZeJpCPO6vhKq3z4nf0OGcLby3 HR6iYoWYUhCPwN/1Bu89UzN/DBiGsLSSJYAiHZr7dmuw3xR6BMFS/dllK3d1 uHjfBroXwbui0oxHWyzOkjWXs43Lvj74kSkoaUwjORgyZKfs117A+WVKLhiR D15E2nFmGXiOHlCuQuTuNkxAbce8OrvL6tv7fb8UwpCnJMzEf+EUoGoAQ/h/ CsAV/jACHzHzLofPKqqK22G1g2rbVVVWNsHfMH/Zyq88qqqqqqqqqqqqqqqq qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq qq6bVWNq22eQnqe9wfFDnObeHBLnOLtWT4qyB2k9esg9lO19qtCf8yz+Voo/ 5QUP74CCPaj5o0H8ZCQVUS/2JsY6k+jB12RnkUQPZCHQjiQHJ1xgQ+Z+PONF nktInZ4d9FZk00NoBpDCAzeQKwbFiFYFYDpzhxOjwwV6jqDSsIdsKSpKRiBP 96ACJ2QChQCqItlEzYdkMCoRK6DGxlNoBRIM/wEoRQ1pE7v6O0/X7vhuIoav tfzADuwMDA46YTJL3/N6V+2x9HsqbBsADMGIoIxv5iFAMx/0wYmiTqYdCHrC UwDTgBCjkBQqUioQXNMwAzN3M3u+7+5Lozj/j+79rw0l+Opz98/pujsdHvod kDpasI3RJez7/rn9fHLDilri92ymkXcYG31lKCsSrMTxqeGB5yktirSK3u+E Jp0Kj7J1OEfOGdNyH2mhcWWP1g5Oo8r39z58MJab36ZYLMmQrOsTIu1ncibG 5oPhem3cIzEWRjjvlFuCjwa2umM2wwe0tFE0+5QuJX0QRnC7+dYSwfHtfw6x hmsfAkczk+hujYbnexmetx2Emn5I8pfIEDk1X9j1rXwnJOL8SPj/qsxCaZEV Dnp2pvU3wXOATXVclDr2dzRY8I7wZHJ+KekN6wWVsa1ZQQkLEjEjSH5cC1Be s4mtnbrwj38ODbfRtl8uvny55mJgXdyDr6RYCnZ2PPnxgofqTOKyQnVJnLq8 3Hum/l3xNxmZb46zJ0m7B9j0e2qIJbZ/GSzzrOPMLCD6HjJnXtl75Kc7Lo0U l8rCz+F/k+r2B0xLTd8FFRu/fAhB8pPYul8Ds7SB5dYP4A6VZhyJKTPI74QW 586rFR2oYfHExMUHIdzu8bxxAIv4ldyVyPZH+rfy4SPmfW/I+Vqs7EC/1Gvf IzTeLumWnVhyCGw1ZCEBo8Mgenj/X4O4ri3gjXoeKYgRMRKBGEmRuaONhiNE PKcmi/7x7G20icChRAkxaWFmnEox+VAeKOIGViDO7aeUuzGDJUeHbLX1tw4+ 0jBJiCqsDCWRgn69flooyuJcT5i8n2Vl54dv722D1s3TZuKbAzNgI4pr0tdJ U3VyNLnpnd19kh8Y+uGcmrv0+s9RCTSOe/rLGhYvp3ciu9C2rLRNW+AUvlos EXXzoRu1e1Xwurwr80lJrHofvumfH2a48Y9c4qPW7RmmSDZjLWQSJXN6+FyE tsPkoSzXHE3IZKa05z4ayqajNWF64H+5/KJrPLVtCMRvdfubFxcukvozu+q6 6se45PpvdPteKqGglo/SKDlc8Y7VSOO3bHyMNkgzvylAlJJE5SFPoOxhkY1j ovVZ9rPW2kJ++d6mtV+VHlkQbuH5crSje6SM06ErpKWAS0uJHujgiGqfscc7 S76Tmc9A0KUqQ33u3Eaj6p448L+OBX1ckgRDcEmfztmXZRtMrK2e/SXgYTJv j3TYwI7E9Fk03IqLuwQUe08TzkVOZp8mzeyGEk1PfU5yjlxcovJtIM7LiHhI jqPe5MuQkCUWac2gTUc/Dr3+slxUhRWNZNk2Uo5OTFffnj3xOH5Z43X9r8S/ 6TPiRk14aY98X75kA1m4kdO928V39mOPdrldwugufE3hLqaZvfoXTo1U1b5K m19G7qRuuk44hDWveCwJc/T5K2mY754YSJZGkdZi84XR9MBILmZhtTv3Z0YH b9F8ZnZOmwrk+23pEupntFv+0r/Lz9U2xR67+70zB5ux6avaZteaQf4r20kU QDw70P4jqZhDp2Cx+ufq/v9Cu5X/g8crhfGJA2TckL6Z90yooGs6HS+/sjCe uagQD5MIltOMcRSrE5KJgylCo9MalKxwuHZI+/1hVCzzhg8zmV8E1CvyHSFO RlyhF+5rmAQsCmJSJ+dN8FBxz6fM4PwYI+vv4+/m9SKDXxP46oxl8Y7E45fS VKPjKEBRk88dePGc+DUTYJmYKPj8ls8GBmb5/Uv6/N9OBb/V9+Cm/1+GBvjd RjXRhy0rsnMiWNsMQaQQhhjLvqx5upl85Kms3eL1Wlad3rMPGqlXRjDMzvah hVKfWcVq8ZuIGUOxU5INJjOc4Dqh1h/tH/h5eP2168GSIK/wMykAgyFJJECi RUP34nH+GxvEUMc/RblBA93r9lmZZmZmZ0T83uoqr5p+kTvTiJuT1AGlEkkk wmqaK6pqJomiaJlXRMJlImUwraWkTCZS0tKSJhW0ykknU4rxOiScSTivU6Jx MnU0myskkmkxNJJoSExMTmfw8+Lnt1+vcTMzKmJmZmZmZn3aGMCGEhhMhhCS HMwM/D4efuWta1rWtfnD9n0vnnhtOSSSUgMUQ0I9WAe/0DXj3Xn+prQfS9DI OyElyPs0g0rqViVUTucpQgmYQZR/MyErU+5wVMGqQ06Q4QXeTqXG9pxMpOCx ROjg6O94HUd/TQ/WnRPM+786IcU8yqX20VV9IHRIoqqqqqrvVU9iSo+tOn1+ xPVlO0YG32EJJJE8E3Th6h1T7mdPmm/t7s3Kskttttvv22223+ZHojsiCOgi o+ro2NRhIM7058FeTaQTPDTj5YXRW+8N0x+18k4KIever5dGL07gQ49abnz8 ekFBTTdPpXlmg4crDHemuM6W8RX2PyI9epwWhN4JIMgyDIUjhrQ8k1BDdPuT KbeL7xFDonJPWGh0N6xJZ2XtkEDAIFtngJR5p297JJCQkdrGbFJ2EkJGfMsY HNjIY9Vey7n09tVVbbHWr38evDnvUTuTuTgn3J6BNvFpoouwAPMnq/yTQHNO tPAEJPP2eZPcnke1EPEj0BuO9pmqqqqqqTwTzp+RP0KB9U+ifGi7YrbG2o21 G2+Sve7kiutpjs6tCdE+O3DtTuTn9W1VRVVVVVY6YkVVYB2BRAQkHWiJ3ggS vQThRIyEhIJ4ieCbWinrSYTCd1mpz12hzmeaZfe6dOgQIQkgEAiUhyTQtLOE VVXqsW222tq2ttttWLa22222trbbbaTYiqra2ttttpNqqqyZMmiKq/Kn0T9G +FbbbbbOpNkxPUnrT2J604d/Wndz386qq7Nk+ryVk4p2MSe1IOOKpr8gDilZ 98lEqqqqrvTwQeivtick9abJ7EA4cuHr0TAHqTuVHYGATMw0PQQkkqH98vZB c1N0R7v2Pwv4UpXWfs1nM9mOtTT/kl4OJ9bu6xwUZh+96ikkqFK7RUCmjrf8 ozeO0Prm5ULfxu4qd/d4zk3RGNdMcYpn/biuf5u1R+w6w69dS3Tt0y9RIGmk CbAXLo3zs+nX04WM+94+/PErtyxEyz96rXXEMdzu5vdPEUoioXwFCMUGQB2l km2h03z5bVK7XTf+3OmubVotNdzFoFV7692Hx7M4gSlUefg0y6/z/r9M/GsQ Z0Jn7C79YnVQ3ut1jEV218qnd8PEaTJ2x2m1Th6N3aQnHjWk3IiW0pT/Lmsv Z3nifZWuey9vM17K3MMSRieV1zHBcb3m/pb99pT1xtdwmzzdaZuoxb1b39K1 PUvmtlLG3pjOpKBSaO2I59k2HnQpOR3360CTfnTlylx1ldJ7ytfx9nZOtVzl CPgtPXeYQWdYl8aPvhXwwxh4xr7qiNxxxNfC/Tc2JJL1Q/9UvBKMtC8945rA vdPT8nvk4nj3nkwloxtbP7P9r0073n89WreUR2WKYp08H3KIyoEeK7xpULxH 09J1NpRzHz9ZtX+7v69VrGCkfKbu4T/b6ThZjDTVXSbRR5hnFmfSPPHmN4cU tvEHP2UYJf28toh3c/o17ccVC39zZGvl8W++xUdKTvEfh73h7D1MGP9GDxHX Un0OJgXGozFZp7zwqrKDkou7a090pQpCnRy0+VKaRLLD22vlV51cfJ4QTsV8 a0Yq3YkEGrCpX3vc3wjKD3Z1+WZjcaP9vyeqH2fUN5jo7C6Q6lEu5/JhErrw 8X8FCIWIEs4O/3S3i6xhKDfL6Pfj3w/jzyfPK2HtdzSOfq4afmg5AdnSU3HU VEYJIUYd4Xjv8fzXXagwmkkw3DapsCrBPt47dPp8O05GAF8lPlpttz3/6/SZ Jup83SkokkCIL54TPVHLh2aDuz1clH8cg8ze/tqNUdyoB/1OVqT8voxv2fZp +MB74fXC8r6L8XPFNe7DUO0NAegOvPhG077lBqD9dtLqOqDfO6dIJxnBUA6R MRNdzrrPk3bYnAA0XOcQWNY9RVV0e9K5ZDgBGJMhEIQBkmYb8Uw3SO3Tr6j0 9ShFd/cnnzrG7LImHYUxwurGJDHCcymfmXXWe5vXierSpGOFI78e66Ns42WD aX/jwupdk9pFzZFMyyzi3f6ZcLKm915lHLjCfOtM962wlwv02uNqPmi0sudT O3GMso3bKueUXyNLxT5X5SfDecaa7PWeVMFyijSPDnO6r20ndaBxpaW0+edZ 88dcrDuPdBxQc2ohx3Hl4ddaWt888HHZvTy2a8LifXCknvo5z5ynzWFcbRcu zpznjTLM2OJja3Pnzzuuq+GGu+M8ccYubczm4+MHFBzkoQcdx4vB1bBWtdzy Lbtrq1Zaq0eFFEjncYV55T5rCuNouXZ05zxplmbHAxtbjz553XVfDDXfGeOO MduZzcfGDig5yUIOO48Xg6tgrWtzyLbtrq1Zaq0eFFEjncYV55T5rCuNouXZ 05zxplmbHAxtbjz553XVfDDXfGeOOMX8v0nr+h9bWG0DuAyQjU9PQQoxG+fy GuPf8CPdsywhGET72PqLp3/XGN0VE1M05lyauVmmqMIQpTRqjXf59Z+SHHX8 so9Sb3vwzRyYe83L0Oi1Y5IVAhqrYT1PCtzvvZ7VjtyCtFOmMZa0fG+EG/Ue KG/9qCCGIKG74OyZ21tlFdLK5bkOnPvZJ0ohCnTldwDF97vpNyH3iqeKeWvb rNNc+7NPTjmZrDQaIo81rURAjFGNCSqhkiCklST5QGRlokIOm+XzOtBk/h8H btni1xHeb9CfkPM9ajkSWi96GBpWfgzwkaAShSIFlGSGj98RGCpEAS/8XAyH IgkZNjFPOHOIASJgbkDc8SZiomI83m25QeTmp3G7y2xhJ8oRRTamipKPWLEO 3EbyG4Rk2LADYqZzofKAAE0ei9sq+eu+t9bksf9NOTjCeKs31OYfBVAD98Ik ipCsIJMIodcOAnSg6VhJQCToc/bf8Bj/q389wOmzZxSbpZOGDXDcjRiKOaN/ dOmN07caTRSGksYadTHCwmixVhWDG8MImwpSUGEdYDyBoKDpBi0tK9Y5d5lO 907LRFpHQYgp/nxqJ7h1iNM3YDU029ZfR5jyTzatctcAkbmDkY0YytNrcI6a qCujlhWxmMEbZSTSXm5YlfUVVdCDFzanSvT2YPKJjzJ/o3A5LAPxPWJBSD2e TYwXDbli4BQgUszQlKlFRpME2fks8eaDUQAFMbY0uaKGoB2M9zpaSIRgQgYH 9//qjRwtHzT2I+L5/T1/ldzMcy5XmZMzMwILaoif6YT4+rYDjxFwD7YCogwd 4JxHZQMQoHiKQoEikIMIP+EbRoQbSP3KIRICsK2Mk1GHvdQ3pc0EEJQ3A86l qIqJoGqAlCfDY38EFchm0wdYcPbhQNAiqie/5kREREREREREUURERERERRER ERERERERERERERERERRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR RRRRRRRRRRRRRRREXQ+9TwXxFPiG7eRERRdabCvzQV3B3JBwDZMDcMNp2evQ EFKBVSBoHQPsyv6BFe09zj5ZwjpifZE+qrTYEf7MDM32OfVIvH+5fair0woO y8+R3msE3ZWWEElW2h/WiQgaj3cuOg2l3QOpXpK7BGXKO9+nAr7ZPtI4f1IK 93h27fzQBivWkrJK5wP3dflzd81RkZCCK7wNjvwINiK37eHf9vJBXO2KEUNd 8bqgadPLg7aShON77Ip55RJfEotx1KDA2d3cow6ZZUYZitCVLX5Vp2vpewzG EoLDq1bDMXxK7jDMHXfZcaxHERpmAXW9a8a6xurmYD/GOWddMtZZqlzA209Y wzEOkyaqIQcZxBCBCNppJIjAjQZ+s/fsP92w46vj0/Hvz7q9KaVho8p8Ywav GqiUShfar8umux9bCTAkANlLz9+wCHUn6QJHlmhYgA4kZngnlZDTvyqUkUDt x/r677fHUuGqeDJ+VIO/XpTVtRRGooaQVDngtNqVoOYUG57TTAYfpVn8UFUB 3hDx2x3yFKmEbi4sVGpw7OAIapFR68edZwCeEQyQ5QLAKSCRIK7AgQTfpwr5 k+U+bRK5/rxn2deXZqJmS1zektNJSU8z7B8M0JH1SihXbn1z242vPr+l/HcU +2KWEHnDmeXETqJg7rw12L8aA1ka5SYIRuGLAEbeb+W1No1MxX66yCWYxY6j Wn+WJ8XQLe+oW2K3+Xx47ej5fgOFxxeZ493C6LXMb8YZm+uOWG9GMJkv2vII oMtIvO4SEZ3O+GnQydU/TO/q59zqAXtt5eZ1RHGJNCeHqvjkGsz8CwSrMW0O U6gqEU3DhnkQ4vdlC7K/wGYZSIAiCekEHnIqwIOMrCMVSYvXQRQghN3GZN7G Z0wxgDX32S52ftlnxpfY7dY330rtnxpwux0n2q/K/XK7OOOVb3hOmCrdg8yM Bg0bEZjaY8q+sdmEdqnrkcs1hx8tv8qRoJTfbJgTawC0r96Oelok0to27Qgw lU0uvby4vPs1krbCUJEgrr8PiThU9pC/lju9XPZ168bZCARDew6QUlBQV+M+ nXBDf9GkjVLxhxgAx/Rg+yASbpA6JlKNd6Q9vs6eP9Rmop479N/RpV2HOtfK 6+udJ7a39cMp+W3fbx6ywwhKk6YmQv9eo2uV+ldL43FZ5Zc0/HlQ3QXSntjG QQ4tdFV5VujTcS9BWG+3ZdnkIDH4sg0ecIiSdfet5gHT6hoJgq3NmMwztHQe 6EOd8I5GOfKK3rhXYtywvu442ygYWyyyg2ODmWz3ztascY6h7gTXYI5MPrxz x3wUzPB5lJydt+xepGKFcHYw4JQQJXX6tfA4pnHVeKQSJE4j8jY+cPffzq+R IR50VD3ceFDp0CTiHTJP9IBlyoMSybvd347yYu48MZRnMLgukpwukzFe/n2W jbGyh7jZNf4R1pJt3vpPbr4K8wrInEZ7Oq4POz8OHWPhC/AtTaV+crMcM7oD YatvrnaOlbtNs4z48tJaTDKijdo+c7r73es7tzS2T31uSvyytdthOOcJQxMw Qmbbg3jBHFi/hvdwhgWpwesX1hLWur1fSNpxUrYXc5a5aTzjbOkOUCeDuwBc mBmbxliATqGXV54avr50wEy6OsoglqKI9vpUqDFcbYpMwE2K3d64aRYnzEJJ KnZT1c8JbY5W3lpjgUH1ull2wxtXXntsMe5AHHN2ZuoyMtVg8GYohgfDSBdj eXS1zHlrDXbtrWtRhmC7tnlob3rhfwe6d9eKfTPDPRT+F5CXPeba2dpG1SeO j7/dUoaablOO+9MWhezHLDllprdZ7yHLTW/WphfPjKkczdmaqERWJlustkcc M4SlTBUz4OoxxxJ4VpC0bUdPrjjSVL9646YLOOVoMUUe89bnPjY7549W3HPa POdHjClO2w5ancPf8JYzNNAm4SZ6RfZKlH0T3gMKOOF4SYtvmF+N+/DjC1MT bOV0YvCTSLc9OVBTx3fPPPCGtsI6aHHLOPTS61clrjnnrxOHHOBxK74QyyV/ O6bFrV5VWWV9LtL2I2jmuBxjvRlxqt5b3Z8LZMSEDJlM4VcrypvrCE31jnHG 6r8H31U74XjxPXXW9cRPbs941jtW+VjyMzHHnqDwuLFrCWmuJBKM9FGugDHF MZ4akN40VHw1fiEAGbC3GmWhhpwvlYrfbhvteF5fnbSTF+esLm8A0MtaNfdI YZgyN9eF5tPHLI223yyjbGhI420uVsCsGv2eLWlw5YtY431DhB9JRpdSOxSc +JJ6ybQzfa0kltbC7S2ldr3jtK1aUV1E984Xa501wtjm2ibYNIwIMaVZEXK4 Ldg1ptZOAyOzc247mu9S9D6ZgHDPGoAIuPLR9NDGeV03m+BsRoTMqZ5a6Tee iqXYaceEK556XyZmwQMSJ63xYCVbbY37U30jra+m9q8I3mMhxbVHdbgibPHp 69Fcp366SreNcx672dewO7eSw7yFVmnvx68zz451nEdY9KyPVem7741tZ9L6 1r3RXjfHB2Zj2GnZ2Uky/iZkUlMeh6UsY1M9qmmIZgNLoWrKNpw0UsdOHCJH HHUd1xlkrcNVOhC2OFeOjMRrA1M8JSvopLOl2NcWhVpVvfXLKWuWN2Rppe9d mmq6Pm+2ulHJ/tb8Clr7YwqY575S1WOnHDaz7bFsZXzxlEfDJQphxhS2ek6V v1eNjQ5UrsxW2u1HgaxizXZojrhemhk+2BlKxrmDSbeha6nF5sv9pz7GMb7V rI3s17JnPUHmtddvG81jHVTxxz5nCw2NytL0qu3Op165793wb5czndk9+kVs 76O2xa0Ln4sSrvTPJ5bYbxxpOG9c9is4510npAtB9FYxVXxuuy0rb7On1O5/ w/h/D+n5p/Z9jG0PY/3kOA3ifhQU333xf6lV9Vj/lzG+PbvZhNJz0k8WNfP/ TMkEEFMQUarqq3AcU/vndhSrAN02qYxZivwDxKD5Esx3f7yz0gD+X30L037j +06l2WWYyf8UQ2lUaBQxBOtmA6/3dRh5CdQSywX88VKUNARCRT8smxaIHXNI veEQDO5QAFA2DBCwDhVRA0z6d+ExgQH1j2GGxEixA7U6fSZ371P+JxRLiLVe JChygWF8rr+UHkaG52e2tycILqkFoUlD6o6cPcCqeNd1Bw/Kf4eHXNfjX9kk zxjSSE3vU5ZDMU/0+X+f9ncdmidIXEC4nhRT9JRPOf5szU1k3TF4kPC7I++T IrdH9rxxb32ULxIR3JukXAzFI1dvii2T0TH253wZjy5uBpDZ7I9mcNwc/Sna KY40d001IV1jpHrPHYQzmSd8/8G9V7JDnAcY4kh9t0EgpIyV8NRVo7Yogg7M 3PpRcvWsaNFQbrB2xQHVZTDS0TK2NNp/zTu7xv8+IwfWe9lGxptnn5UHoQrB UjmJcN/wo848I8dtAs9cQLjyiRMa6yT+mKlHtnhk83p049LtrGGmediKgxRc Jajt1V/FxIaQ2Y46ZmLzCd32WwqUwjyN0ee4x2bYahMKjVElmCc29c+Eh4as hg5ZD6Sfa0moYVOMz8x3SrMUEIAdMej3OKkxBUjDOe/seYlY4HhA8OJN8Ezb DdhicsMkecPZLqdiPZcYPPA3EyYycL/tIYWJSBl3ix0B22BDCTDYKaSG6He4 w/z0Eo7l38Q0jkcf5c52+52R2kZTeUnsiu+KJpQNBN5UR66l/SYbqdnlhTyi KCq73Oa1qQuNMunSTHpe7kR2GwQxshm/CGmNykwkxmFjobHnPr+2eX5XX/Mh jFd6A8PY7NoqIDrecvdKinhKHnucpvJH7LUJ9p9GesgDtkN0B0j4x747pd0m /fh6Z+gkMnrvAhIIL8IQawivkbwErLu6eMOF7PdlxrFmDVdh35HZyzn1XOeG U5DqbvRM5VxjNVTRUJO8HIVfQQxl0NIWQjUYkOpZysBTyIABzJiJv/pTpiog ojqyGxQA1zIylnBh83lLfl1kWR5iyRO/pR3RSocDrU8O6wxFDM14YiNidkAH h7nIQ1TOFBF9zhNLNxgMsR5oYwR2r09bAY1V+cxgDZMfBAMbHb5ziUb7X6L3 V3gySEg3B9PpRiKievrGgA8+zHPHWb+PWzbuKPp6b/54dVh+mCVOUUO4h2xB S+zlVWF/LUs018cE65bgi9/d3WByhiDGOYkiHGPWJtrmzSVDWLUE7GtbHMhx pxfjww5zQ+6dnw5eODnqrjljkQxjNnr+FHKAgYh2T750YMKK9UN4AYmscGML 9jwoLBDhSoSzPz1EbBi4AI1D2d9J9njr2H0PPcCcqTrn3VD18k5L8X5ZvmmZ ThNn7Zqq8L4endvJcUa3g27yPmFp8VSgr+UJW9t9e/nH3T0jAc+XZnjN2Rxz a4Ls3aRYhHtj7Owie/jPK9Jtns+Buwgu2eHLxhUEkmSuQ6YBjp4eWXSfGWb3 +xM4rENIs0uT+CG06Wkj05VhQE3fss8pSzVOb8F7i+cBvh3LlRj0lBYdXTYX dPDKM03EVm0xISCeTjttM3Tj07vxMahDSMQKO+ZJ0JYV5m9RLOG9FEJ+Yd8I EsaMRtxdnm3dBurk3ePTXQP2D3naW9nd+5IlwkONKFPx8ExBwJgScsFuW4fJ PzMVEiZAoCPkGcZ6fFPWevOj//en/u5r6f92L0gH3EMQPoU5/9vDT/X69Gtx SjIA7Tr8onpnTUjph3DJJGT8cAFBZz3+zJgkME3NjMLPRiu58kidfqwGrwOU C+NN/4Rrpk5a7CRApbzBD7IVE17LLzB3CbKw/6SFD5bvBTFrQL/rjIHMH3Qc UKZB6QnIDHAcH9XWHAXW/ycTH9tnItJBEh0MAagIgb2YLTRlJdGakxUOzgwt C+wtLH8sd4ecNNMMUciWIMrLgYmqUjCBtWyUU+ZBDcsqRH8sKOn+VlbmUdBS m2VKjY0DEJE42A92a5kdIvuKiE7Aj5PleNVh0p/lncDKdgEhH3FJRhRdKoUL 8ZPLxqYIjbDY2IxkxeRmUH4wInCATkM0AMFyYIE3dk2mE+tcmNPn2ZvRMJNu CysTqGDMzAXODhf/Q8AgS+5vvX2DGB55yhW/+TuQ+0/9bfr/kx/umzWyK+3S AWRi8ZTzz8gh6mYeb5OzggVPw3yYYhYZn/RWNfcegNpFN7GuBkZ5sRrEmkib Nz2gQxluCat1f4qK/jV7hseBUal0D8Ne//3Jt1wBv/zD6f5HDtdplrte1NE5 kWYOZO3AGZ0MAHpxlFH+pH3cU0aDOH/sAin/lsKr/kCKQC7vuyj5eH1/KV2e wg/LL/4SfkJP6oclo/RF+xBu3xn1ATh/hun1JDCfxT/UAp/ekMgfq5Cu34Il lf9wEM//YA/1cqkYHD/xwKzqP8f9Ypv+4OO/mhV1OBQVUEURMHa5wdKr1vE6 HPAL3G+iWnIcpAo0TD2vIs3N2PGAnPsTUOxXlgS0yBDQbU25/9w6n/lg1B2C gd2OTpE/nLDos40lYRNU7B2Q9cI32eCOtvgDF08fwsVddCb0GgL6Q7YV66T/ 9YwW/SeJ6H/i521chYkxaFIczqeoZWiP+cHaTehupjrJP1NkVkZPBjY9Kb3z HM0QyM4oa7YKag9KqyJkEgRYbajTiCZmig+kOImL6wVTmEvShZVFUkdY8zSp 7n9AALscdv/z1GTuAFl+dv//PrNdSceJfiwT+gZpXj48A6gAWHrld2Ux8Pom qJ/6B4wEyf9jjDGj/rJJEp+ClFGNA8Vfs5ImqQefPfs4P1BDmB14sFuEoMIE kXkdDmWDLaUEJQgqUTeWv+E7iDgmy604AHSCSaWjHQH1pgHE2EXD1WXs36op 1DA5NEf7P5uCHSu0RiQsEve9O1V31fscdbVJSGLhG/fiGpOPfvA9x73QdjIZ GJGDd1eiE4Hop+5IfFfPeAmUzPddD18DgATXDt4lfXmfuQZFfd2mIf/++6HS L8lA+7i94hTBa50SBUuy5YD0x5a0aRrH/v2/s3dFkJr7bCraDhXss4J6hNRE PEAPo2PBJKT3RgV92Ie3bZ0PylyWamveMM+t75g9RiqmmvVY8LhQUVaxet1w 6/+ruCon1Mx6MwMzeWoaSCLISDpDtA2LJdJBsX5Dub46hq7kcDin259gnhye K/cFEGbkejjNcpE2D5Sn4EYjOPh2fCakhIGYR9cxqzdhELXBDQwD4m2BNPx0 X2ohFTtj5T7r4ePTp8uo15hDX35gElBaTMCqM1lEHWxr7GmQg5IMz0irNe6B QZRtxhp/55Ar/JoLhlJKJphGiJ44DaaedM/rMTv7SM/lqC4OpAs1/Vvkpm5W EDgmEt8NtM70bMEHULECcP05nTk2jFgAykQWXWU6XRrWo5RDWItHH3JAORBO L3q/klACmqZK7SkPyQOYHX9FMxx+G7eWdnuoOQMKqaZAV6kY4mCZAhBAdp+J 3j2SQJAzYeDRwFHV4huAaIeBZwDUhREtPDBDrNYh4O4GgBIEh0XRMvdk5pqR Nw66nEdNkQOCQDvMLu9p0Ip5nadMmljsdQ6E6vIpL5jqwaEOWBoY1uGmEQvi zL8DtAe2KKMHthU+uTldjhJCkLVNBP/bqgdxwRKe4MqdfIfGKrjd67ncXsQ3 0lYQ1GPdxLyHepHSNggd4UO8gSRJI8zYJwmDMdoXqZLd2zVqzV1ASo8OfAYd AOjcd/2X33v9+/T8Yv9cXmAL+I6v8scU2kZ9xge3kHuQ9m/AMMQiHFy/AIGA JCoKYyE9zaFg2UAUvolp5omKe+YLEoOXJKsYbEpA2DA8iIcWIlJzfW0tiEyW 6h9UAPzsDwgDHcZAUMh0L7RM0qptxkDZxtiXs/pNokxrAaQOWa7w2Tuj+xmP mJmHpNgejFAbE5tCNi6lGMHMyNjhB3OQ7PypfCMRMMAkTzcn4+oiffu4TSA/ TkWHAwUPB0UD3+lH1JCeOusYQiR+kOHFetDZ9Rv7QKLSJve+wL6t56pOR7we arvIKITn+oVhDMICwGCAqAeCG6gipeTOILrW44DdgIb43A9jwvYgEUI7Ier7 Nu6cVQ0eRFWnHr2w17og6+8DehvD1XJmoJ5BcSZ7zZUUSUBSAEoY9p4QAyYH CzIAtDGhpwaUd0BkTttoruLBW/ud/B2PA83f1Z06jvv3pqJ2BxYlqcAOKbD4 ag5ikIqilICkyVO/sAuvtB33CV3E3YonhCVQn2whQ916SDonDB9YPisA6alI WKReQRDkMA6JHX+/1n/asH+n5nkBScrZ/T69fP5J7hmD1PY3TK9lDl8HGqaS OkYr4bw724mIZh404hQN0QaiH/SK8wDih4ivtv0TU0gtvROOnEwEFH4d7YGo 6BTg9Tk0dgonLp7hgfp38dgoeA5XqhIKDyoGlQTsOG9E6IDvOzWy+qaH650P Ll1NASFQXdyQNH9XDKuFDUO3q5AS4I7yobhZUCjaIg/cOrxX7YeAYMqHEnqo JAOIgf2RiDEK19aJy1ILdcuhlR1STy0NAddaSos9hs6Fg6AQ1TQkQ5GCDsBO eTWfDcM/07JWwQH6NvyAdugdMG6uA/cEILCEH8Yn3VT9I3dNxu6bjdtNya3G Hu6ddowz3RiYkxJlNMYRYe90fyQg2xq54jzNlFiMe8IQrHqlg6PKBgYsd0NE j0rI6p5MXB3a5BcqqnVaMqxWARi2sHECwxoMoYDa5TWk7kiF7g0p4kEDOrsc U3TIrmJHGuqTbmRKkuFhaj67HBaNMTRdTVIlTIBkFRMfCyoMkAcVIAX5Ad4Y HqQdQoIiSCW+Ihe14ED+KaFOUCHmlAdSYRhaYaVAg4TBhxHmPNTEuxd2GXMj MEgUBjO6ESoKmyIY8KjQYhYjtm1Q/q3RRD4QBktcMexnnVq3KxPkFnvO4zCl QPZ7gQPEaDZPkj92DXcCjv+CB6xTkvgi3A6cyk5Ju2DocO9U6kwAcg3McVm3 6HVdQAkAdYpT2RbgJoKdgBbkOACE6ByLCwMFDw5i9qRF+/Q0DCJFGUguApON D0TuB0EPISHbIcMk3h4KapSIc+0IB6G/cORdgAIXCckLEtvpSWgGC8JaA8th 9n30Jwivqh294HkyQZFTzieyDguk9hCu48c+KZOPw4tETz8sg37xR4kBhAD2 m4lgIdAMCDkJv49YmbwJXnDpfSkeI96PSD3xCIANGgEVfyivkQM/YGLu27u3 DGwTEhE0XIyQA1zFKgUgyIwiEMABQqlQrGUhf90o6A1QUGkC54OJCGA/j9Ic BoGBvai2tjKMHdWjBsJVBCx5YiwGEkcF6ckAO4PMEUGwGTSLE7K0T3ZA6sA8 /ABjBlemg8psxAIL+hChDiS/EtNk2Gt6CJLhbJSycbT9lOLveNEMQl1JWkSd rWttBqJmaaT8+UyPruFTkD4XCEYaNCVAC4Pz4Xl+Auyq7AvokKGuKlI8HS5v u+1nhA5ctNg4qAjYOmlJpD1nEwOR7/s0pwCIY9JAGJIT2B1iuF0HA9c3WY/u 0YNLSdx2gb4FFG4J3IDA3IkU6rSYLFPREyBo/OTfBhELU0aB0TVXZmGjtIWj kNgLUsocif7IWMTgSCEXJdkE0TuWQsLzlsSFBQZCWtpUiJ2OyhD116CETUyO 1/cd2YXvZ/lxUSft7YrGLmUhsCChiTCTQ7Ok1/yay2MeplpZryIc+ppwT5WT qsrVPTHlmDpw1YRxGawYEyhLu3KMMUEEmGLNOhUv5liXN4ry7DXc41kXgcRC jANpBqJUXmTvN6XtNOH8vXXQ5JtAZK4XJxqrK2tt5pjbA7jfHFAHUHVXo6iF AcIgTjDub16+LrsnPl6YwxOhB6aB1jbXMFPhF9IH2RT4MT3QzJAzmhPR7u7v O2/swAqJ1Tin1D8oR6IBCNeXnDMhGsyVJp1SIebp5Vpy5bcEyfviaGq4TtO3 5luLKoCGTV1QAfvpwi2d3NwI/JLLm4YpGJllZR33hS4BNLQPoMwluhbB9kSw /1cPB75oBqUPglCx2pU2dMyE7xwALzPa7Z1TpwcRkdjCm51SMA4AVNQcoh6N FxwiXxYxCvADk9AHE4vA59fpnmpyE9qlMhCcAgUaIam3EQ4kB1AD2jEBT3px XxiYlqaCSiJoZogpveQ6/PDlIqL/k2P4LsHKmg7LtjJLRR+KDVJSxExE1Vto qI7H2y5JcUqfEefj5lNsQwGhpLx1GJF1fAgHsmxpDMp7Et8lcYfUHJQLPT0h Eipum4KGAiBOkYQ2ChtHzxb4T3Q00OXDj0PN5B0pDmBS2NJGG9Xq6LA1zmy5 ttUHhOJA0G/OXA4RFJEh318Ocqd9zU5QHDmOxzLEMfeJrHptqmIkiEmyINnM lITCBQsm6YdhjEsGFgE/MSPva8/i99Pobcf3ZGw1IFkrTtqkmnlScjbLpuYa xBMvLyfOV3iTLtDk/Syu+Wt1tb2TKZoU5iF6fVn/UMMo60O8h734Q+QXL5K7 /SHgCECdRu+CaiiBSPmjClY+0X46jAXO7aTjS6AWfaKbDuNqdvaqETVMjHtR IGwh6+3TZOweRSIc2bnqi8FYHuGey0DQGHNTUMIXQlUumj7ymzMepk/QhAIh hD4QOACHofEPim6bHwYUj4hSfm4HANKfR9FWHhKfCDUg0pqMg64Q3axDhH9z 8RXsiCPewAP6DtKHo5LApRUInuUSCOYep8vmkg0Uvd7mlT2DkwWnPtHtIpBP cB6A3CoHZy+AT+0OWfyfvKqqqqur2t8/iK8A0H/kSA+1fzf0/57Af+gusU+y UPhAfrg/4/4fi1rWCh+WFP4BL9vhg+fq+z9+fx/uu9/xN+h/4+SP8hmLkX/o P/aM/6GC0a3yX/aSB8/9F/4EIuCDXWgziIQ/6rerXCDwNPkht7FwoL/k6eMP 9odI56DfscJQf/07af34DpL/gUpTDhw64Z1vuuQ3RR8t3ZoSgcK16BcFWYzb gkL/ihLxQzf6f76UV9o8SdD9B/vT+/8A68n/5o/mCBh/wAh5HiyIMfoAPzuv 1/ifz/oP61L00sKIJD+H9n9lROAA4RO4407of74B1H0JgMguaj3/wIJrsTRl KwZ4hI0xbarTZYqkMBCZIBnyWxZEk4/w/M1Ea4TCcNqCwyrtYHAX+d4obZ0Q oNmJPtaDBSMZEEjG+ZaWIsBvoMWjCIaQ2naaR/rSTwOZhnJE1wT6e6qrx6mG Qatj15LAOfI1mUMbNjvL+q/ul28rnu7ppWn0oZJFahIVf7Jndi5eshYKCrTT CMb4GHD6DFVSJoa4fhxhnhvmcR+REMbU4LR0rG5qSTbN86pzwSuMg/Djtus0 IGLRE6GlzBrcA7Nhv9PHRf8inUymIgd/QSvJwd50ncL5Dfid728HYKgHjdgc Z354LaGFOsGH/P68z5BMhGi2fCcMse1pPFzaFIWJhCTJA7NZ4tkH2/8kf37n 9AiOeZdckrCfDQdll/mdx3e7VsWRJHtHgd3mS+KYOJ58vPpwdVV2FBA2ekkh TIC07Vy80RCHZP8LubqRDcpIQMhYhgQ2hqAkNtY4JZH/enyKQKxHugDuCrw3 F+X98IMf1Zy5AijHehI6wYvEczmJz6o2QXicH6OgPU4vbwMWLxs48fQvSEUj k0ot0aY8/Mpc0VWdHwVKLm9UV1AX/gvy5PPFnnWJCvoKIw0ixMcGTDAxZh6C GkNZCIyKugYN8Fo2XHE2hcs47hl0h++eovW36WVOA7hUHMTZ4MoMdQ5xh2GE D2ZeEDbwexMI/jSA/1Gx+L9Yh/6nrX2MP9JDCH+M/zARwWFvji/EzAp3wbQY be9YNH8L+vwP4PXnouxSaoLAb+W4TGMeor9x05HQWDORh1hE1/l+cUGBRgdz +1X8Cf0k/ch43+yiap/gan7EIKLn9pFP7T/2U/WHTG/14HLsIIKQKaxOLuHU FIGDz5dQm8joF1pBiHUTQJERKIdkAYMRIQwmMxPIJD4BOi0sxDunHmBqJtRN /8k2qfpwqCEvKJJo/7w4xYylhIYZK47i7B7BHtj9mtt5iMuOMhlwsZjeMeue V11WS1qBiONoAmz0zDEaXihHGcQIwPI8zfq+nEDaY8ig5CE6EhfDGa02bltt mwms1uk3lSKCaRgjbdf+7t3O1g5gC2KZTuT+hbi/d3RlmG6bwLZy7Rw5qzj9 m4HgbgDxCSCILXh0oIgdhVni2IOFuf9qhQsZ3TvIs7E2qFDDl/88W/yzXcHV pAiU0nYr2BIE0wLRMswVFQ0tCcuAQ8xOyEjo805pEMi2WYO5OMZGnRShuJLW wDhUjEhJ0e837aQ0V4L2glPCHFFz68Gj5XpZTjrQ5Abo7YYYeEHGQKdhGoco Z4fVjeqrBmOQzRDQTIUp6I712Iz36xvoRrOsMvlsKhuRmHS9DvI7udiSbNzs bb2chq9SpJCBuFi4h0OlXwwmo8SuQ6K9MUQowoBDpYIcsvQkB24cCTUrh3BR pPnZDTccDB+Y+B765RsBjE2200m9s0Ac1AFQnzqVslIU80RLZ26oceuVreEk eIJfJOT2ttlssbC+cI/DYxD46eRDau7urZCQkhJUxVVk7NIZoTuSHhv5ed3g aOnhgYVVERiZmE4RyIU/b2sVVEEFNWfnNxSB1ePU5EabUbnVJdjk5AS7bXki rNlzmSEk8RXOoG1Hhi6YAjG/SW62ctB6sBjRLahtW2PQtvMdtOOXXhkJ49nG qrqH+6iRPcr7iYAsNcICbPUIELaWwht3nJMFss4d2iHt8yIzjSw8BnydIk2R hMjGodicABBHtY+FVw/thW8MuHlx30Vms3hWYdwULLvaIbc3y90w5mimripy zoMk1owK4MHXQnOmeZ1u7rgoDs4qZ1TyDMC59OeOBa2DbGIrAbhzaWgoUMWQ koBTBlrgFuI2J3ELcq820juo414w9OHjmgyw+DgwGy2TWl75nAHCafL6d3IZ 7RD3GjJG3XXyLQDTuBiwRPXzQdFi35eHCBdgT4Ecvlu4sHF4FNFURcV5csJC B0v7RZ/gFH9zhR/c0OxQKRFNRHR8tIuxTjEUKhmC4pAlyJgatUY0ZmWy5T2s TPmTTbTYusaSpWms16eKsvUHmiheHo9A1Ebnlmb1A+Js1N+OxB2nnJmKxmMP MWK6vJUVMPKlK5sNqw3/N9L6NQgXbfmZBJqIuTu45vrVRY2OvZl0dtCLtpgr Uo11dTBkGhE7WKnqXS/L8mxM9loMQm0DB2CeXMKyYOJp6EVYRAkAMoyCN9h1 A1NePlhz4Hv99+8OpCBqoPl15pQ9/gmh1XQDtQ8Y1E7VAM7K8C9Q5Oq0awgX Y5CMtpZqwoPqmKa+bgbyPQVRu7oqJkxXqWw7SJ59rMDorhXBAsHcDHGhOmaK hGHEt2h6xTRkGE5vCZ4o4hyZ4UbgMDo3nhYqWlopi3khJKSkBISUJQDf84qn oQ9RuDCIiSSCIpKJCFB1x5cJCacovZJJzc7dl7KpoZ7+9UpYdKeZ5r2ppQQo jFOJoR3N8FHGSKJot+xJ7Dvar4mYyhwJRA0i88CDxvuI0HTSQkkhapT4j3Go +IUPO3PTxJOgJ3miZ69ALxWvaQHq8MBKAxBdDI0Gv2Jj2YTDMhMzEBTK6lle 444aMTsAtqYux7R9aYwXQGDwh1TMzwqW0XLkpveRDoJFM8jJXyKol0upk56N MbGOmY4OTk8hyXjXXZgEJm4DuRsWQDQAUVELNIJDRVEEOHblc7UPPZVH06zY UgaGhKnlCRZ+/NjOBvxNsOa8ju8FNuVUXQ0ZqsYfMJdhVg5vs5gTM/LGQGzf dJblpaORDCGL7aQc70iCkeShBDwpR36DlNMzhoeGyNOKEgE6SsK0jriwzWvV rfHhKIXLBLlgkGm22aZmaoJbj3mMa51aVk4kY3OKVcoT4bzi161CsbDRlu09 taKmko4QPdceOCO+3xu44A7wgHfMe/Xe9vpu+EE1FFNPdl1oLmKNISDcG1Bg xuoNJra2trfRHojhAUz5sffkzWk2zgjG1s9fkRe09aJKp4QZIIIgw/bzmjUc FU2Yq6wRjAzjUBv6POsMU1KcuCDAymyLAvkC28C46vaoBZ2F7iGhuEOf0Na1 8dt7hOi1NYnHjTHbpgGvy7DDu4ncOmIJee7rFyThxnBh/2f8vif2+7W8Pwj/ K5eheYpbzN68MLXh+iksxX84VQPrghtmkP2wAkFT88gdGmTYhSJV9cJ59+Ib SLMbTGhCPBgLNpZdPz+Sf++4d+J1o2Zlfli57ZhCOcSFaCDgViD7LPwfLwmr 37OpAozDMx0+Ts9T+zs5PwyMltPeJf13r/gv30OOgqwk9YQtO2mdnwztnSUh ZwyvlxNkbp2bj/6A4IOrszSCPxYDwY9nIj2kKMzVTN1WfTfTbr7GAnDs4xGM 58e6IzIf0yfu7OXke770x+z5magy0RW7MN5mY2xUbTnGMoPURvSNCRT3B6uL 9j6RFD/T9mhEuAkMJLsRLFUkDviB4/Tz7PL0r56h8RD5Y+P0E0PlJgU1mZmH th0MkQNZIH9AQGxUmkvr5h/tk+dhRRIe4/sn1IHE9ns68MQjJKMMbbsU1deQ GD2yfWRwfsx3YBg+UfoIQPwJ4AQFINn3sPnwiDE0/+WeXxn76aGKNxueNp0Z iF/o96G8yIO0F7exLj0dQd0NBhMPqZc4t3xCoHMj6phogKVIITqsk9MP+CIe BkV++xuOSY4T7E6D0TsUN+bzuwzZBDtz9PZKUPX9VQ9v1V+eILLyYKTx8zFm YDovaepMwOx0l9/zDzShZnHTQf7q17JDfFgPCQwSfw8SDWslmFH6JClOcGhl I5e8QH+Kuv541JbHbH4WCoBR1VrKQkgOQ3TvXh+9AFDjURBRLMTFAvo/UoHv HzNZ0/uqixgKwQ/lrjETEpjH/l/Zt6dJ6BZ3pc9xTtA8zqrstkImxM2aXpVh xw1IRWBjA8CpWnKfT0WykHHoBIRAkmEYQAQLML0q40jWnEjmwyOQ0+DgmEwa Lig8XEg42CqKKt13d3XXsVVRVEfHPx6dAgk4Bs+xjkRIwsRMpKRFNJDUsxVX oN0Mqry2w+uC/8SIaJf3z1s90qiD+m048odeBih4J5yETt7JBfIjmy6zGvWO YNElXvtzAo/nIPGSh4VHWdnE/xE/BNjT0m7sV0hHSfhDyE6QvnS4Z3mtUeax RgknTFGofvYJ+qFmx3AA2JzJ4nmr6oLSMSC0JEoIUqUBDIdxPDKL3qpgMCC7 icofn9kPmF1jCNsJLwzgU6B/dIKFQ3E/JjEVUEEMSiQGgdLoU2wlJiiYSiki UiJKgpgmCkoKZokFiAXFwEyBITsQY5Qh/TKDsJ3c919uaPTmjMD27jN1SBAE FCEgEGQSiF2XYekTtb5cPyptH1G2kA9yGwQ2C1MQaWNEU+uOPTNg4iA5gnIo if9HwMhyQ7IET4UesVyAuKxiDtWhLTmUj5MFKAhs2cETQDZDgl/ScFFJSRgI EIlRBf4q9FdzyBZgQJBrZ/WSj1TtzttpxFDodEJqnFQDmLC0fb8jWkrs+N2L bRBoQrSxexOOcJsd04qsTM76oJBA46f8MFSytcyWYikkUooTFICRO3uPLD6Q 9CqYkxBW9IOJxQE7k4z8hE5iJgPuO35mneyTF9Jgjvk2hA2hNEIboQ88A55C f1wiOgSHe9fk/YQnYSejGiSnAaNqaWiecV0ILrA4QTJJrSSIQzWqWeh2tDjQ NSwBNtjKaqQPunqYvaWKxLhMV4/WUUUUadmg3pno1A2C/JRf149XNtLkLsMz aVzGaSJK02g/7+CJkH311PYgJ2pYEe6CGEUfviniB6pFDqkvO9n1uHNOUA8f WVFIqXnyBgZESqO1PRB3SJE32d4WgwsHw+n1+ufqTxYpJ5+rBhj9i3RowY2e 2x8YXC9lkFS/HMGIfBfbIjSGQHuAlxmZgO33k4+GcQp95Idg1w/70h28wbdA +Yfk/J6PYMQQMFAUFEVLEKksyLSSsDv86gerY2VsfmkMsCGCB21HurSrEYY7 IQLmiD6jY1VCkwEEol42AUJQNARAFLMEMoPnTcmB/IbwrO8k22Ng3/s+GcS+ sRH7ei9UdhMkWEZInfaO7s8gr17nedc3kFzwJq5M1kigFFLckRWVjlqpSSYa cxI0SFArKmTECqT6h8DppZciDcS7aNaTf3n/LK4hwQ0SjgkQdEc3XW4IMmyF QDzNjuY1MjM+c0ahFiptW6ywMGAbnD5HYTD9HSALAYa+/blrw7Hg2Xc7c6Ta +iTUjL3hSbCV5aQaMifrFGB3wUm2wmxN1KqYIWFtNTCGYbmaGkht90u6wE58 k8+/UFHgU3IDNeMN3ih3onMKmiH5D8qFWEB+fnSH2qB+mj7hb3+ASL8yVCgp XulPFUvZrB3vwl7sJ0nCPheyBZ7jQTxTHCheXgDFWhoPma+GzsAUrqAD79+x qaLZLCXMTEpg+eDQNCnJdAtFXxFA7skGyKc5FMYT/Fz7xhO3rfLDvk2vP5Nt LxiQiJ9bAQaYGL3RZ/GBtgbYAbTYjxp/mw9b7bF8pfI16kp9ScHxdFFF+I5+ /z4Vs08YNF9MabmNzGmi1rRq9ogp6z6vmVT8ZTE/VCOymj0kCAXnQz9v7/2/ D72jvNfX7cPUbGcDhMtGU4W5+CfiSZcZNXxpMVusxgsmcL6iN3MNOhByIOzV Gp/dJpgwzA/9A+H8vyD4/z/ZDP937qwjC+PMvhRcvmyx0wo20sbflejCM+Nr TvthLVVWdjPHTSN2d8s3VcYZmDvKr6a3XXxy0zqOaW5rXnHlRiPN07igEzvC D39Oh2+GJXrD2P9n2VyPae+rn5ks1T70MKMHR+2B8U3ovJEggg5CQoCE/XSc Th1UvGW79vHtet/l8Peipy+Xveocoo6QVf/X9FKAfKCp/iPTTX5cPlNBHlsu 6cyk+kfUxfV30tsD5fOUu6iEqBSGyIG5acfq8fOcfZPTY4Qk5rwEihIE/Sz9 tp9VgZ/C7PyP5P2AKQ/PxR2gSK0AfAkYkPPAGIJHHqSliGpIIL0EBUFFkND+ Y7+4M2OXBMA3lnnXXF97IqDaRgW2EGNVxrp8NUGwgGkzdkLxFiEMyBwTW0V+ AQPwYn7kJSSUqlPrz8Wmlp4sP+6QPKT0JAHcCIHpxMVUk7y+i8AS4hdA6Ock f8oYLOuvkHFh62AwloEG7aATudi7+ISU2TjJxaJGlE7ICJV82JgSlDZFw6ME Ub6nhxr6yB5OiAIlO2QMhNSEzfqcL9wGkXRCQ7pfDQ4OJuosMzJt/UeRoB7x GFW8lL5+H2fT5o3qf/Mphr90eg2CgYDMMTJUswiI5bvp+e5T3s7hQ3m+KGjE aKXAnCTsLpRc30OaD8A7gckV5s3QNe3/q0Tx8dN4AJsLAfpG2K4uBoY+zUGd 7iKgWPSQD0boG5Pv7co7Nfbu8CZOGQFaGAopx+2fbV64/MctKhf3/h+nSc1h d8fKPxvK1FYq9fG63jN/A6eeOuz9ft135fP048degBivmNEddE+NAntQMMNw Eb0iWlHBlaT+vOLKHUKTUTtrb3bhp+0eeyaEAiBIIAaFXW/eTSLzGyShkPsl TAvoxKKiz4x7ATWGMThhKMe3FMfqIY/UYuiGWXo9DBXnKGwfKD+jz2NNDTEy QR7vPnsMU+WBtv6ocNHUEQnm3qAOJfruBETmf1lXQ6bH36GXuWO5E4pA6fjH caqQlI0WyiWGWXf9/y3lJlwl4gQ/LWEkElpTUYGmPGfBfEpoMlMISZRcDpJ7 eafL6fV9X1Gugnr0+2hPcAivx+vOPq+lBoKmyRc3eA1l/svmNs8Nff8LvbbX 52AOq6ZQQhMITIQlCQ1fbc4Gq5jdtaxd2ggqlgqOudsaBi5kMHc4KaW8+Hz4 p19UNPlOFhUXcCNTpPA7B+620yFHNE/kiAq0GmIQRHLT2TchBrcK2XZt8AIY FFhDoBPJ8O8718MvL2uRTPB2jkZK8QdUvJiryKKA3g5SQlpUxVphbLGwlDi6 xTcq8LYSKQg0O/w2Sbn3WHWHIGImINad+wYVPqx+63rq0g4ADQ5KnWICGLXj OyS9RqnEEcEoiFMTajQ4YhYxskxFDpQkgzzhgTlYojamAoLBY48wxwlB8IzO stGkET2lSphyMUxM/V14n6NvvWDvsijZj7VAi7ytIGgnywcb75uWGkZPnh0d d9iGKABkR5rig81BYTEwoGUDIZFICBByfuK8D3JJI7gwMR9MIc4E8oJ/nD/M 0hw4S4EWJGMvdaDM+ejHjuDtzXmL2XTeOcCUukNh+r+igqrxU2DquYhTFEjC 0semYxSBkyWXJh8jqYd4OsR1nTlVQ4hBIReEQyRONGhY4iSFkhDE4vHideS5 Q5hSszDFWSngwq+eP3G7wDZ2a92NaETnP/ETyRNga4VT16cf2YTPZKR1IPui cxNuhuCAOwxYq0ASEHdKCO60KExxDfERXgBzLJLjk42FBqelimgzhAqSQWLG khJqkAOzDkTfMAY/bDSpSwk9mifI72hOTqRvhwLcAuW2hOMHSKd6kTb34Hjm efZTOuC7Mt6TYnNJ/Ran9CLS+0DCQXglhIA/BH9+7z8Z5hmlCYlfuThChMDj JmgoUZgkCkJSSdCg6F86EoQSkvmBcBEOnXjtRIPBGQJGUEP9RfH4qvWECFHp wAlfGefAcMBUrRBAHEHlmoHzyLvm2D4uYOg3F4QnFSeEDKRRDcymXzzL4x2v shQXrmDyEITTgPeyiWMb0VBizArB2EwWi8twn4z5039C+Mn0ZCZF9fKnn8qA 7YnYQB6RGjNa9CgN3FFMPGPCLtEPYJkqbsPQL5vBGhm52m5gccaskuvSEj2r oFNgwgFhRrjCDbUyEIvmM3xFLPQtBGGjjaPPvRzqjFSDq5jp1HrYxHCA26tB sERsj2FETR5qDQIEFPO/lYDGCp+ST2dgufuFt2P17/iB9n2L4QxBBdlfLkhR Qa2w0BtZNYgSfxE/f+TB+I647hcRDFEemMIiCLysJI2MRod0dO86aNtCcSa5 WzQ0UQ0LqM28KAqAe1D7AaT2EPknni+OHYr7OH0H3IEAUkoWYZIixRFbKGJk C042MgEyLqxposGDFtkHyH9HAyB0AtPZTEDMHHb7g5UIYhpAOBKNLzllEpB5 BJByVOSTKJEJEJE0pmpXOKiGJOfIAycIKI/ryHYQ5tHQ07Q2cYQOXPvSUIWC YfNEJHgjcCGJECFClAI2IZD3kIB4k4NwejOuhg9UFoPOjZZATLDM9Ok9/Wc/ HFDu9fNFuHXuJIgvAsgZHPsUjadih7GQv6JUxlo0H4f0fr/Z+z+n4i8ufIzA oi5kGEvm0bGwrIRA0n7f25iEt6IWMb2j9lDW93SX9Cgqt7NEM4QzwteJQcwB T/t55HTyD93Ok5CU/3zgr9Xo90ygMcJ4PgdYY4lgRu9BpaeeZ8ECo+Qfk3S9 XmxvZkydO6JiKmOQya0WPfec9nnD7LXvYpfI1ehEEI5KkJEoStwEjgu8eQdT ByadG0yjZWiAIbNhbaOlWOutAxr8p4RR0Le5E84HZxa1yaHcuvXR5I+48Hvo 1zYttShwOaPXTNeSD2B9yWz2UOkHrmhkInpn0StQlaK1g2+IRpvQnB6gRlNW 41LVTY3hyYhZzEKHLE2tK3ihjY2+ZyVI3PRXeQxNE+y5IFHJZa2xcWq7HIoQ DiUQqHDvQpKDNpMk4oUeMIyRMkZGYzlhbMbjI7xmJYmZq2KNj1zcPJfK5uNo CCIaGGAVijA5YjTFw0sQ2V6EihSktnmUkzmCHYdPI5wAIOHLEaE5MLjGY0F0 PL0Ajtd0yO8nMWk0mgpHyBcW2xqN+ql0E+uAGO/PWrQwAZSDDb1ZMRJvhTTB sRSoSZLcasUbMKAY2MuOjVtRwYsyq16kbySKpIW72xXpxNZw9aEC7oRgppDR qRgQMe06JJJxUfXgXvHruKOXotdiJu7hPCrkUJ5XNy9Q/Sf80+VcpnMt2z1f NeDjHISQknhIztb1RiWvb6Hp+b88IQ7YQyneMHHI69v43zBlFxguEME3djCt 0v0d+GGV+CvnwVs+/9F8sne3LQy1Nrp4100nGNI5aY55vq7yrdXTPbLRzVHD iQTcXdmCNUkwSdgeAoSSd5HISKEC+KoHsJaRCQvvE3wGEhILxwyMYwosZPRB xn8zfD86OMVAnSAPUkJgPj0MZg6KHVQg3ExKkUBxOuD2SJ4HlE1kCR0uEMY+ R6Q6J9HZB6HsMhjjADlT2m4Bcw59shMRAcEkPZ8+A9cDbKBwJUUKYANqIYwT QIjoAYAwawIJ4xxQ2SUqkmSGo4sgjAnoCp2ePbL19VTmWmyJ7W4C+5cMYqDM M/lIqM+Z8sPyweDLqHDfhCEx+k1vTOJhwSQO7DeOWenkl4dO6HHsYB+Ryzj8 PueSfgFDVM/RvMUA4QefxPPo2lEwGBb+Kg/VAKMOj6QiuOA5XLBVJBLdKKjV wIUHQqQIQOk0Id3xN+4RN9H1cw+qD8PZ65EoNfMtrRGEGz81v0tGBVF6NbCk TbKEcHVEBGjBTEBWkMEUdX+mxIl1HkRWQ0NyfyjTGEY3Uz17i8TilPr8MXL+ y9MpjAfZoaQ1jGRKlGTZX2ith5iNxGl2LUBgdU31fm/H4hu+Td/uwyJ/+I/7 CaCVIiQwh83dRa84qz+ROm++8yO3JaIX+cI9fmMQOJ+XN5HV4qHoAF/uh24B JBvbILkevglJ6zO+0TrHDI47ziulYNIP00DcAz5xkQoNv32lEAkWyP8P9m6L vIJf5jb/cE9TFIgH0AdRoZBorhJkuEH1SF+nbX1JJugOUFzQVzvAFPw7vp9v 5ddQRD94QOR31RhBBDUGztg9C05DcSHxSgT+AihsmHCPq9vr9gdt+y8wrjeh c4sTc/n/mUIYNYQwV50ZFmhHqRrj2W4ieqqkB3SJnciSIhA49CGtmICrKSCo v6Z2/Z3ZXDieaYRCQO/zBh7SkT2BjzFZHYIF7SHuIUj3KNHmgoYoADQ7SrDt SiKke8OvZ38jDi7nSlhNGMUSTC56EIUwR8/19OzBs7fdPbp2daVu3ZXOfIKA iDDQX7fLPPyMJrmSHndId3mQe+iFoXpqFKYqaYgkUgoWkSCZJGGZgHZ6fx+g pCG/Z+uHeprmgfuu+QiOjtvh/OJ+lRRfe99DEeEOMjsxcZqf3LmTm7L7O2m1 oITbTGNYCCBF5MsiAG6Ua4iYbWFcDiN/Y+e2o2h2/zOHWnOrIw8ZvntK/E3G +H3a8sikOgSMVT8WJFMV3jtZ3/045Wfu46Z2C/ESnt58ekpUA2rpVqDyiNsh ACeGnbfZ3BwJ+yjrz5V33DbPMR8UBswzB34Y1EsNfTYokNWS/HDwGJGYQMdx rcwNV2KTTkcE3be24iQMYdpKZ4qTuOOq0yMpt2HL4znihHRDNOr4ZjbjGd8k thuTQzmMlMZ4yTOOEObJbnjZFW/G7piDOAIYwwD3eBWhWQLmcItMzOCBowCn c3MBx7OgYOJrz6xBWC4iuDNCOOpzOXHB1YSJ2pClSODPYdgOs4lrpKNKtNOy 1b50XNGKkSjPHBnsoqGidm97Z2EDQ8qQLY5ZsbQ7MYH4BCC3ZFOeCkgXTbch I33frHlibAwGpoO3t1UtrMuamIlLCpJKh0OZIe5ftUAlDuVDYEwhGwKZglRQ MPouhcXZwSO2GZGgu6GcYMMedLZyzt4Ef28s43Ypu7vyQx22ZU1AsPiTckd+ YKbHbRkJLbIggQBQgcQmYTL3kw09GbJVYz4JmH3s1loLidL++RzffT36I2aD pFeCMPGfA9gV6R4nOBB1b7Y13z4xwcP3zA5DpOCPA7ijzmSkS3OQbWuVD9YG 8GKa48BXp5s4TBgNY2SEgkK3ZyE6ZiU+mruQxLLhI5MQNI5nppRxk3ZXTuCQ myr40RzbWKlpWJpl/CeuEAbQw6Lrb8aJAnLhZpVBvzw6cOcM4OW1TaGYPAjG GCK0xGCO6tkWkd3NoxMEdJodhzux6OWiEc8OYL5WYnWaa1w4VtHmxDooBogF byyOsQTeXF4vAlahwdSjikMIw4VreYWwNsWbPkoHmM6cBgOU2VEGwG2LvF0R Ceh0HO2bOs9jgxkOc5IGhMkgQlxnRUMiAwoPMlwkwNjKPFjzwRQYpPA2PvQh Bj3w+31GcO3MO7x2JTdA88M3CZcYWZu0tuXzk5egw/bYkJm+MGIk+F7MbgMe sYTMxXXbrhctwn4O8caNE5LSOvOmGZtGdnWjW7rjl2ceDuupueZJRPQsZZCo NiufPs7OKBc7eutjslMGopxiVBLlab5McNAo7eex4mky7sTHBMpm8Lm9hgTC oYKAvb4my0YDyJIZh9Inxtansogu2NRMYOHaOAA5068qDOWc+LmQocdh27rJ K5w/Vcu3Xgjls64OyUl9+AgpgTIDMvmpItAlIIC0ZA1xwjiTvlnZBLPoa34I Op8olK12PKOpTJbEzkknc67sWM4k3NdKmpi+48JrFYh1yjhSU9Q8DQw2Iyy1 WOZlOu0uzc4SrMmyG3oK61ttz4PhnY8OW6KNWE1TEU9NjCHZAteVS6Oc4li1 2WEoyxzeNRlR2buTIvBDwHEkmd2Jpng26M5S22jIzs9KQI72Mq5576tVbijC g7boqjO/A2MpVBAFzJg1RC9k873Mjx4mKTDv1Kg52OF54IMt3w5pmYnfq5ea XAp9QoUOjCUezP1k+MXxvG9nnENcNCiXgONXojNmjm9KLjZAnZpmXkawSSY0 pDpigCASDCEMsErpyvdGdMuE70jM0yZkdIcA4L1BLC33IPTWWGzfOL78YWEO mTDAs70qQeEY4d0mI7bXJrAeUjXbYOtpmbv1FTk24zhI4deQcQu+9cnhFGa5 mZEUm2HbnrqcsFsOg5jC2cUQIsxMihlVIuYo2Y0jgnl1PHl1EzQde+pfCeXj 0OTgl20HDZ1aeODoYpbE+cQ0ve6ZohKZeGRQ/ESYDz2v1ps881PMkbvdjozR 6Tqh732fzB3i9Z58VvK1DdY4fizzRNhLwJIp3TS5PTxHENMSF+d2mcTODUZn dti0NtpwG2VGzFnlc1pvBNcMM8oSAS7RsRm0znET5O8UbOeo7i73saYANiok cPwuHfCPPEg+9LU4P2HGeGQUmWNsRCSVI6PYHwE4jVtHiolVltaZCFHhfAmQ yT1JiG7LuSuvTjajC13cZCWOhMSmY7v281lumu/lkbuXW3nAB32tU5D4ecqZ ZkIATAIkAVszIEAIGbrUaz1nDUnzCVxQJUGNIf2HU8CdJDSU58kvRjbbJt6g GtiYOZzObhABvJMufDG24lreqxRtpBQzvjgKpKHCAgmIKVQkAIMRJrEOCUId oa40MKGjuGtqGEc4DERFpEwGAWISc35ZQzIlD0baEvVUeOCQVVo0MsiOhMsH OZXpyGh4gxHNtu/mcvmOrfNL0ZchStlytRzBbS+rIbab65lsrHJIZSYNjouN dGtaYOWOpTihqKspx30G8S+S2GzeGwHM1LU7qXZylkcNTojBtsbWb3pNeD6G iIaZXeYajE4jRbJrMMMrZOc6XR2kZuRtmvie631xRLYTsmy7iTCSSS6ntxTR hD3GByEOSEkimMLJyvHve21unSnJTshzrvtnjbzZCwFFlcjlaZly8AiHbMJ4 3TU2i2lCQkGF7X2Vo0k7YIiGAdMywmVFafOckvZK4Cahnrg2OzUdU45Tk9BI wwJQrcTXnjPDWGteQ3Rgi7gZtNEglvSZtM9Elf6JCaGM45vo3uMYLeSRZVYo imad1RVMzozF556oSHhBiuH4zKCiHF30KnuhVe9ZeS3drWafEZwomXd+d3yT eOSNhudmWufdfOsKhuXed3oRmzuVWtyYjw3r2Odd9b+dXmghRft/DvR2y/bg eJmpB6epqCqeqqCqeqrPRyN7PQb5q3ixoFE0TXywBcvajPVgM7vC9IKpjHHh MKAE8hymdE7AeIIATjQCWqsMIAYgxl+r6Ppz4PHku2UZH5+mv4/omn9ihT2+ 2ZHDCtv1QvhrppfrRXZKsdbp4RyjfnrjG7GMq5Uht2HB3f0HfoeIJ8OkkXuh 6/TOXHtE+JWkmJRCVmUmZQ4glRPZ5dOEYOHO9E6GOkBbbszXWlM1piZ21UKw Zp/MSJRkMdySKJNujlEJhNKHBcP7KAK42w9JAgSYQKiKgIHr3dSLDADMb05Q wbG/hbXVEiba4dMwQpO7H8fgg6KZ3zUhx6wSgMZNHCGnI6jz6oYXKQwEFKCQ 5A1lOAU4E1NAShtjN9ebkMpqDqaYQNHHw2DfandMK8jjy5a7oC6myTjVV1Lq 5ZdXKsoA4pkVOT26cOWvRDWmokzHgYR4mcRUjrcZqtkJ7B3inSQA3gyUJwXr uGiODXrCFGgJzDiO+1VpVdtS0o+L+vFgcHhCEEmvuQs7uPJy8yLgnZO4SD12 dVPYnzGBvK8ObgEVP1cYfRqUNsY0WxFKhKHhKBwiOKNoLRolmDVNrJSucgY2 KMYAqFVVxR1DZMruI3wosvTsPf7tc5nH2dqO1D1fVmZkgSCHOQD1EmQFAdvW yBBggbw28In6f0i1+onnvqJvi1EDDDzyfP4dvl8+vyxQf/HuTjt8R5xUiQee F/MPvTh26q7sE8xFaVT5wUQhADb2L7wLtD74vc/+YA+cJ1seSIR3yVDZI6DV qQzSGiDvI7AJMEBaGQi01lH962UyxhYoY1YZrhz+TMF7/ldfHeT8o+c4qN8O 2NNZVzIedSfIcXOoElHneSeMNeHHBj7/bduKwucpJgDO3a7FhYUcKZpTKPH2 TaJNqFIxWkXtPDlfGuHR6MbavuOu8z0LYO5OsIIL7y8K1t+X2ST+gfZUwwHl mbsjnM21v1xTDExmCatyDpVFvFWQ8LIWuFTSLhxQGCZrEBws2r2Kb0qpBcql kzbLo6fTA5Xfb5l67DuOvSPPglzBR68MXjszZcSDu3Xgc6rPDM+Ba46hujV2 u2dcDy2xHpvUEnKOVHZD6NpyUy7+g8MhNStFoFLOESmyobhnKWxHA2EE+H7s Ve0uk+j1GjDDWx2Texc5nzDQHTlECBkmIju/eJ2Z8d/JlbwZXSYSHpPrgceD FMRiuC2UvSJZTkflZ+z6rX37BcXjJwlSFUQ5KU8gQynehw6OANR6bJjzkJ0K BonBGsoHvwnH1aVxIJhz2fdD6mah1TWgN6ReSlwPCuoSMBT74qLkgvvgEHIA UxLFgClQfq4fT9+AR+vvQoiId4V8rH1xHBBGfy8jkvU7QiwT4BzcgTwvAVlG FIqIFu3f16DYCLawU7JxVk+58c5iEin2yJvpBn+coIFwT3c06n/XIq/cfFA2 VNkaIv1vuhIKwMB5PUr7FKQtNvV7G9E4/MpSOGOQ8gpQ0mi5xOQpTKHzT5iC jAN+yZBDwwhhRMB4nqr5f3Y/5b5nhVB0OyDzKf3krGLq/nP/rgf1JDrFOjpB /cY0F+YLt5ttkqJcbwuG7+B9AmflvlA3Rix5pjnBERwTHjr7qBiIADn1qMHj 1TOC5AhgDRzwOD5j+n1mjm7wOVQHBQRwd4fdXshuQwQOFFb13B+ZFfEDwe/H lByZe8Ig2qQ+rWtmFctKEY2A2KIesgtlU0xA8mqqNMDUiMi2QzF1FgIce1+J D4kJhI63D1W9oRCvhmRIX6cDBJRiiYhYhVKKBOUmTSAB7YRO0YVD3DsTQ13G uXD/or1R19HXWz1o9sJdDuURIQhPAOwIn0ncNQnAytGA9epgiDMwjXrEtvs6 PBpweW8w6tJj18DRdSd3LeYZwIYB5UltqOYTkf27XFmVRctBedFBIvcrBTI5 juQqBxhI3wHJ7SekQ/JDZ9RJ3sPR7EC2IA9xJTQKeCgHlIoGVgiHSJqcD+0y WOuxAIRHL/N38vm9ff1hT1q2GwNiSZDf1TG8KIHBkyEgTJk6ofwp6YmN7o/D zK3RFAHBbu2chbQcIcWm54bj1qZZ40D6N4tYpDYmrjDjqzlmcMxka6FBzd8S KDkD5W5iTg5jIMBwjTI2xgzc6/SUD4rKa6+CiGphHD8RRjIPCh5G0k2Uak73 FKV/z6hK3wPV7+ebW+hN3mqpw7MbYbsjz0cVqjMODutbIDOcdF5YtREaUIY5 kc5GZmkAFvUvnl3icJLF2S3lVxwNhzoODdjFcnCzfJildQ3Elo28ImEObgez TLByGWUxN7NQXC1B1mRO0TAS48/ErF8xDm0l9SMWIThKBBKlIESht0QPuuTK zFC4FCCvZe+toYeiIWJsBvvfAshxTCZHhvDWMITe8omcAEgIHYjwP9Y/Uifd 8ymfA9TYNIIUH1qyGSvqIKFxUPlMmjt8mTZdpmddTquMJ7x2FTrccinIhJXl AhC55NgwOq6qDUWUM5FWJgfPJIkm1c/leuOf+3PHHV6aUPzRZVp3GKKC4am8 +VdfqYc83Zsj8MEjMIWpDcNW3IpD5xrJxJmB90iVgMPvEu+1E+LjngKutxqX iFAcfTXeeVE6s7ds9dnHfdPuOz77F5c2y0duyRknK7SUOHDILI2USF8Utupo 0/sa084OOOk0gr5RvdbfMbVXLaUoxaHk1Bc28xT44s6eGKtJCQksJIQTlx8n nKrZMggh9vx9+t6PVNTevLFUYNyBqAQOFhSlgQDogxUoY9QwdohDyOWBgZyt OiawlMJs1ghphPKXBAa7BOKf44H47iaONrTiFg5KsWJ8kUX15uQZJ58DHDkG 50POd8fujwVX+JQIioRvPUqvok0KCm4B+yKFQoApVEeR3+EkGVFR+oz9K1Mf 21wEaYBjG2mrNY1lYzlPpzRRAgnNhIJXGxLj2IQbg2QckQGwCWcEEiBshQoP Iej+/givcBgCIjk8KBWe4PPR9Vz6ni9eGezNmWQBDsJREKVBWlCwhfJBWug/ BI7oeuAZlr8YHznmifAIFeZzNgl0D7ChlFYAnxnCIICxTjSCUCBXj71sNBi8 xUDmSLJMMcj3ioMHZKwr/CTO6vRjmv4Jr8kH46l0TzEPeOH2n7gP4GOaFPzq UEvVy3FFFGjOpzMAMCS6pD5yH8CP/HCw1ZHA7n9HE2aWOzDdpQyQoaJHHzvq 7XvYNJbVImSEaGx+RLUwxIxsxGgxEY2LWgtaExEUEnFx7sn0CqCqapqj/KOA jgeVPzt9fOHCYH7tzgg+xoJDg4YHKXwuDoNW2/2XVgOy4/YX0LTMNKTBoP47 sfBogoiJt8m75L7IJF/8QTB7fk+1+74iUsJN7G/7/r/t/ryurFhoalKGlFTO T5fUqloEhQ6yng4GJeTBADyofAIDpznBGGRE6cJcjEiHYNxyh5II9X+gIoQP 4TP2C0AduBLgjq1+4cpEDijINDE2iCX8WLn7ILBhpJgIP8IQLuIJSaY8O1NN ZasUtg1oSgiHGMNIlKnrZ8h3dRoSMZ7JiOaBBjrtbRCSA2MhJJBO5KVzAJJI MgYuGaN2JtvocOdJcdkw6Qaia0xUEZfdlBmaIyl8PF85/l/Kn8ZQ5cvyuvaf 8PMKF/DLDCH808s7EHpfC7JRw/KmmmWOE6UnBKkqPZF2IfQAHHcHwAvLAD7z 5tCSkmAv4yQIOIG9W4Hsq9J6g8AhnJn2JphQDJ9RfntPLB7fncTny293p7sL 96fY0B5EGiBAgyL+UR/5+BQ/pgT8MFgLsgx5Inw5eHxff9PGq7tr+nHjD7aa DQx7PXy0z9WPqt4k8ttd2CcMGwjG8YCIyYRcGiGFDf5p9NunP3+OOLuBqbXF 6pXsyBzIrR0WHgyB/nAKLKLo+z9ClhVEuOUKNBBfoBSv5f86RVo/p0UhELQO QhVB9v0KPp9eJuCF2z4fZjtooIENSOmN9zgfprZqp2nFEfc5xIb6VtVBIf3f XXGLoaFOIhuA8OVBGyqMfVnxg/LfAqH6eGSNuSMJOnrUxgMfOPCiR/Njf2T6 pvSFLEBNEnaqimLhl5H9qAxwSYAcY6FhCd/SzppAtnAESXFPuxytq9cGZhmJ 6zI1v1kShSSdfrXEeb5a0bjFwuZBgTaiovWijefhjyIQ/wk9DIUfqt8Icy9Z ZVmBigHfagTewguQGoEOog5DnkLvv7P0gU/kmIpMlLB7kyQEkhG+04PeTg/N /H+7OiRDikHrSAf3QJZ6dhCcwyA4IC/UlFQYERHsj23v9WHvhjSC3aPCa6ZQ Tk+yU5FRFAQTQDRw0OhgLfAaol4QC0ofDDDsuE8HQpi9XdtKEzgNoYT61OwE Ps1giHyAKTRNijuA3iWnaCn2qBgmDTHYEo909smxK+aP8fDBdoEaYgHfcWLW S91EIULZiMbSjwnhwxORM+0w4H2h71TB3dxQh3K+tKcz2s3YIGmVKUSAHxjB NpEoR4y8UnfKnGEAd8Kj65pDmZclFB+XYJ0mvs7w5NYjEhjx+9iYmJiYmJiY mJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiY mJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiYmJiY mJiYmJiYmJiYmJiYmJiYmJiYmOdJnQZexHvf1UQ5yAuyRoMwJWZUoNTQHpn1 QUFNMdPD5XBLiCCHQfmkHTzYEfmK/JSL9k/Bw8tKGhKBE6CHIKD5OGkbAwjq FFTi0WBzoRC1JNiAk0+Ac+BteuD+jxQJxPs8fXr8XkHmgChGlUKUBTvU2E6T HXkZkRSVc3IPjz6fX8mcY1BmEkHOsn0i+oq+5Ozd9l4LDBpaBrT4Se30moWd 4BRAGDJMn4/txoLfcfgd7GjRfs4NsCXFdybjRCs5pA3/5UtAHRzdwxOBJANh VPYUcjbNnd6eVHoNxns7rbSEEkCQhwH5nZweHecaOxOdLDJQySMk9tOlngYw neRdJHNeuBt6pD1CHYoQQoRQwHPXWdqgeCP4HI1fEew5AKd8QLR8hyr9OuAs VTt9dJ4wft4HVTJtbn57/9MG5w5dztIeImM3E7TBUaYyJ9meRHZ1PiBSYGYk SFYmhMEQ/D2H3DBe8FBqImg/Q4HY1HkncgOQIAXladF8gdqJzbEZBxZsR9I+ R6LbgHsJNDt5BtLEutgKgiIQqIMKyySUrGoxwkL6t1xbaS3AlAH670RU+1k0 PS0BVCW3ueDBzYuWliu7JMPI1UA6CkY806VGRpgboGxIQuPe9bvv68U7s27D pwyvFEkyqVJZaiCYxrMF4Mt6i6wxnBhYAcLYIi4QxKDVOINgtIw12nWJkTXQ IlAkHISh0MqYjEWByEDzCeddAbHoiJEsHBoChCaZUYA8IwzliWBqvksc21XM f/35VgLgCrxhEDuYssCYVDG8jvv+LnoUob92BPWlDU+SuUebVQym7g/IoUiH 5gOHPLR6+qf50GCh1IpKhtQngMZ91MHq0Yd8IWIfA0eCL/XJ/CUiACZKRSmh aAKAooW/uw+4LdQL6oBKXxNYMpJowQDsk4kEQUqMEQTQCUDSRLQsQUqUDQFM SDSC0wwFUJSxIzCUrSNDpU0rQlCRESNNARIFIEylI0pQUi0qU0MS0KlABQUU qRAJMhMIRCRC0I06B0hTBLFEEEAUlCZ7+rehEPcbNQ0RQzERASUQSAEXrGq3 qbG5l8HEOeKfSPjmw/Q5ggnYxNAVU1Zo5jXK0ck9/AzH7exAQ0HANt8e4pQ4 Hln8liTGZGzEMaVjFWWmpNEm6MfRxTBjiXHTBVBNFPGB9B+vip84eBKew89o ERaFPcUlCSUTQzJJJEExUBExNJUFRVQRQS0sQoHj1MIsrsfdXMi5HUUiV1ps AQgBZRSr/SMAh3EWDUzoK/NMJoEGfoD/DcKqgtsL2H90eMfEtFv+gzf6pZpo dqE1IgQ/l2aSnA3jyVxqcDbbBpG+P4GAMRAOw/KCH+PvJEIPvV+n5ST00QGj bOJEKDMYYjQEEHSKk8aE1jgoKsMD3FBf8OBrh/oIIkL1kCEen+ORMcV3kM/x kSusIVCyOAJYxZgA0Wiv5DZSA/s1y8QkhTH38ACkxxFdw0MAUfkG6FPoY3QX 3QsihyKqeEQ7rAEzEdCIpVKn4464Ht4YgRUDLmcbRmAHckgzFlIwOGCCKAZR AboDbXlwH+tpYfk9Tu0OT3MdhhciqAPp7mwMagd0CJBCRVIObTHCcycjmbJ+ Hvp4EAurtKQfX9PIfSh6D0dNSQYl9P+hEUEC4SuNhmCliQxESBiVAcQRFClF grC/D6pYq6MUYRB1ziJ8ztKR0uhtlTIzvMAH1dvcB/80KUA++B+FiQJkHONQ VRQC0h/UuRwKlptg1U1DU1EQXMYjmxJKwRERHkrT24d3JQOQHIxUVpNBzagK iewmiIdHWeBPJdGlENNGhIvYfkP3OPf58RQfW/7vns+uUoQoSIHjxZTecA5C AngHjdSTu78mG8JgFZER0TebIfSDtkgbajjxZlF8gJX3EPxA/thxQ+CnAKkg iZapVJll/teD1aX5L9q9ZEwPI+HyBRDiHWpKgGoggGlA3GTkmUJ9aKzodHd9 1yM+Qd0o6hoqR0lRa0E4KCwTP4hyQehzCPnkeAJDu/F4Gyu8LfekDw9QbyJJ EKSlTSr/y1BGDo1Un7Q+3ZO0j9QOYMCJyIXfq+QYeKyIUr0vA+Bl7B2xH6ZA 983kon7sffCh2YI9kHnH4ndqnD1whgL4hESoAHSEOAeMieB+fDDW7yDBy1jo 0/qxcKCkmqPfFOBESIGeIHAPMPmlry5p8WhVoUQiCu4ugecNiCZke69nW/8T BwISzssMjNULSGBTJJB8uPf/iIofB5fbffbhgoHnwD3eeoh6FIQwLEODiY0h +eiDkIkT+Ug5AcdbvMPGQ2O0cQxKvGukZEOAQApyI3LYiEPp682SmiaFaOir mYiAAnBHugA9YR+joY6j7p1UlRC7yAPV1H3gE+k183ZIMJAXpPun6MElm+OT jl0mWtiKLyO0pRVK5coRnFETh4l0aSfBRLM1swR6vhfrWCPWCCByxPojfGrM 4acwRhUAsm2IIb9+ayzqamDawZnjJi3FccOR8TDlJyOdOBA6W8+AVgjexXLi 8nkHQFlIjV6lx1BTkZN/qxrvXM332dksw5QGsW6qNmCUAlNSgW8OUd/A7T0M E/V6U98ona8Dviww8T8Pq0aS9JmEEKYKTQRRQgAfti/PDXzg1tDwlgcQJ1Pz d1FofKPUCQ67+csC8PGhpKKPOS4EYQOSh0E2CCU0EK/lOWUOxjgHJtQOK7BS GPCgkbFwUngRHJbmgS0tyzKkoWErwQCdMiYNR0qRFwbUQ3cYlBidr3UAHoaM LxQZPxi0CAasCDwLEA9RCVkHHFWA4boD2w12YUUvxnSD+fH0T85H8TEEXs6P JIDiHQB0XWD0yhAi0kEmV6EUO9Q+3HEZD9XWWGIqmJCSSCiGqgJKAoCGRIhC gGkIkCiSaWJIgoKiQioGihCImGgFKKYIiZJaoKRkgoIipmpoiIoaiAKopYiZ ACCpQEiSmhomAiCgpoCKmimlIimCAOf1F8W5mwfmk0AeyfoPtPrIe0nADEh+ g/MmAyJrPpB+uaB7B0L3HAZDszFRoO5jCKJiJqCSJoUiJZGBKCkEoiigIhDW ZCoK9MY0kU1MX+346XTVG63SIaGSgYkU+zBHJ2Jft9Qmaq2gPjPOUPQ2DJ7Y Yo/26GG5XTiMIkAiA/KIh6oIg5UVUQkMoo9+o2jDT6A8I3RRMAZkW/tvG76G UHYBf1IDFcOgCHcEHaCgfqIgQBv7kbt2EmG/XNTiXUu6SE95DSLkiPCDmDiG 4ihlakTC9+/NbsUk6/w2D8e4yvrsSSlrjORdTB1awCol5+U7Yde5/wOY5wGV miW+mwpAFEB7g+EByCjkL0lOQiHCAXyObanmxUGJTy4YwyQLohhgmEBnlYxC oQSnw8WioNQC+Hko9mkCCgpt3L/WcTcfviHs9a+859SgH7IUD60JyBu0RA7d 3Xop9dKpZ4WaPsw85u7Ae6bJyJyWliRe7dZw4G40cJmFxoF72Nr/pEOqW17Q pX9vX6L2YdfX0juJHJm1IhkznfjpDqxJDtb/OUIOYi9Ip3HknMD9E8JI7HM2 hvHvukV99+E6nHbDRb7JTUUbE5YEb8z9snJ8hOwGk5aJkOByz54HxHgdn1UN IUfDb5EnuA8DdPoh0tnBKoCmJUSknkrDhacM7aooYBseJBH4Bsf1kUkQ4jAV 0KzqnMMiHCahNAJFTUzq6mVNFx2B9vlCwbSCxZtruSNImzRGkXgfuoyGgv0I WvKBsbEVHYXqUgpkPh89FVvOD3ZnDjm3WY4FqGxCSeJS/zm/N4GtEpEwLRVO 7CNqs05pmkmy6aKMrQQjjzBZYpg3ycceB4O4URwimGDwCkD3HnXJ3d2OHsRI yJCWGPPx86122nGjFIAyKRBNbpcYFaCFWMWYo9k0rGMgMwsv3VQrG2J47WQU hINqDKvLRTdvPO+bB2B0gPhHA0OkfVgkkWO7XMGuaePwnvrL5JEreYE7FJww bXkeExVywHZ2gxDd6xHQyPSjGzReMulDbEb3HJxzlphwMENHKGSIwoIWAhgB od1j3qYFe7M6cbvBTG5MZMrpmEzIZhMyGYQ9eipiqfexxJzVm+RjHhPu8aUq xCK4WBgIfCegwEwZFGiYfJQ6OEMRtHR2Op1LMBmBo+ui4IjxxSoGsEPacj38 l0ZGg9pB3KUGxDgSpMUIS3XzBQ3gJAaDahLh+VFPqFb7SlIUJgz+Xrr4frPM Oc7ocFLgL/VBhAQNtuiIMIKuke5lgw922qZModYdC86dDcInBCZjmopXqsjW UZhOJRFIkOnCOxRQEjzGIDkAJyAEK4IhCf50jLwDOVQgggNnIn4ymgIwLIMw ygYCU0SBrRGQjWgiLDca0ePwr0zvD68OXANk3SuSQM7IHPuDGkRouDh7ByiG xjSTjpjHedC5guRsSCPMLLjoNQKYyIElZU/lyaeU8uY1WQio5ziDwlFw0Qsb ALzBw5ARNzcMBraJWDlhyKJzA5AV5KqRA3rHUQlKAiIHbHbTEuC5KC08XvJG BDkB5A/IG1ybaiiQQi6s5YVDxylZICmm6rrCvM7HR0YbG1BVlAASWSEglV/R 9IceQG44aOexURQQrI0MJApIvraJ5IckPDQBkUKcv5HxPNs7MvZaP6onEKil dqgcxLSAaqnFCFD80l6BThIsAe0tcfpOPsOPpo6n4hBPU6GLRpCTXcToaiOY ngSaYp0MJZBsBItObAMth/FNPzxjoEug4QEGwhiE5FY4nydjYyDa8/Lf4PaZ oMCUOpkJImATSVH6EFbAdIQIlzH2RlCCpuhDlpkiWh2P7ccRqkIaJNQBQpEi 0DEjS+0ITkhyOHmVf+WVeBBRdUHABSNLhsHYL8WT4RJ2r2nmkQoPh2V8rUSx OAzPot9XAhYhf58gzGJgpqLTQEijcCQyZLuQIn4aq/besTTBRRQFKvh6k+KD BLd9A4NfDhksgfKqW/spk6TY02iTwMwZXw02HYRuQjRCJbfWLEFWDkeFHCdY H7IZGOIUnsVApsn4eh6T541nD13kC+tuajzE0stFP+xAfZBLE0CkfwCB/eeR oWm0OR6AF+Ax9qUhk480drpIFkcZjoKxQer8IB8eP0yGCyiaNJCK0ONuBJG8 ksucnmaQgMY2AH+6IEaVX+F/WrvjokIg1pWjMrgRmAWE4hoWUACUBoUB0J9b oj0GePV3x0IlZ+g9Xr0UbFSZ7iOQbbQ12EgF7PP9AIPnTIS+3GZI36Ejwyz7 cIITKx5+inGKIemwQo5HJlHdeuW6jYM5MJYjjXFmNyUut5qIFNCDoInaPwnp qRB990sJIc5R1YhsPcuSB0fXAeqqZOK99FipmFrbjCRM2NWSsQnUUgRYudIA 6ZxSc3o86UjEsVeefodu0NbNr8LDublcY2Lh9TVvLe2ET6wXVg9cbEG/ib+D ysQOmYNIFBQFLS0A+H2bzowfTpkOgdkigfM5CHqGAG22AEPuTjyENSCg/D+Z +CvrEQArLl9IPaAQfj7PQqqIlqmCB64d3U9fj+aNbj1hH2Sd/blUPVqU/2d2 IobFdB0fZOBrkhmrSPYkF1GPbOziHmipEQ8iEwL+P5fm8fIOQYBmpSITGEwQ xA4lXjUcKpCMWdznCW2dXHGLQ7PI5cR1AaDS1iy7XDA1wRoEJlRSaTSppKSk aBxYNgKbmXcwfZsUQkCQSuxgpk0JMyBMqscVMA6F01RSHamDkKxDhQDQFDli +yLmqOEkSmmNgpKySj8huQD+fYrw2qY+GB9x8nhbAvxU79jGEDwgakAPhFpG PSODiT70sDvgBg3Qa6gHzRW9mVekHXxTqC0AIs4H7lEj80R7TMzMzj3fX3tx 1Gkon3cwxIFOpQ7vh0UVySJZniqEJ1iSfl9HU6DoB50CjbS5D13cben9TD64 d8FjTT6RtZHCjIapRDMeGpjERAvE0JBgh3gmDcAwKOVE/zQFAPFAgCU4i4MG DyBkkHJ9/sqGiKUCAX6FibACpwOqselJwsTyh7J81OeK+ChH4vIw49td1nZj kmRlFk8ZNYd1CWRAlAkCAVFhlSIowBFGJ1I07UHmx37jMUZBLFTawOE2OrHt LgxxNlHuH1wUXDIJOz30np0jYPUNpmwhClPYnnCJwtFARLKQAzzblEDh7I0M S4ikxLlxXF9w81hW4tXGdH0YYaN1N46b3dufA4FjQbjBqI297aI0lWYijUei RYFs4xCpokGktLpDLnVgbpiKw6MthtICcqFCjiG1FVASMGFZwPii6bIns0Xe WqZRBG2KtCYJ8OlxoMMBh2TQcA5B5I1peWPDxGuRtznSzOMMZiw6HNo9B0u6 oC4Ykas2zm5uEMTJMaRjyQiwhy9aeWDHUNaxFlMpMMMlJbGDcZjARjFKGIMI OZQ0HZ71NpCmJielofCDSSSdk7ARzLpfVy7YI7nJGfhOnuNhOyqe+XNk3FDh 02jYk7sDeo8ZXRzwXb43Ac9EQwf7/GfWHnNlzCNikYjZeQocJ5IDzBxKPsbG xib+3m1srF0UtkHYDoENEELRyOdEmjGogaCjrdOVj7F0zWoubivDII4Zvwlx 7lGix88lxNaZNGpcbYGxnZqJaZSWkHIlUWlJaXABjMjJg8h1QRJWjtwuUTXx 85c+EGvd6gNOIfdy67sOYrTqim2NFNsaKbY3K2s7bEGI1W4w5GvO7fb+VKY5 8J8RBKURS92LHr35xGN3hJEeEyvSyNEUST/K7XCxEidsl4YCITQViQozTwLI bJx71OEGYMyHA9Pig8+Z5g8juEyyTzhwUdhgOPYEIh6l5jwdJiifOnVJ4ixC J+2+755PD16ggj1jKYIksQvwYdykZEKVoAgC0srBZF7Sclffmh5n34tT/c88 gBcl2k7B8RM2MO124iJQnMfEq2hsDFJCQ97Mn0GHJnvHuA7tGB3uvAF3Kp6Q qPHu3dYEXhXLWsLUVZR/fJoI7cI3Ag7FsnvJyIODgxBBdpQAOGckT0VELHTk 6Lm7PKuk7rjCr0p4RxblcDbHBxCYmIwRcz2B5PdqACw5TSa5jcIIqJIDVsMs lSwduTzhsgy1p0nIQpJhoXpHDYDpxzMsS9wqHNrELhSts2jBouY7zaTjAdjQ Ek4xkkYUXGE7jE8QyOXPDcA4IkdZw4heMEYMgHDgSjxSPiiF0KChdrmxMxcO T/3oaDAopEwCZKtKXAKIHCiuDyQmSkRoAiRqhkkEiIoho9wmCsZcSRDBBVNA w0oNEQihTDMoESUSIyhJAivRPuQw66KKKfy+blEpTyNEYTSNmEMgD1JIL8Vf jVyPg6bKb8QWwUuCKoc/jxPzNX3y8oga+OHV1gBsi6KU/pQVlP8wjUH3EHH5 5HseWpKt6p7k02g5pJpnZZJ9QPeB3ooxANCBKJAhQJFRSgsEB6JwSUQpStgN VCKUxFJSCUoZSAWIAJHZEChD8OChyTiLDYSKSOPA/MAvefsY/J5BjsaQgADx yA9gP0TyBdEVFNKsygESsQGjfi7euIw3SDxQT1wlA9efQhuJhDggktMRR8ow /ySUsY3mB2p/OZ3/qw8NIAOCAUoAUPu6LoD+fCFHNCPHT8JkvlVQDdPyNW0P YySuKNAB8AAkFiiWgL28tCakOk6j8p7DdoU/WQQE0FMPzA9SPtXY9I69FljC hH6bmjctVa5zcdo+to53ltETQEVLOyaNB9OYNPOYieaxjjHvvQ4TF5s2qvWM FcHQuqT1FcCaohCAz4h80DkdF/QS8TidEX/7+XgefJVPT6Agkih5joYUKQAJ lIaRIS91A4QGJeI5XqFED4RoJaDlgPJThAvJKGsZxg8GwHkHQIF0mJYhiKSS aUBrY3DcjnLVUEzGhNkNNWiUYlVMbL8rdwYdRiwd5gpuRlgQKJJpeG1HMmEQ 7GeZHSshAydZoEMDAOKkkDYf33npB4A8EFOY8vChDwiuDyxTQpXuA4QKcTCo UqbeW2gmyhGQEXVCGkTVQiImFTBBBlkHS5UMTEk9xwgtrIKSapqSHSdEPAdl Dl+hBWcods5AwEO53yfjVBiuKmmchiGQ8tA/33lV6Jy6yJBMcJDKqYMJDv5+ H3P+MMYOfCytNzUpNWt+3hJqlUTaKomiEeTYORguM7GE5KX9wnv8P6t/D3CH pJKOtcuOF+AsU/hFDnAcEEeUQ3g/nnWBS0/G9z6h7HuwB8QMnID2TveDmpzI AlA6gqzWtICtYntka+WQXLELwRR0iQSG/7JKUAOhwEaqFQduOmxwmD3aMXwg 2MumhUmFfBEMZL7ObgFLQHxFkE5DRSNUBuZocRwPvrQIK4bYeCn9WSn9gNRo fDD36tOsIQ4MxX78gEFEMJxCchiA6JVJhUEu7SxUbCt+0K53te2CtFkGQZBo YAF9qwAAmL1CIb5bXE9i+u99EEAoQMMGkE+MpknsPhgwiPiQBxCEX6kPSQPB CPIIZIEUlgDBHQDo3LA8el446E0d2bAoWyfzv98FOQEWwia/cB8ADioyESDN BsgI7kjrGQHjIoP3YQewtUDnfka4/o/ggSCBovUsRWVApTEOhh0g6USkGlGJ HThxaMYBLIAfyJkfxAeL8Q6qLxBDlLxFQesX6VlRcgU64KBCgU98KbRtkmd0 vmk5hxD0qd6eZB7TzD5o4D3/X/pKUixKq0CBTSAFDSiHgiv/n6zrIDgd4H7V EDu9fietH3wdF7xOUCaTRKomkj290cglwIlgHcf7jQyNvibRwiDYRAKoPKUw oxQWMQT8jHUEAIT2QIYC/Nd8LtIhQIUp9Yidcq0buPu1kOxKhRwjSETEpEot InxhTvcoGyGYUJ4TqAXzp8ffilAaQHlAB9CXCSGiUDhIHFWqoimhDeOiEE9k 0IKOQKQpCgggvpfPz3E4JaIejF5Jwhk/sidIB74lB7MtsQEeqDKlF4clNchN eKiURCyhQvEEMKOENegChraCAeBFGBHYYUDJQg3Klgu4PSv8WJgfIxwTCHgB 1fQkvvCT3FqRHSovSP65HSPWgSr0k9HbwfSYPW9H3u7yd1rwiqKKFoENQ1Ep XTGhDJGwdeAh1SIwxwVYTew5J8yNfqQOrTSn479cGS+2flVwLeJIcLeQ/lYu vzS9g/1PYncHBOZdSHQf5sR0h/CDtj5wHnY4ihFy6IHvgRk/09zv9JiYGK94 LaJoaJg0GjDSkSxSDGmCb3ymFQaG6WBHhJhAIQYTUE2RDFjAtiyqFbBUk0Ea DVrXsw1AVuvFNYMbgMd99XwOnvuKYsfLgcfZZ0oBggAOSHuO9z+G7zy8uvEb nMgHISIhKSgCilSCClogA7iUyGZE9sA5U65H8dAoSIQMDxFDGcwaZTDMQ8yL 5vtEiIqSSQi5cNWkiuh7yDFhrCQoTEu5uwNwz2wz5j8u7pKpSVP5svGMHQup PLsQOKqHMhDmvoGIiIUIJARWgFEoKFoBCqVRCkWlaKARQ/j2DSJ1D6+ztLqX RQ94Y+iKDPvZanGVsqBYkgTrcKAMvLKt27pHgEcPgUTzBjgHXhu/zziDEHEr jmC0DgYmQIyiyi4gxD+5IaCIeEVDNpJ+qg4KFhRNQIcQ8GpNIs47q7PN/aB/ zTzBsb+MWGKIeJFD55aclShGQx3nOA9A9ymr5RQ7eHavw6pW4SeY61nuOwOB JwkiskOup1hqFE0FjkF7iZOYqoBgfCT6A9uIYK9gHGGYH2Rw7dKD7NUoHgoa U2mg0eGQ9PXbUISiANX1Mde9OEbFJWpSg5zg4xQRKMEGhPL8KVYe4KxA0H1+ WFUX9u3I/yPTQ7LT4ZYwJAGRTUx/YWH7H83fZr7Ia3GhEfwpznnoVc602jcM 07Rxh26HfbZZqhw+o6IsiWnFEqlKGR6KFC+OOO7MzcOUmtBzfVHcO7Y+LtfL 0XmmIbU1mThQm/NjWn1e/P3t2twFGag3LY4iTgxvmmwKasnfUZOcrbyJtFPt bjdPSqek+oOaQCAyQBe/vxjy5co5u+aKaa7TeDcd2A8URPAOkvLdzDmlbHI4 VXErXClq4CDYZWhI8DhyyQklt5Vi9nNuyJg1BNVKgBGDCygx+Xwk7Dc7zZDZ 5nIR4SSSTpQUZUGAvGx5JqDgzhNRkCUq+JSJ4PY7HZvD3J3oEEQEQ/L8fT09 ZNSSP+RoP7f0xd3vUlmmFiWwDgoHQenUgPgAJDLxCcuPQLUwJjY0dBEDqQSU vhv3vMTUigy7tIRSSTJkN5x2ijIfxOLqIZQgpCYn2vccKN/1/LodKO5KjExF Y4W5N4YY3WyyJHjK9fYB6D+EZ7fRKTINI00NACUTCRAhELRUkSSKBEKJSlJQ 0FAAUiIZ4PIV/m9OVNK2yJzOnbcXtOZv9xsCHEUDRKq0I1ECowDCUB80C8l6 /t8BoLy3yHnCg3A3KEdFEivrSJo5G2AktI+DOwrHoiz0YbAchoaoiE6vLmW7 D4Hvk0O+B84pxeJJhkbiywkA+DOkDdEy0pQhUURBWAD5kVgEPoilgIBgKAmb XiNucdwIyAIsbcyNtUyL2HYPKBCZGBJWBgg/Pw0mpiCTi7qT8fgfE0V0JogH FHmE7sXdZieqD0JNQrrp++n+yrli+gAkQg+IBAE8VeJAroovKAF+mBQ+hJUT +31bmSHvg8syGWQTZgG1nopMbidkea9gv1L3gKA23bA9qxQcklDs+R2Ok/LA HKKezFTKChHtgXowFEwB5gVQSSIEFudBFAzUz65cJiRj3YuP++0wdmwODqCP 14IcIA/woEfOjzV9J8PXbiBUoewMQR0lyDqRucBaMVhCSh6H9BoHUEQl1Qeh +02IqCgLxxUwCAjMQxyTD6hNa0ESJQsfSnvL6H7GMG5aQ+Na/L4d2CulGx7E TeAJAibBKnBIoAeUc9xnxeJYnClYCUODv0ZZCppJCSJEJoKpNWb0D8fdxdFu wPvQqoSnld84nJSOqBgomX7E4b1/bJgbvQE5oO5PQEB/WS9I9VcgfUaR8g+k hVVCIbpaJobwNlEPpyin8kKiwNuIYCzvIN+PvbRfqN6jGaVcnbiPPrdX56/N 74enzaqCXOAHnAMQrxNBmW/g46OC/Cd53uHPEduxyEI4uZNwngR064Ojk6cJ CIxaC1jYGUSo0kUYQG4DDKVATDPj0j7r8rnFurQvenechcmHb5HRufbAQga3 dJIOEHR29BStnGpRoOJvWVNJtBwh76QYBljBTXTElE9ndK/i9oisliSGTEOz iQgpG+n13GCKCeZizelnBEx62BLbLHAg4c3kpq2U3bNnBh8xjEcqOTwt4bnA x5kPIOt0aZbuDvLqceDXHWNa0TQUzWxyAKkMxgYwr7uGxzTIaZUR0DbgT2JF IgG1mJiLnQ1sd8PDhEABRQRLVFBEFDPMJpCgCigCfl5671ifWNF2Q7wth1gg 7IcITx6uWxzByEKIOB9dj0TSaQQ7JCZzSlMkIkXe5Q3IelGMMZggRbIXcspr gDdm4wapZ1SWFFgslXLaDW9m9ze8aI7BoCKg9GAbRGxhq2uqDs7zVenvLg2Y Pcyt5hWQK6jN7muNWgd9t3hmI0yMdiXNyuOuPjUsCuYmsQZIbyJMdYt8xcIs UOFJpjyW+DShildM4LQcHFzVuhzoxnLxFLOEim94sxb1ga0lMHmq9xQ1pdjv mLcUxVVKcVyBxNsZFTJDNBNwNiLnhztc2tPY0cuJtxiD5R1tOKiqo0aqjRqq NJR0Y0weDYFK/jhoWERmgJa9gjnI68V3xfDzwrt5C4jbWPjdDtQFXdrGtUZX GMGVJZZkJU+RAHoXhpKVA62nl5VUQRFK3VtNgWWj7zGAcpSbFg2ttIoSBvmS VR4YopaNkRQImhKrASguCOqT4gHhwnvXDKYMOSkp5xEwDQWDZjKYP2jYGTmY a1T9+QRsQ58giQKUTkIm6EVMEjmJ5QHaMhhBNuQbiGf0YFP90FTjadS7oTYE 7EeVTE7syRqCniHMn8R1cCt1gxNARAC88z1oB5DuA2YIvCcGsspKSCJm6BgS zjy5mjTQEiXHiS1/Y5jyUKSF5pMcSNYStSaqjGKK23hBuJjXmowcg6R2KHl2 TYW50uhd7xNcIrrJRxiguFonsY23bTpydgMnIOmchNTCXA70iYE2OUL0JA0g VAgmYCql3VLcNo1dLK9o6efyT6QrlFEr0gYTI4e5AMwjy95hQHifx9v7SQQi BJAoQl285L+aXyvLxPVQERDJRo8/o8vRvIx+Z1oyaQ1VeDM3pLe8pXhVBDXp +8OhGP7OH0PgguQgGAQjSi6hVIgBaVCJBTgSrEppXEgpSsSItHvLtD4EB8wX XnKH0SiK2B+GOiE3YfvvH0HROB/CRRQGL0T+uo4SHiSd+5ffrEnmB5SpCkko niI0INOuL32S4iImSkivjwM/OZg6SdMgs7OBw+jGDexST3x6YP2IxI1TFRCb 58tBoIbdJBHWIXzCNSd7fIN0erHAckxQHXPwDED8cnFl3SDulpA7hi0w+7J7 2g9ow5GGdzI6Ap8QAWfo4UBBokEMAAkOIPYbpgnjIIf1sEXBfxjXhdqA5XVN vM82wVTNZUKYEOIR2Xc3azwZjeLgRGry79WGEySxxeoSKkNAaDNpwwBi2jqH xUKpUSstwcLBmilxjBtNtZj5jjc4j0Oyz5nviYUxox2t5qN065S1wB9dx40r HC6DEEPHpjkcnEJ5sxfHuo4AmT3wD37x5JShpE8JIIAiClfrsgEe/5cfil7J NlaIKn/CJZdSiNJ1eOFVNwMg4nFvrpdvLSFwg3HHGVw0DjghiQDbZEyUPQ7f vNkdeIvmUExJSgchEPuYJXhk7EmATE+0fio2GeJrZg19ntT6cEt7fbdo8rgy wjiMQIJ/SjmpBvfkLgaPZ8czs5MYzGfGOivPOIH0cc/iF2yC6OKfriOANEUI wIMRwiQ+U0CcaKCClmEhalIJKSWGioCWkpKGhoRkaQmVwBW2GNMnyDhKghoT SpSoBDC6DSBSpS0osMIBSqpoIhBiRUyCd5wBiiKRGCkQIA2e2UPiSpkrv1lE cmIygyQnKskqoj84RDEgQEgksoKRoCcQA5ihylNj56XuFANlf9IVmFWhSVYI JUGSJkAiZSEAexRdtj8U8gPqdEO1QF4hA5A2KfeGmRPKKiTwpARIRUATKhk1 iuloIcRQTK8D71wh9x94IGePFEWpMZtZo825Fzhw5OgsZiKKSLGORuL6jRDw x9UwE+QeHE6S+jZFTWRfwRd7KeMig7UAnhZDgcLjJi5sEbQUBY5yI5PFAggX KgQZJJUcXMGXhHAjiBsR5styNBgTI2KAOGxU7tgQQ8CKA9aInYfv/r094F5e 06hNGXRdD2THMWoPVmNdmY2tMIBGiEy16CAXFkzKPTWrAYxtMWnGNgXyEp8v w+mG9xbG+g4af2vhhNY/6afCfXvRetqNCd0jGR4uMzVOvpK9NapdeJpcHkxI MDjCl6cnOxBq13/VcO376n418fnWzZTbXLtRA3Cng1zkrfzb6bxrHYzFIpOT WYsUDuVpepds3JnMW+HEgmDIZJZ1GiMoBb17QyaeFmulZmQWnImIhqSHxPTj SDZiz6YKbzdIazCsUCbQglGp4KkEik6kY2JjcC0vSIb4deRw7M11h1ZOZyud V+XPldJYFg/e8nOGVD6K3VkNac/rdtQ3WrRHofHeFgzdQ/HL21VyYV2SMwZh nPhl/xS4DiMVCldOOLW64ppZVD+o5MD50TLIuKlse92KqkXrm24WE2ENhoHM IdqcmfWGa6A3wZPgtTus0dCaE3dP62RAtYYmHZnfT08PwBQj2A7OyYOZens2 duCpsduuEerxu/bBWJtEkMq7cBDyN7s3BtIbS0xIffse28S73JpQa7yVi7FL hrQTATUJ4C0UnIHTOh9SVmZlYNQwgpHCLWZHraElK9OM7JO879bxxrgPZt0t xrx4mFLCFDFxG4QhbCDo6LO8N5wzQyf7DjNmlW/CkqH4kGtiiIQoa2dDmTzc wL+yOCT0gcw4lmcVNHcgqqgxi8cVLVJRbrbtzUnOtXtMkUlLgvZFJtTQJHlx 5eoSQsCBLkRZu8S4r8WQG1d7y5vpVx6c1b01pkIwQOdn9hw3dNFERjEOPDRl Oaqzv7Tjoi9l8IwoRpt77EqWiAgrFCk3ZApYZj2xxYXHyucHw7rSwkt40zSm bHn2lGZwwVg039quYG28pXAjy4Kd3t5XyX9mjySBI3nsohzDMK1aHlz2W3aJ VSFCQJ+JaCHoHucdFnjhZLMpql3QlP5Bx2RK1HMExgyVyIm8LRc4q46Q4nxB VxDsdMJiSSSSSSSSSSTB0D5N4NJA5LzV2NMpolJtegCWm6Szct5XvOHGXt5w rrB8pJmSXHkdL46gzT5jPFC+ODDvMM9sPiYL08J/ZyGDc2rl/i+VuR3W/Lyt U+/PFolxEcGoSTvOTJ/srGB+cw/MG2W9wRalKHNezPDjc6zq+ejh9B8ZnkZr 4lXLU6WlpaWl5PedvGGArZvtI2445IMhISQYy7lHjTgeuCVX5KHwF4eiBEDb fQNZ9cTkaGK0lIoNAqp2x0qM8xj7bd37jvuHfv35mJuabgQBHsXO3LyajQ1u 6K5PX8iE1FMi+fLK68UpyO7QpVlEIFBMahkIHQcACY6Fn+b6WAbDLJsZy23Q hWGw5GGmjyzdd8iZNCK3oRsp7KeGuSLvpDYEDaj1lak2oOI5Q3DgaJZEpDwT 8f11Pc9/l1pPF8SHmH7Vf0c01R47D657HhwS8U7FvNkj7g8R/DqXbqCEOJL/ JPnGjdAcTGFoBLjZERRP44hxv4cg5vx48xz8tEd6bsEEg4aRG6v4bq0OZzVv WMRcRzSrGLRKuKtlnGIVSAFUEMYHMQWEOKRMkhCco0cNVXOYQWq9j2HHEQjj mqoxoATnwsMtLMFPuzacnbvAd57wPZO+t3d6dNAWNAkFQjCHnNgIzAhhkBD4 qfh6vO8nhwKR0qHy2JOzbFbIMWwR8PIntnnn0aWD2h/b7p6/5psEjbDPKInH p5vXsYBhGiHT0hNxEZO5OQzspEoJFCoAUEUTKW7PgRWCRiiYQ+J7fY9gvvMG lcSkJDodOM0mIM0g9vofedbH6bOOgketz0nSDaSgMmDfD6raPY9gi9DuO97n AiJcwiKaacYWIQwsQGEw4j0MNKQoKyU+tISHqooEQ5GU+j5c6ADO+sO+Ziki UiAjx6riD1GyXAoMFc2U8RjYdCtIFiyHVD0ucFB9PyxH6ffNGIQ5tETARBGk BentSAMJ8I7BoacNoSNh8OPK4WLZ0ZQiyQafsnQ8kxEQ6okoPcHfAsLjldy5 smncQK8CyUH0hZBIQmSI5xc5ux+H6BzRGqoScZd+XFicmziXwOkfmCNsx8jz 31jR8k2C3w78pn8+JmZiFp8oDxJN9Mp1Tx5Vwdtm5+QKv6QlSCEgkDiJuICe ID596aWA+iUHR01VQXWDhIWGnoHrIOQ4q/rDcL2L28QwIkpCn1U2ZZEBQRJr EkxgnOg0pMSIbYmRimFZWmBKTr8bebJsdMMib/liI8CBOwdpAaEWSGBOUoBk pRjImHwfzX0H02Rq4awRgxKr9MaGCGA03HU/BpRg1SBGnvcRQvE67jojTw0I oMMYlDZsjhvFm2obhMaSEt1tkWDMzUg8eNhhDEk0VbruioxXGYPT7gTkcqMS UC6MMehcUgC6vc4j00EWMYkoOocDvzdC0/EsM3QQ0mHHdZN56StYE9LTijBC AdsgmCBolR9GLjA0vsgHwTmgohYDYqyAe+e4/oKMPx2CGkQpGPa+nA6Eh/Mk ukv2m5M1J1Nkasf9ovUgeXcc/AhhaA+tIXQK+XoRWAuqNiqYqci8fZtghB3J H6FjUZWxX2lrYaNLi1lsFWiDWJNg2sGnBE9eOpjkGtyE4X7X9xwYjDTIVDRV o/FSFD95tbyIPUyFgesjMjGLHsNBimNTI9nNEsFotAbR8xmBhM3QQHyyeHDD H2mzCsgUCELDH7NaxYxcMmSouWIAJqShiAngc53geS+hgoJom6432sIBVIIp oN99BpMXnxPi6+lTngyjFMQXiYJxZfbuFBTkirt0DERQmckJFAYZR+E21Val diqUEACJy/PnmBSRqfh1mD28gzelEm+0ABYQb4OLF3L/wfu5aQOBAeZVcqeo 9xe13WKC1CgxeB7oHU/eWDFbbcHcxR05GAdAjkKfpkcJ7QzgagDqEL2qI12T hARk4wsnvBJe1wd+DDTgaqIu1N++GJlDyXxsfAFA/AEKweJUnL6Ca5/H0+v6 /fVufo/PiM5xX3+JsgMlzAa/Gzh4Nfhq+HWW0r1c1Or0YPq6DYiYrFgYqnYc xAMnkrNeKzwwFOMlPFxjLqczjAJwP4L0zpzANONkjIAoURFAMe3CEYxpxjBw +xMPWXhq0fFhU5zYkq+aloKNvI2mNUGpvxKRo6DxadlrROXFUTSNDSxgNIZt Fw9hXnEQlJEiqLmUzR2+bWHD0G4dA8OWkYkezUbeEA7zlkQxVs8O4CFlDDsi eWJEUxuTqSqWvv3DGUdLhZ3RHyK14oIjwWQa5q6nsbIY5VQl44gbFNhblJ0y p8CO/mjG/F6IzZx023hNKYtMOB2XDGQsKflOqAq3bTckfgrIllesnrNPo4hF FCAOga568Mb1vIbuNXfcnfWLSjGoyjaYloo1xE3EdYosWPV266YbLJhB3TJw AycXUa23HEFUQ3YeDDpxiF0GbikWIFgvTjWEzK47iuBaEWgQNkgwCGIhtod3 iczpYvOAxudQDDO+k+cRtGKyUCBEMcRtGo2cp8sWnQ/OjfNgGCdXsEiBe98d sOVp+8cFcwdYZggaNJmygYrl2JMRcJnY15ZoKeJtQTJnl2cWmax0nZQnhlHz DZz2aS4w79znE0cdNh/HIYTIqZhaSeHW5OlcjoRvEc4KGdExM8h2GJMHN5H6 pi2YERlULTYcxBfZWIYBqxgktiTEtEZJbcadKNdbe2ZhmyxGXzvjjOtJp12m UpemoUzBEu8lU5XaYnd5TvvWmSUkgb1iNS9IdySPJ1prGfZdhJO3jjTanHfu 3GeX6vQAZE88Z5QrtDqy+qclK9GZVZGrO7yzry8eO+tYWs4jQZqL0FjoNanL ODiYYkzPOGNKtYLjXEQN3HwQzTFyJQnVkFdnqlbtHOWgxee1ub0VGsslInMO +TI7xRuLMZHvWdUrmGxZrC5mcu9J3dsynG4EFUzlYhZDD3R4g48uGWM27X8a MGYEzHKK2USFKENS5AqcN+c1TG+AfF9dwwSmGiHA0mRw8bMuWgcDhA00I21p ojGF6SFB8NE5fW6euMKhaqm5vsbJrx5GAhuSASFSFDQpGGAcEwDIPFlxvZhI 0qkHFY9JIzM8S9ptGdCnLDhh7GQaCMIxdB4lAREzMAkJGvUbc8nHUPfL4ez0 R1Wntg2a518KdJG0NjD6ypPd+qyba2aGNQzJAuH0iky7duYY10gc32CPgamH 7+B20kcuOdF4aGS9Ubvd1vjOJ16uFdNRydEVTHF/HuR9ioqNO6lTRjLDscMN 2MXrPPp3OcYfEDGNvTUpiPQNDYZYmwg02sm7DAIMg93ftfneg1gdUaYjtO2o OA1dU2BDqB8vOGYTcXLRN+ikh57eei99MPvvnW0VCYTGBhDCYkkhJJJJJJIS SSSSSSEhMcTJ9/vq+Xl4nuBA6dyu6msqNcoJgEDHGukuaFAC5suRsAW7LZlL fRx2cbwV7Tmw3Brg41fPnfVnL3Atvl3acw21LTBVcWVeiEhJAhMhMheA7h4b pCThZAcY6JZgDKfxuZaeE3UQu39lGWR1YcBZPHMASAI63fkRzo3xJ6vPojMC WreXdd0zv6RtYV7Z61jv3RTBDM+lOqTDpmo6wQ7eJrrHjKkMhgN0qEHacgcu iQsDY0BoENHOI6ADMws2NpY28bHCDcxiKoDC8hPkHHkwd4w+eAhgjkJtkQMu DsvJYTJCJG10sG4koKUiXWJQUFHI6uYHMOfGHk8QdzVXhwLyqmSCjFRoJSUQ RdQ4tCmQgZQmUYQDigZDXIoPai5ehwXoIj2GR1YHbJQaLLGXQu91mSbPEdP4 EhSOkfDjx2HgL/AgoGhHeG9gPcRoA2ikBKMkHfAgO8PAlOk6YQU6+jo4cwmI peo5RMTBElJF5sMFCSD8fSImUxN3AJ8bEKgUBxLy5jC12OcshHLC9ttzu7TV ycRBJHMCFBoCrAgpnIEJ1SF6EvEkJ4YYxERowEOr1IaJrBBrrSmgd+bi8ZAR NWnBq1Yj2wjNi0MiZsez1nXWWdZxVFuyboDYnjZeYczdjNvVg8HiWxvlA3XV i6NiJxBDXeEEMe8TFgSN9sH8VAkA9FYyHVMvI/XB/RxjrDEXvgyHzA8/SJ1p 3gXw7HGO4xNT3ZlvrOYaBAbOkNbZwPVCQa2YEOEsWkFNmWigbEimdaeJ9w6g UPFEwJIi06rq4cZMkN5+Hfj4TxNsQ1fbGHzzekKC5dPG2pICB+IIKangPaCu RVz4zMH+6fx9NaV1DtG1kmqzAfq4ekfBDXg4eEmi1IwieE7QnsgP/G1JQgbl PcQRDGJQb4U7TOpU6Qp3yA0oPdKh2IyCHdFCgfCUTIFH3QpyX3eoVOSCck8l iAB9wmhfIB/pyq8hA55lU97KgdgSkR8mTJBeEnGd0JVIbSp4Hb2U9xmJRgdC DIyB4Rb/3pQ8IPbFNdvx1waGLsHUCnKED7r8ilKQGzA4idOAi/EcJ9rxAKAy ROvE9912U5LDzQ5YCh3V7OaUUUPrkRxgQIiV216daRMkGvqaES4JLJOtjQWB sa6jhBXqZHU0MNHn34xE7PWgc05RVNw4CqgGCue3V9RRWYn7ootB4s3Vwzte O7gM0swaCkccY5w9cA6QUnSZ+J4YOGjSrREk0QG3TzrzuKdLBCbanuQr4Xok 9RvDQlFRBSFbBvWcLSmAINgsYB0nDicUh5sBUwVVy1VSHNz10eRdgLKfOATi HEwGRSHq4xzgoYPhw4cxMomI1Dddp5PK1giTkm3hzJd9bnlZskWDKHRBzwLn A0h7YRwzr0SMW20DSgwbrBjO99cPvO0TkAKnb3AEd+N44H5MvZA+dDACeQOB JgDOVwsOlcAX5JxBEukyzVHbyND+OX0QIPSCigaGl4SaQoiAPGUJCO2Tm5Vw Vj+pb5j5GvuycbKh+vYPTgboPA+vYSx4aW27hRCJj4nlofujcEH6PQgbwlKY mQMMpcRoYQmgIktGkKE0mTOEM7CRGimSV/Hk0FycWVsWnGZaMwQahYB0pGo1 g+74no4SfUCqmTtegPsTTkear3ge4F6jEVIBQUsgfLJ2DfpPDCYqIPSYMYca ijQn0S4QMyQQwd1WOYvtkM+/YtTMAjFD2moL+F6w+7NNwIVRUqgegHBTlftZ LueEhUWnRiVrBO2qINAJieTwJOSPNkpeHy3SWkOzTR0JJJeUQUPGiUoLmHhJ wmxvy3CQiHvbcpqF485xNA+d3ZaCgApD9Upzxx2Ka1iJmjknJL2VvgHIbOQO L+82ephKK420TiLgmhiJmkkN6EdW80TLGyxO8PE7UlMDFl92/QnugDZQ4VVV GxhMPn0BsqCeXFwQEOfAV7GPdVHygC4ybK3BCDpKYyR8XHqENLmRtWdXYOD1 TxWAZhSV2SW/Vk+Pm7QkmIwjNwcHqFyUtDXGpyZU22aegIglx1nD6DRomCKK od0fMh6oXl5/P9hWRwoHMSskIQOQoKStfh+TKXptKP0JgAt3Do9SiKUz4Q1O Q6Lv2SLvpvViYJOHMnEABlA0IeCAAfSQAQt2Gy4cwofzgEC0NkQ1XaGpAjOh k2ij0OBibRv3+CHPDE1DEfTKBjAahnl+TSCfIk3ShCbzMfbZBKFEKSBDUiHp YBOLCHGUDaFioTIQ8iOUrtEJv+nEOKbAm6BXTJ5yBRw4j9WB8USIKk/GEJCb D4FHb3cCIp9/aj/QvIY5eAf1h5ikSX+4w5R4I7F/PicByXmH8FesR7vB+RvR X8YBD9erA60QA2agXooAHnlAyFKA++BPqR6e5uztLRoFGEYJou4cukOSUAcD STicRYmkZYiSMDHGQJSgPP6ur2nWqUYfqm46oT7xTw5FIEe9D5IZDAf5SEIh iGJiVEChQKVcI+IIpP3q931J619HMBQ2QV2CaIuMoOHFTnMEEwylF5KzIWym QJkSAAjs/Ij4lUtgYGIA+Z/ISIv8h0nDmQ/wgUMU88mX5Nev0hsIPfCq/1Es wIJgr/HeJ+eEOP6QxU9FrkmASXV7zEoAp6WyBzT0w0DvdqTsMNaT8Eg/ocwa GuLURg/Q7COCMDCGxg8B71+RBgaGhmobAnqg7h7yMIejYVEyqg8oEfanUeu3 s4bAgIGwIG0JWx+gusW2YOD7nupUqDJUCeFeXlAXw9IxgIjC2H1MJuakjQmw D8f1fFT5IxC6RgjEvQRz37qwU4jfog8D0iIB64BVMPH4n0iTEUBI+z0dY4mF AUB/RxoluMmCgr+C3MIpYw6oLbUJezg358phg7JZo6J/Y/BPzFiqgGuQnKEq rE46AIFAbImaBBv1PgL8B8pJgYy+xyJB/h/7DZJAh8qf2cGgln50FfgAUjvJ OovmvabgYQNc8G3duy4ph9Ic3E+HvAySeYsYrQHAnIShP0mKLZcpGmgIpEH6 /MOEE6keasqYMOJwQ+v+nc7u89DFHaaRarHRpnSBm4F2QczfRAoBsRvGXwNF MiFhATRKCCXZap+FlNkA+caF27B6pfBU+HePoBJoUh+FSmyBUXMDHTEzqkSv dyR7eRRXkm1jtYjOCC2Uw3tfjSfrKgo+kb625zmFMSfvffampum5VQ4y+UxJ jxyAQS2EIlb8/PAGsVkQSEBZD+6snSFInByaYF/nZRCNtBP3875K8t1DQlLg bTy5/wcOgByDbqGDhEOdAPS5KSEWvMlq1Lh9DdDikEhERDDEMBBAedM31J/o ZrQRrU0UsKCgxDKSIaAfyHHhH904KEhtAmu96SztVmlJNiXmSzOuMoBLCAEI P4QOJ4iVifWK6dXoYDu8ZvCn4mtTWspkmGZVAiokGKCiSEBZTbCH1QCxyCj+ s+E1HeXBC3McCupntAJVVOWgoKCj9Ke+vDpBkkMQBEmFI8IhMjjAZMLIcDIg IfwSKft+gOU9H90g4TRH+MrpAvWviAYbgj+SOF1D5dtKAWif1T6RvnWPtHHi KA9wfiRNFfTAHKRQMhAKADeecDddoegwIaSBN3rkxWFOyReJJwuvni7EieyG Q8L+RZz7yhNIAnEZ48YkHoD+mC4AekETjBWou6QeAJzoXYOA+5J2oY7AOokD IyWIYxHiHfhyjxRLL82YbptlOidAojZRdAOl9yfYn+wPveN/X28JA1yiV0ig eo18tsSA4YwRgqUAeKRBbxeklBvvDZd1wnkRiSEHH1XDayMkM/Xk6YLUmJ+B NFUkhNUj8ASA0wlAhzpDiCv+xAYOyCHUgIHU3MB9pGPdnbB88HxgOgCP+KAG gU4kENPcTseTQd6cErGjRHuDahXsgjwIKCgFAN0i9YlJCuoV6w+0gvC5hgMu /6+4dQmQijym848lRYD0xZtgEMyCgkSAiqEIznyE5vAY0HCtnIQkkfRErrSl WYCqegE0AvNDQrc5DyEzBbYmxaq1xt5LJwkkJOkrNVhIV2jfTNlQgcldo5cu aT0Zkf+Yh/AsEZCMYH3p0nwThzu+OMzwsLDouWVIW23jjbgckImZnHhTSTSJ JltHZgOQ3F8McZTxcTlSVbqLZxXiORwEKwFbrUIEZmF4y8YbjVzAOyxWTJSY p8DJBlMNwgfUsJBToU5L366Po6w7LuQ5rvRd6ZE2oMjGCBpgt6IIGBdjlM4g gB9EMjcvKooIBMkfsaSirROm63EdcvGpybUYNbOYU6yMJzybZ7dLbuNg2jqk ec7LFrTg1cp0cwHCh25HSj0tTCVHIYgV56mttvkwxYPGOu1tYLCLCaw6HHkg xaXJrhHVoKtReDq2YYM0YMIFHA9sozniPENw33XJhg8Dc8wAlwReQHjBNBMh epxyQwgP1aTGkiCIfGU2EH4bBiitlElCSh/aU0hOz27JZliFH6r0DD3gHV6v qVFMI9inaACf4wUBCEF1SxVTvQ0ShPH1PoAmdf0a68KLp+CiH2xQrxOwCiyG oT7fOk/BPlS/IWwSoCW4ZTQlsRiFKi/mgPlbMKUgEogxBQiSyLdJUmDJ0XTK wC0qSQkKxU0RREUQwIxCTJIVITAwBCsREcMXBlFNEKxKbSIgfwFu7pgbQq6O 7zGk0RCJAXdsmgYP+wmAEAkp+DLwJoGIB7IOrtSE20ZBDfdWWH85DSZLXa3L K3hjbBFGFGepHEVCNAR2AdDSPcrgKJC9YNAuRCIKCAAppGUUpYDMPepzi+db /enPLsBwhfLu1mD2h5d5dJOHIelQv9SO+o8YhivVAYQDKBGwLC1ZFKgl94OE cAJlsMxHQpSbGVTie46NvN16EQxeGNPITkIaUNHBLkpLA2M4YOTT6+Cei4SU CpTTLsW6X6PUd17odb3cPj7BcK6/y4nOFCQOKJqwFKHjoYLhcPCd9z/v7sKD olCHwC2DGSgD/6wp8pAgIKA/4i7kinChIe/rFag= --Apple-Mail=_963CE16A-0532-4AC0-AE2E-5E40C23779D4--