From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 18426 invoked by alias); 8 Dec 2010 14:59:06 -0000 Received: (qmail 18401 invoked by uid 22791); 8 Dec 2010 14:58:58 -0000 X-SWARE-Spam-Status: No, hits=-1.8 required=5.0 tests=AWL,BAYES_00,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (38.113.113.100) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 08 Dec 2010 14:58:43 +0000 Received: (qmail 3628 invoked from network); 8 Dec 2010 14:58:36 -0000 Received: from unknown (HELO codesourcery.com) (froydnj@127.0.0.2) by mail.codesourcery.com with ESMTPA; 8 Dec 2010 14:58:36 -0000 Date: Wed, 08 Dec 2010 15:13:00 -0000 From: Nathan Froyd To: Jason Merrill Cc: gcc-patches@gcc.gnu.org, mark@codesourcery.com, aaw@gcc.gnu.org Subject: Re: [RFC,c++] fix PR 45329, provide information on overload resolution Message-ID: <20101208145831.GX25904@nightcrawler> References: <20101117204631.GE24469@nightcrawler> <4CE6FD56.1080800@redhat.com> <20101202220946.GH18963@nightcrawler> <4CF921F9.9070700@redhat.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="dDRMvlgZJXvWKvBx" Content-Disposition: inline In-Reply-To: <4CF921F9.9070700@redhat.com> User-Agent: Mutt/1.5.20 (2009-06-14) X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org X-SW-Source: 2010-12/txt/msg00665.txt.bz2 --dDRMvlgZJXvWKvBx Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-length: 35150 On Fri, Dec 03, 2010 at 11:59:37AM -0500, Jason Merrill wrote: > On 12/02/2010 05:09 PM, Nathan Froyd wrote: > >When you say "indented", do you mean like this: > > > >pr45329.C: In function 'int foo2(int)': > >pr45329.C:26:7: error: no matching function for call to 'foo(int&)' > >pr45329.C:26:7: note: candidates are: > >pr45329.C:7:5: note: int foo(int, int) > >pr45329.C:7:5: note: candidate expects 2 arguments, 1 provided > >pr45329.C:19:5: note: int foo(const S&) > >pr45329.C:19:5: note: no known conversion for argument 1 from 'int' to 'const S&' > > Yep. OK, thanks. A revised patch is below, with testsuite modifications. The changes are mainly due to examining testsuite output; previous revisions had off-by-one errors when pointing out arguments in some cases or had unusual location information. The testsuite modifications are large and relatively boring; I've attached the compressed diff to gcc/testsuite and just included the cp/ changes below. I looked at the comments in the PR; I think the indentation addresses structuring of the list of candidates and I think printing the candidate and reason separately is more appropriate (and slightly more structured). Someday when diagnostic formatting is separated into its own program, people can write their own formatters... Tested on x86_64-unknown-linux-gnu. OK to commit? -Nathan gcc/cp/ PR c++/45329 * call.c (struct conversion): Document bad_p field. (enum rejection_reason_code): Define. (struct conversion_info): Define. (struct rejection_reason): Define. (struct z_candidate): Add `reason' field. (add_candidate): Add `reason' parameter. Store it in CAND. (alloc_rejection, arity_rejection, arg_conversion_rejection): New functions. (bad_arg_conversion_rejection): New function. (convert_class_to_reference): Add comment. (remaining_arguments): New function. (add_function_candidate): Record rejection reason and pass it to add_candidate. (add_conv_candidate, build_builtin_candidate): Likewise. (add_template_candidate_real): Likewise. (print_conversion_rejection): New function. (print_z_candidate): Print CAND->REASON if it exists. Adjust diagnostic strings. (print_z_candidates): Add location_t argument. Adjust calling sequence for print_z_candidate. Print header line directly. (build_user_type_conversion_1): Add reason for rejection to CAND. Adjust call to print_z_candidates. (print_error_for_call_failure): New function. (build_new_function_call): Call it. Adjust call to print_z_candidates. (build_operator_new_call): Likewise. (build_op_call): Likewise. (build_conditional_expr): Likewise. (build_new_op): Likewise. (build_new_method_call): Likewise. gcc/testsuite/ * testsuite/g++.dg/conversion/ambig1.C: Adjust. * testsuite/g++.dg/conversion/op1.C: Adjust. * testsuite/g++.dg/conversion/simd1.C: Adjust. * testsuite/g++.dg/cpp0x/defaulted14.C: Adjust. * testsuite/g++.dg/cpp0x/defaulted18.C: Adjust. * testsuite/g++.dg/cpp0x/defaulted20.C: Adjust. * testsuite/g++.dg/cpp0x/explicit3.C: Adjust. * testsuite/g++.dg/cpp0x/explicit4.C: Adjust. * testsuite/g++.dg/cpp0x/implicit4.C: Adjust. * testsuite/g++.dg/cpp0x/nullptr15.C: Adjust. * testsuite/g++.dg/cpp0x/nullptr19.C: Adjust. * testsuite/g++.dg/cpp0x/pr31431-2.C: Adjust. * testsuite/g++.dg/cpp0x/pr31431.C: Adjust. * testsuite/g++.dg/cpp0x/pr31434.C: Adjust. * testsuite/g++.dg/cpp0x/pr31437.C: Adjust. * testsuite/g++.dg/cpp0x/rv2n.C: Adjust. * testsuite/g++.dg/cpp0x/rv3n.C: Adjust. * testsuite/g++.dg/cpp0x/rv4n.C: Adjust. * testsuite/g++.dg/cpp0x/rv5n.C: Adjust. * testsuite/g++.dg/cpp0x/rv6n.C: Adjust. * testsuite/g++.dg/cpp0x/rv7n.C: Adjust. * testsuite/g++.dg/cpp0x/temp_default2.C: Adjust. * testsuite/g++.dg/cpp0x/trailing4.C: Adjust. * testsuite/g++.dg/cpp0x/variadic-ex3.C: Adjust. * testsuite/g++.dg/cpp0x/variadic-ex4.C: Adjust. * testsuite/g++.dg/cpp0x/variadic35.C: Adjust. * testsuite/g++.dg/cpp0x/vt-35147.C: Adjust. * testsuite/g++.dg/cpp0x/vt-37737-2.C: Adjust. * testsuite/g++.dg/expr/cond9.C: Adjust. * testsuite/g++.dg/expr/pmf-1.C: Adjust. * testsuite/g++.dg/ext/label5.C: Adjust. * testsuite/g++.dg/ext/visibility/anon8.C: Adjust. * testsuite/g++.dg/ext/vla2.C: Adjust. * testsuite/g++.dg/gomp/pr26690-1.C: Adjust. * testsuite/g++.dg/gomp/pr26690-2.C: Adjust. * testsuite/g++.dg/init/synth2.C: Adjust. * testsuite/g++.dg/lookup/conv-1.C: Adjust. * testsuite/g++.dg/lookup/new1.C: Adjust. * testsuite/g++.dg/lookup/using9.C: Adjust. * testsuite/g++.dg/other/error13.C: Adjust. * testsuite/g++.dg/other/error20.C: Adjust. * testsuite/g++.dg/other/error31.C: Adjust. * testsuite/g++.dg/other/pr28114.C: Adjust. * testsuite/g++.dg/other/ptrmem10.C: Adjust. * testsuite/g++.dg/other/ptrmem11.C: Adjust. * testsuite/g++.dg/overload/ambig1.C: Adjust. * testsuite/g++.dg/overload/arg3.C: Adjust. * testsuite/g++.dg/overload/builtin1.C: Adjust. * testsuite/g++.dg/overload/copy1.C: Adjust. * testsuite/g++.dg/overload/new1.C: Adjust. * testsuite/g++.dg/overload/template4.C: Adjust. * testsuite/g++.dg/overload/unknown1.C: Adjust. * testsuite/g++.dg/overload/using2.C: Adjust. * testsuite/g++.dg/parse/crash5.C: Adjust. * testsuite/g++.dg/parse/error19.C: Adjust. * testsuite/g++.dg/parse/error28.C: Adjust. * testsuite/g++.dg/parse/template7.C: Adjust. * testsuite/g++.dg/parse/typename7.C: Adjust. * testsuite/g++.dg/rtti/typeid6.C: Adjust. * testsuite/g++.dg/tc1/dr152.C: Adjust. * testsuite/g++.dg/template/conv11.C: Adjust. * testsuite/g++.dg/template/copy1.C: Adjust. * testsuite/g++.dg/template/crash37.C: Adjust. * testsuite/g++.dg/template/deduce3.C: Adjust. * testsuite/g++.dg/template/dependent-expr5.C: Adjust. * testsuite/g++.dg/template/error38.C: Adjust. * testsuite/g++.dg/template/error40.C: Adjust. * testsuite/g++.dg/template/friend.C: Adjust. * testsuite/g++.dg/template/incomplete2.C: Adjust. * testsuite/g++.dg/template/instantiate5.C: Adjust. * testsuite/g++.dg/template/local4.C: Adjust. * testsuite/g++.dg/template/local6.C: Adjust. * testsuite/g++.dg/template/new3.C: Adjust. * testsuite/g++.dg/template/operator9.C: Adjust. * testsuite/g++.dg/template/overload6.C: Adjust. * testsuite/g++.dg/template/ptrmem2.C: Adjust. * testsuite/g++.dg/template/ptrmem20.C: Adjust. * testsuite/g++.dg/template/ptrmem4.C: Adjust. * testsuite/g++.dg/template/ptrmem8.C: Adjust. * testsuite/g++.dg/template/qualttp5.C: Adjust. * testsuite/g++.dg/template/sfinae2.C: Adjust. * testsuite/g++.dg/template/spec22.C: Adjust. * testsuite/g++.dg/template/spec23.C: Adjust. * testsuite/g++.dg/template/ttp25.C: Adjust. * testsuite/g++.dg/template/typedef4.C: Adjust. * testsuite/g++.dg/template/unify10.C: Adjust. * testsuite/g++.dg/template/unify11.C: Adjust. * testsuite/g++.dg/template/unify6.C: Adjust. * testsuite/g++.dg/template/unify7.C: Adjust. * testsuite/g++.dg/template/unify9.C: Adjust. * testsuite/g++.dg/template/varmod1.C: Adjust. * testsuite/g++.old-deja/g++.benjamin/15799.C: Adjust. * testsuite/g++.old-deja/g++.benjamin/15800-1.C: Adjust. * testsuite/g++.old-deja/g++.brendan/ambiguity1.C: Adjust. * testsuite/g++.old-deja/g++.brendan/crash29.C: Adjust. * testsuite/g++.old-deja/g++.brendan/crash48.C: Adjust. * testsuite/g++.old-deja/g++.brendan/crash56.C: Adjust. * testsuite/g++.old-deja/g++.brendan/cvt3.C: Adjust. * testsuite/g++.old-deja/g++.brendan/overload1.C: Adjust. * testsuite/g++.old-deja/g++.brendan/overload4.C: Adjust. * testsuite/g++.old-deja/g++.brendan/overload9.C: Adjust. * testsuite/g++.old-deja/g++.bugs/900127_01.C: Adjust. * testsuite/g++.old-deja/g++.bugs/900205_04.C: Adjust. * testsuite/g++.old-deja/g++.bugs/900330_02.C: Adjust. * testsuite/g++.old-deja/g++.bugs/900404_03.C: Adjust. * testsuite/g++.old-deja/g++.bugs/900514_03.C: Adjust. * testsuite/g++.old-deja/g++.eh/ctor1.C: Adjust. * testsuite/g++.old-deja/g++.jason/conversion11.C: Adjust. * testsuite/g++.old-deja/g++.jason/crash3.C: Adjust. * testsuite/g++.old-deja/g++.jason/overload16.C: Adjust. * testsuite/g++.old-deja/g++.jason/overload28.C: Adjust. * testsuite/g++.old-deja/g++.jason/scoping10.C: Adjust. * testsuite/g++.old-deja/g++.jason/template30.C: Adjust. * testsuite/g++.old-deja/g++.jason/temporary2.C: Adjust. * testsuite/g++.old-deja/g++.law/arg1.C: Adjust. * testsuite/g++.old-deja/g++.law/arg11.C: Adjust. * testsuite/g++.old-deja/g++.law/arm9.C: Adjust. * testsuite/g++.old-deja/g++.law/ctors11.C: Adjust. * testsuite/g++.old-deja/g++.law/ctors17.C: Adjust. * testsuite/g++.old-deja/g++.law/ctors5.C: Adjust. * testsuite/g++.old-deja/g++.law/ctors9.C: Adjust. * testsuite/g++.old-deja/g++.law/enum4.C: Adjust. * testsuite/g++.old-deja/g++.law/missed-error2.C: Adjust. * testsuite/g++.old-deja/g++.law/operators32.C: Adjust. * testsuite/g++.old-deja/g++.law/operators9.C: Adjust. * testsuite/g++.old-deja/g++.mike/net2.C: Adjust. * testsuite/g++.old-deja/g++.mike/net22.C: Adjust. * testsuite/g++.old-deja/g++.mike/p11110.C: Adjust. * testsuite/g++.old-deja/g++.mike/p1989.C: Adjust. * testsuite/g++.old-deja/g++.mike/p2431.C: Adjust. * testsuite/g++.old-deja/g++.mike/p438.C: Adjust. * testsuite/g++.old-deja/g++.mike/p807a.C: Adjust. * testsuite/g++.old-deja/g++.mike/p9068.C: Adjust. * testsuite/g++.old-deja/g++.niklas/t120.C: Adjust. * testsuite/g++.old-deja/g++.niklas/t121.C: Adjust. * testsuite/g++.old-deja/g++.niklas/t128.C: Adjust. * testsuite/g++.old-deja/g++.ns/overload2.C: Adjust. * testsuite/g++.old-deja/g++.ns/using12.C: Adjust. * testsuite/g++.old-deja/g++.other/crash24.C: Adjust. * testsuite/g++.old-deja/g++.other/expr1.C: Adjust. * testsuite/g++.old-deja/g++.other/overload11.C: Adjust. * testsuite/g++.old-deja/g++.other/pmf3.C: Adjust. * testsuite/g++.old-deja/g++.other/volatile1.C: Adjust. * testsuite/g++.old-deja/g++.pt/auto_ptr.C: Adjust. * testsuite/g++.old-deja/g++.pt/crash28.C: Adjust. * testsuite/g++.old-deja/g++.pt/crash60.C: Adjust. * testsuite/g++.old-deja/g++.pt/explicit38.C: Adjust. * testsuite/g++.old-deja/g++.pt/explicit39.C: Adjust. * testsuite/g++.old-deja/g++.pt/explicit41.C: Adjust. * testsuite/g++.old-deja/g++.pt/explicit67.C: Adjust. * testsuite/g++.old-deja/g++.pt/explicit77.C: Adjust. * testsuite/g++.old-deja/g++.pt/expr2.C: Adjust. * testsuite/g++.old-deja/g++.pt/ptrmem10.C: Adjust. * testsuite/g++.old-deja/g++.pt/ptrmem6.C: Adjust. * testsuite/g++.old-deja/g++.pt/spec35.C: Adjust. * testsuite/g++.old-deja/g++.pt/spec5.C: Adjust. * testsuite/g++.old-deja/g++.pt/spec6.C: Adjust. * testsuite/g++.old-deja/g++.pt/t05.C: Adjust. * testsuite/g++.old-deja/g++.pt/t24.C: Adjust. * testsuite/g++.old-deja/g++.pt/unify4.C: Adjust. * testsuite/g++.old-deja/g++.pt/unify6.C: Adjust. * testsuite/g++.old-deja/g++.pt/unify8.C: Adjust. * testsuite/g++.old-deja/g++.robertl/eb109.C: Adjust. * testsuite/g++.old-deja/g++.robertl/eb119.C: Adjust. * testsuite/g++.old-deja/g++.robertl/eb131.C: Adjust. * testsuite/g++.old-deja/g++.robertl/eb22.C: Adjust. * testsuite/g++.old-deja/g++.robertl/eb69.C: Adjust. * testsuite/g++.old-deja/g++.robertl/eb98.C: Adjust. diff --git a/gcc/cp/call.c b/gcc/cp/call.c index d538cf2..a1f596d 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -85,6 +85,9 @@ struct conversion { BOOL_BITFIELD user_conv_p : 1; BOOL_BITFIELD ellipsis_p : 1; BOOL_BITFIELD this_p : 1; + /* True if this conversion would be permitted with a bending of + language standards, e.g. disregarding pointer qualifiers or + converting integers to pointers. */ BOOL_BITFIELD bad_p : 1; /* If KIND is ck_ref_bind ck_base_conv, true to indicate that a temporary should be created to hold the result of the @@ -130,6 +133,7 @@ struct conversion { static struct obstack conversion_obstack; static bool conversion_obstack_initialized; +struct rejection_reason; static struct z_candidate * tourney (struct z_candidate *); static int equal_functions (tree, tree); @@ -152,7 +156,7 @@ static void op_error (enum tree_code, enum tree_code, tree, tree, static VEC(tree,gc) *resolve_args (VEC(tree,gc) *); static struct z_candidate *build_user_type_conversion_1 (tree, tree, int); static void print_z_candidate (const char *, struct z_candidate *); -static void print_z_candidates (struct z_candidate *); +static void print_z_candidates (location_t, struct z_candidate *); static tree build_this (tree); static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *); static bool any_strictly_viable (struct z_candidate *); @@ -191,7 +195,7 @@ static conversion *maybe_handle_ref_bind (conversion **); static void maybe_handle_implicit_object (conversion **); static struct z_candidate *add_candidate (struct z_candidate **, tree, tree, const VEC(tree,gc) *, size_t, - conversion **, tree, tree, int); + conversion **, tree, tree, int, struct rejection_reason *); static tree source_type (conversion *); static void add_warning (struct z_candidate *, struct z_candidate *); static bool reference_compatible_p (tree, tree); @@ -417,6 +421,43 @@ struct candidate_warning { candidate_warning *next; }; +/* Information for providing diagnostics about why overloading failed. */ + +enum rejection_reason_code { + rr_none, + rr_arity, + rr_arg_conversion, + rr_bad_arg_conversion +}; + +struct conversion_info { + /* The index of the argument, 0-based. */ + int n_arg; + /* The type of the actual argument. */ + tree from_type; + /* The type of the formal argument. */ + tree to_type; +}; + +struct rejection_reason { + enum rejection_reason_code code; + union { + /* Information about an arity mismatch. */ + struct { + /* The expected number of arguments. */ + int expected; + /* The actual number of arguments in the call. */ + int actual; + /* Whether the call was a varargs call. */ + bool call_varargs_p; + } arity; + /* Information about an argument conversion mismatch. */ + struct conversion_info conversion; + /* Same, but for bad argument conversions. */ + struct conversion_info bad_conversion; + } u; +}; + struct z_candidate { /* The FUNCTION_DECL that will be called if this candidate is selected by overload resolution. */ @@ -438,6 +479,7 @@ struct z_candidate { type. */ conversion *second_conv; int viable; + struct rejection_reason *reason; /* If FN is a member function, the binfo indicating the path used to qualify the name of FN at the call site. This path is used to determine whether or not FN is accessible if it is selected by @@ -519,6 +561,49 @@ conversion_obstack_alloc (size_t n) return p; } +/* Allocate rejection reasons. */ + +static struct rejection_reason * +alloc_rejection (enum rejection_reason_code code) +{ + struct rejection_reason *p; + p = (struct rejection_reason *) conversion_obstack_alloc (sizeof *p); + p->code = code; + return p; +} + +static struct rejection_reason * +arity_rejection (tree first_arg, int expected, int actual) +{ + struct rejection_reason *r = alloc_rejection (rr_arity); + int adjust = first_arg != NULL_TREE; + r->u.arity.expected = expected - adjust; + r->u.arity.actual = actual - adjust; + return r; +} + +static struct rejection_reason * +arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to) +{ + struct rejection_reason *r = alloc_rejection (rr_arg_conversion); + int adjust = first_arg != NULL_TREE; + r->u.conversion.n_arg = n_arg - adjust; + r->u.conversion.from_type = from; + r->u.conversion.to_type = to; + return r; +} + +static struct rejection_reason * +bad_arg_conversion_rejection (tree first_arg, int n_arg, tree from, tree to) +{ + struct rejection_reason *r = alloc_rejection (rr_bad_arg_conversion); + int adjust = first_arg != NULL_TREE; + r->u.bad_conversion.n_arg = n_arg - adjust; + r->u.bad_conversion.from_type = from; + r->u.bad_conversion.to_type = to; + return r; +} + /* Dynamically allocate a conversion. */ static conversion * @@ -1148,6 +1233,10 @@ convert_class_to_reference (tree reference_type, tree s, tree expr, int flags) if (TREE_CODE (t2) != REFERENCE_TYPE || !reference_compatible_p (t, TREE_TYPE (t2))) { + /* No need to set cand->reason here; this is most likely + an ambiguous match. If it's not, either this candidate + will win, or we will have identified a reason for it + losing already. */ cand->viable = 0; } else @@ -1558,7 +1647,7 @@ add_candidate (struct z_candidate **candidates, tree fn, tree first_arg, const VEC(tree,gc) *args, size_t num_convs, conversion **convs, tree access_path, tree conversion_path, - int viable) + int viable, struct rejection_reason *reason) { struct z_candidate *cand = (struct z_candidate *) conversion_obstack_alloc (sizeof (struct z_candidate)); @@ -1571,12 +1660,28 @@ add_candidate (struct z_candidate **candidates, cand->access_path = access_path; cand->conversion_path = conversion_path; cand->viable = viable; + cand->reason = reason; cand->next = *candidates; *candidates = cand; return cand; } +/* Return the number of remaining arguments in the parameter list + beginning with ARG. */ + +static int +remaining_arguments (tree arg) +{ + int n; + + for (n = 0; arg != NULL_TREE && arg != void_list_node; + arg = TREE_CHAIN (arg)) + n++; + + return n; +} + /* Create an overload candidate for the function or method FN called with the argument list FIRST_ARG/ARGS and add it to CANDIDATES. FLAGS is passed on to implicit_conversion. @@ -1599,6 +1704,7 @@ add_function_candidate (struct z_candidate **candidates, tree orig_first_arg = first_arg; int skip; int viable = 1; + struct rejection_reason *reason = NULL; /* At this point we should not see any functions which haven't been explicitly declared, except for friend functions which will have @@ -1638,13 +1744,14 @@ add_function_candidate (struct z_candidate **candidates, parmnode = TREE_CHAIN (parmnode); } - if (i < len && parmnode) - viable = 0; - - /* Make sure there are default args for the rest of the parms. */ - else if (!sufficient_parms_p (parmnode)) - viable = 0; - + if ((i < len && parmnode) + /* Make sure there are default args for the rest of the parms. */ + || !sufficient_parms_p (parmnode)) + { + int remaining = remaining_arguments (parmnode); + viable = 0; + reason = arity_rejection (first_arg, i + remaining, len); + } /* Kludge: When looking for a function from a subobject while generating an implicit copy/move constructor/operator=, don't consider anything that takes (a reference to) an unrelated type. See c++/44909. */ @@ -1680,7 +1787,7 @@ add_function_candidate (struct z_candidate **candidates, for (i = 0; i < len; ++i) { - tree arg, argtype; + tree arg, argtype, to_type; conversion *t; int is_this; @@ -1747,11 +1854,13 @@ add_function_candidate (struct z_candidate **candidates, t = implicit_conversion (parmtype, argtype, arg, /*c_cast_p=*/false, lflags); + to_type = parmtype; } else { t = build_identity_conv (argtype, arg); t->ellipsis_p = true; + to_type = argtype; } if (t && is_this) @@ -1761,16 +1870,20 @@ add_function_candidate (struct z_candidate **candidates, if (! t) { viable = 0; + reason = arg_conversion_rejection (first_arg, i, argtype, to_type); break; } if (t->bad_p) - viable = -1; + { + viable = -1; + reason = bad_arg_conversion_rejection (first_arg, i, argtype, to_type); + } } out: return add_candidate (candidates, fn, orig_first_arg, args, len, convs, - access_path, conversion_path, viable); + access_path, conversion_path, viable, reason); } /* Create an overload candidate for the conversion function FN which will @@ -1794,6 +1907,7 @@ add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj, int i, len, viable, flags; tree parmlist, parmnode; conversion **convs; + struct rejection_reason *reason; for (parmlist = totype; TREE_CODE (parmlist) != FUNCTION_TYPE; ) parmlist = TREE_TYPE (parmlist); @@ -1804,6 +1918,7 @@ add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj, parmnode = parmlist; viable = 1; flags = LOOKUP_IMPLICIT; + reason = NULL; /* Don't bother looking up the same type twice. */ if (*candidates && (*candidates)->fn == totype) @@ -1811,7 +1926,7 @@ add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj, for (i = 0; i < len; ++i) { - tree arg, argtype; + tree arg, argtype, convert_type = NULL_TREE; conversion *t; if (i == 0) @@ -1824,17 +1939,24 @@ add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj, argtype = lvalue_type (arg); if (i == 0) - t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false, - flags); + { + t = implicit_conversion (totype, argtype, arg, /*c_cast_p=*/false, + flags); + convert_type = totype; + } else if (parmnode == void_list_node) break; else if (parmnode) - t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, - /*c_cast_p=*/false, flags); + { + t = implicit_conversion (TREE_VALUE (parmnode), argtype, arg, + /*c_cast_p=*/false, flags); + convert_type = TREE_VALUE (parmnode); + } else { t = build_identity_conv (argtype, arg); t->ellipsis_p = true; + convert_type = argtype; } convs[i] = t; @@ -1842,7 +1964,10 @@ add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj, break; if (t->bad_p) - viable = -1; + { + viable = -1; + reason = bad_arg_conversion_rejection (NULL_TREE, i, argtype, convert_type); + } if (i == 0) continue; @@ -1851,14 +1976,16 @@ add_conv_candidate (struct z_candidate **candidates, tree fn, tree obj, parmnode = TREE_CHAIN (parmnode); } - if (i < len) - viable = 0; - - if (!sufficient_parms_p (parmnode)) - viable = 0; + if (i < len + || ! sufficient_parms_p (parmnode)) + { + int remaining = remaining_arguments (parmnode); + viable = 0; + reason = arity_rejection (NULL_TREE, i + remaining, len); + } return add_candidate (candidates, totype, first_arg, arglist, len, convs, - access_path, conversion_path, viable); + access_path, conversion_path, viable, reason); } static void @@ -1871,6 +1998,7 @@ build_builtin_candidate (struct z_candidate **candidates, tree fnname, size_t num_convs; int viable = 1, i; tree types[2]; + struct rejection_reason *reason = NULL; types[0] = type1; types[1] = type2; @@ -1898,9 +2026,13 @@ build_builtin_candidate (struct z_candidate **candidates, tree fnname, viable = 0; /* We need something for printing the candidate. */ t = build_identity_conv (types[i], NULL_TREE); + reason = arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]); } else if (t->bad_p) - viable = 0; + { + viable = 0; + reason = bad_arg_conversion_rejection (NULL_TREE, i, argtypes[i], types[i]); + } convs[i] = t; } @@ -1914,14 +2046,18 @@ build_builtin_candidate (struct z_candidate **candidates, tree fnname, if (t) convs[0] = t; else - viable = 0; + { + viable = 0; + reason = arg_conversion_rejection (NULL_TREE, 0, argtypes[2], + boolean_type_node); + } } add_candidate (candidates, fnname, /*first_arg=*/NULL_TREE, /*args=*/NULL, num_convs, convs, /*access_path=*/NULL_TREE, /*conversion_path=*/NULL_TREE, - viable); + viable, reason); } static bool @@ -2573,6 +2709,7 @@ add_template_candidate_real (struct z_candidate **candidates, tree tmpl, struct z_candidate *cand; int i; tree fn; + struct rejection_reason *reason = NULL; /* We don't do deduction on the in-charge parameter, the VTT parameter or 'this'. */ @@ -2691,7 +2828,7 @@ add_template_candidate_real (struct z_candidate **candidates, tree tmpl, return cand; fail: return add_candidate (candidates, tmpl, first_arg, arglist, nargs, NULL, - access_path, conversion_path, 0); + access_path, conversion_path, 0, reason); } @@ -2802,6 +2939,20 @@ equal_functions (tree fn1, tree fn2) return fn1 == fn2; } +/* Print information about a candidate being rejected due to INFO. */ + +static void +print_conversion_rejection (location_t loc, struct conversion_info *info) +{ + if (info->n_arg == -1) + /* Conversion of implicit `this' argument failed. */ + inform (loc, "no known conversion for implicit % parameter from %qT to %qT", + info->from_type, info->to_type); + else + inform (loc, "no known conversion for argument %d from %qT to %qT", + info->n_arg+1, info->from_type, info->to_type); +} + /* Print information about one overload candidate CANDIDATE. MSGSTR is the text to print before the candidate itself. @@ -2812,38 +2963,68 @@ equal_functions (tree fn1, tree fn2) static void print_z_candidate (const char *msgstr, struct z_candidate *candidate) { + const char *msg = (msgstr == NULL + ? "" + : ACONCAT ((msgstr, " ", NULL))); + location_t loc = location_of (candidate->fn); + if (TREE_CODE (candidate->fn) == IDENTIFIER_NODE) { if (candidate->num_convs == 3) - inform (input_location, "%s %D(%T, %T, %T) ", msgstr, candidate->fn, + inform (input_location, "%s%D(%T, %T, %T) ", msg, candidate->fn, candidate->convs[0]->type, candidate->convs[1]->type, candidate->convs[2]->type); else if (candidate->num_convs == 2) - inform (input_location, "%s %D(%T, %T) ", msgstr, candidate->fn, + inform (input_location, "%s%D(%T, %T) ", msg, candidate->fn, candidate->convs[0]->type, candidate->convs[1]->type); else - inform (input_location, "%s %D(%T) ", msgstr, candidate->fn, + inform (input_location, "%s%D(%T) ", msg, candidate->fn, candidate->convs[0]->type); } else if (TYPE_P (candidate->fn)) - inform (input_location, "%s %T ", msgstr, candidate->fn); + inform (input_location, "%s%T ", msg, candidate->fn); else if (candidate->viable == -1) - inform (input_location, "%s %+#D ", msgstr, candidate->fn); + inform (loc, "%s%#D ", msg, candidate->fn); else if (DECL_DELETED_FN (STRIP_TEMPLATE (candidate->fn))) - inform (input_location, "%s %+#D ", msgstr, candidate->fn); + inform (loc, "%s%#D ", msg, candidate->fn); else - inform (input_location, "%s %+#D", msgstr, candidate->fn); + inform (loc, "%s%#D", msg, candidate->fn); + /* Give the user some information about why this candidate failed. */ + if (candidate->reason != NULL) + { + struct rejection_reason *r = candidate->reason; + + switch (r->code) + { + case rr_arity: + inform_n (loc, r->u.arity.expected, + " candidate expects %d argument, %d provided", + " candidate expects %d arguments, %d provided", + r->u.arity.expected, r->u.arity.actual); + break; + case rr_arg_conversion: + print_conversion_rejection (loc, &r->u.conversion); + break; + case rr_bad_arg_conversion: + print_conversion_rejection (loc, &r->u.bad_conversion); + break; + case rr_none: + default: + /* This candidate didn't have any issues or we failed to + handle a particular code. Either way... */ + gcc_unreachable (); + } + } } static void -print_z_candidates (struct z_candidate *candidates) +print_z_candidates (location_t loc, struct z_candidate *candidates) { - const char *str; struct z_candidate *cand1; struct z_candidate **cand2; - char *spaces; + int n_candidates; if (!candidates) return; @@ -2885,14 +3066,12 @@ print_z_candidates (struct z_candidate *candidates) } } - str = candidates->next ? _("candidates are:") : _("candidate is:"); - spaces = NULL; + for (n_candidates = 0, cand1 = candidates; cand1; cand1 = cand1->next) + n_candidates++; + + inform_n (loc, n_candidates, "candidate is:", "candidates are:"); for (; candidates; candidates = candidates->next) - { - print_z_candidate (spaces ? spaces : str, candidates); - spaces = spaces ? spaces : get_spaces (str); - } - free (spaces); + print_z_candidate (NULL, candidates); } /* USER_SEQ is a user-defined conversion sequence, beginning with a @@ -3129,9 +3308,20 @@ build_user_type_conversion_1 (tree totype, tree expr, int flags) cand->second_conv = ics; if (!ics) - cand->viable = 0; + { + tree rettype = TREE_TYPE (TREE_TYPE (cand->fn)); + cand->viable = 0; + cand->reason = arg_conversion_rejection (NULL_TREE, -1, + rettype, totype); + } else if (cand->viable == 1 && ics->bad_p) - cand->viable = -1; + { + tree rettype = TREE_TYPE (TREE_TYPE (cand->fn)); + cand->viable = -1; + cand->reason + = bad_arg_conversion_rejection (NULL_TREE, -1, + rettype, totype); + } } } @@ -3146,7 +3336,7 @@ build_user_type_conversion_1 (tree totype, tree expr, int flags) { error ("conversion from %qT to %qT is ambiguous", fromtype, totype); - print_z_candidates (candidates); + print_z_candidates (location_of (expr), candidates); } cand = candidates; /* any one will do */ @@ -3346,6 +3536,28 @@ perform_overload_resolution (tree fn, return cand; } +/* Print an error message about being unable to build a call to FN with + ARGS. ANY_VIABLE_P indicates whether any candidate functions could + be located; CANDIDATES is a possibly empty list of such + functions. */ + +static void +print_error_for_call_failure (tree fn, VEC(tree,gc) *args, bool any_viable_p, + struct z_candidate *candidates) +{ + tree name = DECL_NAME (OVL_CURRENT (fn)); + location_t loc = location_of (name); + + if (!any_viable_p) + error_at (loc, "no matching function for call to %<%D(%A)%>", + name, build_tree_list_vec (args)); + else + error_at (loc, "call of overloaded %<%D(%A)%> is ambiguous", + name, build_tree_list_vec (args)); + if (candidates) + print_z_candidates (loc, candidates); +} + /* Return an expression for a call to FN (a namespace-scope function, or a static member function) with the ARGS. This may change ARGS. */ @@ -3377,9 +3589,7 @@ build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p, if (!fn) { if (complain & tf_error) - error ("no matching function for call to %<%D(%A)%>", - DECL_NAME (OVL_CURRENT (orig_fn)), - build_tree_list_vec (*args)); + print_error_for_call_failure (orig_fn, *args, false, NULL); return error_mark_node; } } @@ -3398,14 +3608,7 @@ build_new_function_call (tree fn, VEC(tree,gc) **args, bool koenig_p, return cp_build_function_call_vec (candidates->fn, args, complain); if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) fn = TREE_OPERAND (fn, 0); - if (!any_viable_p) - error ("no matching function for call to %<%D(%A)%>", - DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args)); - else - error ("call of overloaded %<%D(%A)%> is ambiguous", - DECL_NAME (OVL_CURRENT (fn)), build_tree_list_vec (*args)); - if (candidates) - print_z_candidates (candidates); + print_error_for_call_failure (fn, *args, any_viable_p, candidates); } result = error_mark_node; } @@ -3463,14 +3666,7 @@ build_operator_new_call (tree fnname, VEC(tree,gc) **args, and give up. */ if (!cand) { - if (!any_viable_p) - error ("no matching function for call to %<%D(%A)%>", - DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args)); - else - error ("call of overloaded %<%D(%A)%> is ambiguous", - DECL_NAME (OVL_CURRENT (fns)), build_tree_list_vec (*args)); - if (candidates) - print_z_candidates (candidates); + print_error_for_call_failure (fns, *args, any_viable_p, candidates); return error_mark_node; } @@ -3620,7 +3816,7 @@ build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain) { error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), build_tree_list_vec (*args)); - print_z_candidates (candidates); + print_z_candidates (location_of (TREE_TYPE (obj)), candidates); } result = error_mark_node; } @@ -3633,7 +3829,7 @@ build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain) { error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), build_tree_list_vec (*args)); - print_z_candidates (candidates); + print_z_candidates (location_of (TREE_TYPE (obj)), candidates); } result = error_mark_node; } @@ -4052,7 +4248,7 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3, if (complain & tf_error) { op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE); - print_z_candidates (candidates); + print_z_candidates (location_of (arg1), candidates); } return error_mark_node; } @@ -4062,7 +4258,7 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3, if (complain & tf_error) { op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE); - print_z_candidates (candidates); + print_z_candidates (location_of (arg1), candidates); } return error_mark_node; } @@ -4581,7 +4777,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, /* ... Otherwise, report the more generic "no matching operator found" error */ op_error (code, code2, arg1, arg2, arg3, FALSE); - print_z_candidates (candidates); + print_z_candidates (input_location, candidates); } } result = error_mark_node; @@ -4596,7 +4792,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error)) { op_error (code, code2, arg1, arg2, arg3, TRUE); - print_z_candidates (candidates); + print_z_candidates (input_location, candidates); } result = error_mark_node; } @@ -6656,7 +6852,7 @@ build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args, if (free_p) free (pretty_name); } - print_z_candidates (candidates); + print_z_candidates (location_of (name), candidates); } call = error_mark_node; } @@ -6677,7 +6873,7 @@ build_new_method_call (tree instance, tree fns, VEC(tree,gc) **args, arglist = TREE_CHAIN (arglist); error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name, arglist); - print_z_candidates (candidates); + print_z_candidates (location_of (name), candidates); if (free_p) free (pretty_name); } --dDRMvlgZJXvWKvBx Content-Type: application/octet-stream Content-Disposition: attachment; filename="testsuite-changes.diff.gz" Content-Transfer-Encoding: base64 Content-length: 42062 H4sICPyc/0wAA3Rlc3RzdWl0ZS1jaGFuZ2VzLmRpZmYA5b37d+M2kij8c/uv wO09x5FfahLgU+541+4kc2c289jE2duzSY4PxYetxJY8ktztTqfv3/7hSYIg SAGUxM49X++OY0tA4VVVqCrUI5sVBTg7u52tQfLqNk1frfPVevU0W+evbk9O xtntq3Qxf5cvV7PF/FXyMJ3duuM3YGrc9GA2z/Jn4GZTNwjC8Tjy88TNIHAd J/C8g7OzM4txD05OTmzG/o//AGfBKQInwakH8B+r9fIpXYP/DT4egE/nB+AA zOZrgHuu1odgmRfgS/C/R0fn4NUr8BFkt2f5crlYgpcU3tPiafUSfDo4EV8+ 5KtVcpuDl2kyz2ZZss5fSr+D+YJ88BGsk+VtvgbHZ/j/wCcQYRCZzZ4vHs02 nLbjux340xj6yXicOwnK/cJutxkks61mbck+u6euA07wTxfv9AFI75PVCrw5 IFsNwDp/eLzHu/J6/eExnycPOfjhAhycAbB4zJfJGm/yD3jfX7x40bW5eO8N OrB9/yQfcDEHozcgPcJ/fgRkOst8/bScgzeTSQmuuF8k61HaPPx6i/EbPo/t sCCmE7RDhNXsITNDBd6SI4MfTPOg8MbjIvGcqZPbIYOAZYYOojVBCP80Aifk B0GHA/BvWV7M5jl4l6dkN29ukvV6OZs+rfObm9GIfXqzmv2Wj9zg6OgIdznj TVez23me0ZN8d5+BEfklcU8Z3YJmo+MEHuEt54eM/zrHO/7qWDkvDAofJTh+ pY6zulssDUZizWzHOtn3mn6fL8Cv88X7OaiORT/2ftbZMT5Ggvx5neP+ZLzZ efmndl6r1TnjK+FpgPlKeBoSDs57dEw0xT0fMex3i1kGisUCjI44E8JfYAaP 5zianeI/0kdM7PyfWAmnebyGh2Sd3s3mt6B4mqdrvAgMawnS5P5e7Oa2PMCl TKAxrRWeVuPjVHxuxDMeH53nV5jckqf7dZ65XgfTaDblXAMiPw+8AF8hXhhk fmjCNTTAutiGpjk9cO/UxwfusQMnqPKQzOblKV6ChO5Pgnfnit4BCsMWh7cT Ru0G7JDIaO7YaY5Wlw22Hi4yvhiU3YvMDzkqDznJHd/P0Xjs+3FWZEZXgwaY xSFHpVTmEanMJ0fMKJUyIYzq4/FYPtSKt9BW9GZv4EQxwnJHTRzYy+n0PRzo GB8OacoPJ4uTzPEKfDiZj4Iktj8cCsz8cGhzcjjw1IXgBP9E9O4Wm7Z4JHxw Bc5W6+zL9OTEeSb7cSCk6kt8FliiuxxdHh4eYXLhcHVneTmZXPITMW3ecq8w MY/P4IphA7scBJ+4GrG/r2qjsG+u2obm6DPDUussna3vP+A29zneo993y12c SlCl+H07utKi8fL26SHHWO++tMC//JnNHm3CPqkhx700Q2Hi+uPxFGsQrmfO GGRQGzFPbkzwzoPkqsc/G5yfbvT1Xb7KQbYguzkmn63ez/BJgFGCL/Lmpr1k nHu6WNyDKT7lRLOxOzlFz2MjFWQiL1oncgWmEE/jI75LPrVMhV40JwBjc67V bfqc/sbbX2oo1McwDZwC3/1OgaZpYKSsN0AZn75Xcp2QMJ1Qy3NeVkznpZ7r cKo/PKWI8yVwtLeIqk6a9qtplYLdkNuHSywelVj8Jt7iU6fMZnQ5mh4J2v77 f4qP8LWlI/g9yDDmmCO43kbMkRpyzAn9wAkSLFAUcZhPQ98Yc2RQGzFHbkz5 BjE6nHjk1mK6psCNA4Ecdbps3EPltaWlutpt1QHp9+okMG5j3WRVu+NaYXde bRW2TcBlE1HEVtTvpS3xxSWDCxOZKdbMn+7vH9dLfGlswBqpYclvsjjzqLkK FplvjjUyqI1YIzemVOucukTRwP+h942wUYHKSHV9CiSDFRE874kJo/xsfY1/ u8n/9ZTcv8Ztf7iYTMh3B7QF+3z0A9GbCcc6axrBri/A9TG+9MnPNZBsTy38 qg+EknNxEYPszs1tKTrj9l/l2RNTcdf4bmW7dLM+xeiBpR7pq8cFZm35ErAl kq7k5+2Id6m0aaFU63maVqkm8HfD7LhWXZ3Aa2q4O74Y3Y5G7NcjMWOmaWd5 ek+alwsBDx/Ir+QyOGdLZB80Vvh5lgiRwRL5jO1sBoJEYlMajivOn08dZzod j9MCOYWbWtNwbEPDsaBhl9oKXCYxlrgLfh1JfxCqUC1VnCpaPiXGqopYfi2J 5deRIwETLHgFZDVzN7YhfsS/jm5uOOYNMapvJyg8LpHrIfcMbkIXqaEwSse5 mxT5eOz6eTFNzVm+DGojusiN2RtFSJ4oog4R83b+JITMJsOuroPxeFz9cVEa G0c9eHg/oCpbnybLyhyyWLzGrPpC85Sl41A7YUqWMiY/GUPEKdFm6vpO4njj MQoK5LlGD1sKIFOk2RHK7BBR/n+HHhsVkLKZsGeGkZ/k8Xgch0nmhOYmswqQ IXoI1SMiml/EFD/dgREBjT5B4nNimub14VFz19dEY8B7mGfg/Wx99/s1PTvd ybEbqPXUdmmWsjyt0Oy0wvK0IhemQeyPx8408IrQ3MxQATI8rZCfVkh8AULm C9AU9/lxlYYFZZfLbVv9fimpZ5eUlkBicjDbPxqbHsnyHZxvOg/WRpCOn/pu GI7HcIqSOHWMD4ND2XgSvB05BuQQpkp/4j/5W94CH8bsPsf7nr67WS2elmk+ OqI7jHcNggQvGKxnDznRpBZYCQNgNZv/egNvXDhSpPLLQyKpt2/26ndhUKWn 0g8aOaQaHLB+v6jBYQuzh8MeOMg2UjBHzMbhEHP8iSe0VaWJNF9pJ98xEzjQ 7XFCTaIqxt6/S+6fcm6LlBfzLqlpP932qq0tqrA5gbQ+gz1PwNPsQImVdB57 nkCg24HaDPY8gUhMgL/5O1STbBAf2inxmULTEN/dMs8lOCWub0N8iBOfH1BT UeCcQlchPrR/4kOjdEjiCxrEh4YlvqBBfGhUI729T6BBfHgHhqT+IGpOYFD2 Ezo6HBiQ/YTQjP14O2U/ptCabKPAOyPDUWm+F/vxOPsJPXr3R17z7vf2z368 YYkvahCfNyzxRQ3i84YlvrhBfN6wxBcbEp+/U+IzhaYhvtm7vBNOL+rzOfXF 4p3Ia97+/t7Ir1qN3eW/reYfNMa3k/y3HT9qrt9K9tj26dNpjm9F+9uOD5v7 P+j4nmb/bVjPtuMHZqwn2CnrMYXW5Bir2XMNTkPn78V6As56XCemN78L4+bV Hwjes+0FH1AW80JHXa09BjUHuMjVzHlIlcRFSLMHQwoFLvJ1ezCgVOCi0Iw2 w53Spik0DW3m7/K5BKdhEuhFm6GgTeiziCcP06an0Ga4f7E8HNYq4PoNGgw3 cIH2iQ9Kun7DnBAOq1C4fkOlCQcmXb/NmsfcFwP6yBlKIRccjyOBx2LiETu8 hh+adNbM10m2hUNkaAtv4wj9oG0wEsLdGAmhMBK6xEpILmuNng73bybEQ9Sp sTuKdQdI1dDU4cCGQrehqsOB7WRuQ1eHAxvK3HZlvU413k5p0BTaBksZ3I2l DApLmRtC6gsMHY9Fr6iN9kyDA1uKoNMgwYFNRdBpfSeqMVvkGTJbxQemFwyl V6t/dQ0V0W5QEZWoGLHrAMLmky3aPyqigc22EKrPRmhguy2EqqCHhiZHqJIj GpocYTs51vi3b3sbaO4AUxikV9mnnRhlIy7ckREXCiMudCCjRo0DBdy7FRcO a0WFHmyMP6QVFXpec/0DWjGhF2jWP5wVE7Y7T9QpSGMvtKZCUxgyFQatVFiz Z+pg96JCYc+EbsSoMNBQYbB/8WxguyVsuFLAge2WsOFLAQe2W8KGMwUc2G4J A0NqDHdAjaYwZGoM26lRtmDCHVkwobBgQuTTkNvIPY0VWgx39LYAmY3Q4m0B DmwehJFq2YcDG+dg5LfgJz0kHzJnWUc1zkHVOAeNjXM1/cjfgWZmCkPpZSYM oh0Jg6gUBgNITPYniMR+KqiP9icMSusZ1HSP3IZqZisPbj2Dhmpm+66+9Qwa qpmtTLr1DFRjJbKVSredAXRaL8IaXQY74AimMJReZoIp2pFgikrBNHJozhuE EHH2qXOEXT20I/7Q3sGeldaD0mjjgRkNLCqi6oFZ3oMhKQTFZhSiEcWsKcQU htLLTFjUQe9FIaWwGPtYSjxBvtswrKP9v3ajgV+7ka9KhWhguRT5DXIc+Nka +Q1yHFgyRn4bOdIoMpoi8AQ1n62RKhkjU8m49iLg+foXgU1k3hNIGbJbE369 HQm/nhB+EfTYVUeeqZWrztu/8OsNLfg1Xqm9oQW/xiu1N7TgF7cKfnVcDXaB 8MZASoSvyXbejmQ7T8h2+FJn+aEc2Li6vP0bHb2BpSjPUXUtb2ApynNanXjr mBLuAt2MgVToJgtK3o4EJU8ISlh0YOjGbN11dNu/pOQNLCV4UPWA8QaWEjzY 6gFTu0l9jZf3Bqm97gHTE9oGp3F/R/zOL/ldwJzGPRQ0Hln8QJGM8AfmKqlv pcD6A7+2eEi9Z/2BVWjPU2nBH5r5NyLn/aGZfxU6302NGr/uLajRGNoGN3F/ R9eBX14HUUj0Zs9v3gZ+qBJjaEOM/GnFuPWgCrQXNEhhYAXaazy++kNfjY3H V3/oqzFok8RYSpGIKNBehFQF2lcVaN9Uga5dbYHmNdSKxntC20DjwY5oPBA0 TkU9IvLFTetxsH+RLwgH9vz2YtU2FYS2MWSB9ctwMDQDiePmDLp9Kne90b6j Bt0EA3MQ30EtHMQ8ExUyyESFqkxUaZJOsykajwMUhm5gnuOPQzHIRIWkTFQx zUQVm2aiQq2ZqNCNC+2z4ZBzkv1QGBRz53rWv3oiYP3NA1sonvRcBelWdWp7 mDjpubrSRWYD9H5rV7u1PqtUHJ+BPxJZ3z331I2Inq+kBSib7ZHp830clB0i zQyGVW587R4MKU+ZRMCSedlnxtDxAVMH65IPSDpRyyzsGIHpMmqMoNWrR2UE 1v7j3dD7Lp722wy/ecj2uYd0h2wTScUOuTJ/yv1NwlZ0Z2y6itoZt8bUqGds urraGbdD77l22m0zeIXXexWvD2ga4MCrO0qWjap/e+H0A4exKB67fKOH5LOt Hrs0Gxak+XjCUPHdY0S//9OwjeXYci/CWDODQW/+yNXtwaApuZqyx8BPqK0+ uuqlYJ+YRncpmAZ1lJeCZClp6W93K5guo3YrtHrvqbeCdcxKN/S+iyf9NoNX boWguhWimHKiONJwon0/LLMxhk3D4ziaKQwb8e9A3S4MGvKvvK+LXRgy5r/9 gV0hY/tUPDpuZBrUUnGjytzK+hvaW3WcyHQJNU7U6iWpciLreJ1u6H0XrvYz 5EVhxYtcJ6RJXKDTlFF3E83DF2T65sR3d1DuAJvcYehMO7Dt+ZPljAqIvdH1 3OYh1Z9c2Cdmby51gkF91dKaQcw410KLWmqVTUFD9sarkMm+PdXDSc/Vqd0M FVPj1dcU045MFTWyR5Ji6qKQZSf1YVMI2XuaCTbGoHkm1HRefLc/Zz4vjlDD TiHS7cKgnC5odSpVSLmvMbROe6Yhhi3GULsgQh1H6mMMbQ9xVDlSjwjKbvh9 l18zh3aEaNZZki+xJN+j0ZVuiDQsaQALzdDxlW7YeJgYOsDSDUPdFAZlSU1D 1dAhlm7TUjV0jKUbtb2Xq1yxn6FIZUp97DQdUZYKdzEN4tR58rP+hpaYl5WI TLgGxNwjDhVfGgZwR5qMTSwmbz4oPcdNYho6cYfTJKahM3e0Op+oxNTPzqES Ux9TQ0dApkJMpvGeujiFlv4bAPA8dDHROaEbKA6oDOb+b+OBPU+h2xSNh84p AhuG0qGDN9V0fGIXBs1F12UKgS4tAgg9t+58SiZamkK6qV4XGmlP9cZQZKr3 OlKX1CwBbeGf7URbl9vtwj8rqofQpdcoSR/TuEb3HubJFz4owjftAkMHesKm XWDoSE/YmuhbpZ2diJ/GUGq00y5+KrTTEklqKn7aRZJKtENsaiSJcKjmOmBA 9087Q4t6YeN9feiYURgaPrB7OxH1jKHUELdd1FMQtyUm1VTUs4tJlRDX59mv IzXYiAHdP+IOLeXEDUFr6OhTaFQsDU9MFzBqj7jGUGTE9Ts4bk3asAtq1bBc 82BWCWsDlhQUOWq8KgO4I43fJniVNR/UuQI5DbVl6PBV5Daoaej4VTVVndiF IZNluK0BrAop7uQmMoZSI+iOm6hO0FZxsZqryDweViLoiFVGQjBUKiMxgHu/ hoYOdkWwYa3z5fA2i2kPm/GtSWxD55hCDa1t6BhZhLpiZBGLkUW+1zBT+IZm imAnfMIYiswngo5scbV72zy2VsMjzONpKx6BoHsa4X0NqKpV39ggVF1hRHip 4d0d2LkpDR1YioIGuxg8shSFDev+0KGlKGyz7rM0Oiw4nbq11fEjbCW8mnMf RPYlj5ouguZQJBdB2OHKU3sVgNZ+VnVVE1r7WYEqRwzkSYoU8yAcwG2IjDFw zHrDJg+HdtrxGjZ5OLTTjtdqk1dpx7pAjJZ2eoT4wQ6fE4V2bF2C6sIxtHcJ 4sRD5FuaYClsKKxwAAcXMsbAxIPUGwsO7eHieeqFBYd2L/EaIdBwaPcSz2s1 kyqUZ11aRku/PQJ1oKl7CdzSvUQ7OxP65YkgWU6mBv3u375PxhiYfoPm5Td0 brSgefkNnRwtUJVNOLRHS3tCJpV+rYvRaOm3R3gLNPVogVt6tGj7G9GvSytu n3hhrKHf/duXyBgD02/DsREO7dPiNWJw4dAOJV57EK6C9lEv4jlT0Duy9TjP Z7d36+YsJNWsI+yt5xJqlBuZeZubL03t1gq/79LVfkbu5pB5CPE0PIhL4yQM 11O5QTQAN4gYN9gzD/Ab0bdQpLXfMNFuYvH6aXr1eC9o7edUD8+A9n5OJz2X IRNMuxvXSc/lyQFdneB7rl6OzuiAXycXT4rO8HyHkovvqun/y4b7JZehvbJ8 V/XKgkN7ZfmuSQVCMrF+WptKi7Z+U/XsEdpZ2NFiH7Wx3S1MpUXT5dVp0TB9 hMXqpfQRHeAVUpTSR3gBu7l85GpIcQA9dGg/Mx81ZMih/cx8ZChDev0UMJUU bT3B6qkToL0nmEqKfTTAdkc3lRRNl1cnRcP8CRarV/sZEqOUP8HjFeB8r+k7 BwfwnYNDO675fns1wBoK6Xy6jCihJuLYu5Ypt5JdnQQNKRivQyaFdte5k77r q4lwHfD7Ll++ljo8/2qU4MvXUkwlwxM/aMbvQn+Aa2lo1zs/UON34dCud36g xu/CoV3v/IZXAhza9c6vnBI2sKS+l3OdZK2d45Tb2c45TmVHfW7mdsc/lR0Z r63OjkyvZvOlq/0MGZJ0NfsuLYHtR76aNQf6u0ptBG3KafDTG5RBRE0GMbTA EHVVYyRKTAxOAidoHpKhv47OCc2EqusXpV2ZCA1V27mznfRcg0zV7W56J33X JgsBXeB7rlztZ0bUgUzUHiIOgAErnVFHmGBnVG3nCQiH9gQMmk5Jg3sCBk2v pKE9AYPOSGE/jChn8ZucpcMTUH64QJ6pp1CXMo+2tHGjPjbufstQu5mp8+YL lNX5TvA91y/LJB3wa9wFyVZuP2JPxEHQdNFCA1i50dDhz0FDekdDG9qDhksx GtrQHrS6FKsMwdT1qJshbGdoR30M7f2WoXYzZQh9TO1d4PuuXxJnOsAr/ECy aQQOM7UHUdAwtaMBTO1oaFN7EKnhhGhoU3vQXnVaQUdTP6JuYtzO1K6dhR0x mi5D7WZKjH2M7V3g+65f7WdIjpLwj+VeSo6hoxbMKxvumRwHjnMLHdXEiIa2 94dOa/GiOkL6fe/GmrC3rb0f2YWSn/Rcg9rNUJTtZ+3vgt938fLNaGjtR7K1 PyBVorGkHJKEQaqkvLPoe2QXfY+Gtr+HUH2ZRkPb30PYYBFD299DaMoi+t7Y dSLa0v6unYbVlW28DrWbKZvoZYXvgt93A9R+hoxCvrN9SMwwoec03sfRAEH9 aOig/tBT7WJoaKN/6KkBC2joAP3QU73n0NDvDqHXVQ0Mq/wULYPG4xDqeHeo kbPO7G397oDsQugVTmZXklrDyYzXoHYzFEh6vTx0gu+5frWfGSOTXx6CyCcv D2HYTD2AdvbygOxSFqChXx7CRrZuNPjLQ9iIakFDvzyErem6WaVBmqM0cn01 BwFqf3moKe2eb2pBU+K4ekLRRzp72+b18uydr/gOEtdWF28hbGYf9gbwJfKG luIjqNrdvKGl+Ai12t0UrDI1KHXjpnWyQwU3t0xR5dlrARw3vYDhpoc0uLl/ idYbWpaLGgW0vaFluai9gnYdq4Kd4KYxlBa2Z+9LouCmvVzHcTOgqWdPosBp GEi9YADcHFwYiBrx4d7QwkAUtCZHqbEsX5eLq0vUl3HK30ZP8C19k/pOW7ZG +KY6gsXKJB2hE3zPtav9jHQEX9YRsHhMJb+oUU3Rb2Qn8+1Efd/OJ8kfWjOI IpUQ/cEJMeryB4rckGj8cbPSpd8uldcwNQg10dWmNEg6W9BgPSi8GtksKLzv tCUCw73MCMxiYWo/s7Bwi8Wr/YwoOAilsHAsiNMkpDGihRBqeBKE+w8LJ2N0 Ue2u78+4EVtHt1vkIDWe8zvrHql9ly6hd/cb02Y+zGZFAc7ObmdrkLy6TdNX BDtWT7N1/ur25GSc3b5KHx+d51fLd958/AZMN7c5mM2z/Bn40IsivxiPs6Qo kBOSytmB5x2cnZ2ZjHRwcnJiNBpLUErzkzrMQqFB2pJvnxNqwXvpgQQvGKxn D7mSrNS7cWHP8rEnfcGU6UpZr/bUM5WbNYdv5mddytWS4ZMD6J94sTYDU92C xlaxBP0eVDRODnC/TEkse9icabopDJxzqU2qV3F2+3pCVmDqqN+R9VBBfdNM F62ov03exLYVbsZ9km0NkggRRaPlEAfA/YFTFioardj6Qd0ANeQ3tE+uMflt XyDDCkyd/DqSFirkZxpG3Ep+26Q9bJvBZvILfUp+kZb89m2JF9MeVJHVkN/Q rwEa8hv6NcCY/LZPU28Fpk5+HTkHFfIzDbBrJb9tsha2AdhMfjGNYcWKQN1o wQEOQH0Dm5FcR0N+A9uRXKfLjuS6Lj0SqFSgpDM1qe1AGu6gBqUVmBrVdERG KVRjnB2tTdvZqo5l2wo3Uw0+CaowuUh9o+Mw9084Q4dRucjXzWFYwkGtz3Qq 4u5GaLMvJMl6GeO/tdCm4v82tSjbZmCA/yhm+O+rpSg5zAHwf2CZyfWRbg7D 4r9vUo2Szmw3UpN9PUrWyxj/raUmFf+3KWnJAfSQmvBBUCu+G8SKsx6HOQD+ Dy20tCfBUZBmBxUlrcDUcK8j1kTBPeO8W22iw3bea21TMEC+kEWpuaTeR0NE 3Lv3Gh9k0FRYrpJmRmzeoJpDFGv3YdBLKHb1+zAkI4hbg9lVCt7NJWRfipL1 MmYE9peQwgi2chXkECze7ikTiKgnCHSipuK+o+xTYmKmTiFiL4ckSqjUhi3n MGSpZbet1DKtOuqwgxJPobWDMlXnd1Cr0QpMjZI6HJUUSjLOMtV2IW7n2Mgh WFIShJDEXUAPaUS5HQVeiJnZkNLQDlbQayr4g7tbQq950Q/t5gW9roRy0Gf0 HKEmPbf7edUJUZtyyJ6ezcHI9NyVuKhukzZP7NSintmnplKu1h65qegZhdS5 6gTGfvNVaf95lsTKh5QMYdwgnMEzLcG4ISEPnmoJOYZqKtqNidAcTJ0GjYrR cfhb0uCWJsIe6aBYtXWaQfEEuX7TRLj/3EZi6watGu5qaHBg7Qy5bZdXA/93 IlOag6njv1ExNw5/S/zf0kTYIwMTc4D0GP7rnoj2n0xIrHxQ/G8+EQ2eTgiZ PhFpc+X0wP9eZsqulDgK/hunDGoTobY2U1qmPKLID5kAhnyoEcB2lL5HTM1C qRo8gQ/yG642g2fwwQPq92FIsvRbS02p9LSba6mX0bArAY1KlvbXkkKW2xoN e6QZoqSJaNpiFGp8vfefMIcPMmjGHBRqaHBg4woKNTQ49PUcRvp9GJIPRG1J AChuBixqJI4atpWOrDkK5e/GVmoOpsZAumyldQZinBmn7Va2C9hVmYd9BDg9 oJBmx/dct2kr3VWSGrE2m2t9aFup5zacQYbPU+O5TXF7aFup57aJ26wiNqVn z2+6MnZkqqkTojZJjD09m4OR6dnrkNPrauZ2uXDaJmjFEXpkw2GxXzz4K9Ao qvtPhsMHGTb6K2hQzuDpcLzAUFHVZqLpQwB9LjSvQyJWCWCbhDttE7SSiHuk 3GGVupml0os0zoz7z7gj9m5QAoga99fgOXe8yNCZ0duNRGcOpkYAHRKdQgBb ZfWpAehNAP2kOs9npkovjjUEsPe0PnyQYYUn32l4Ug2e2Md3DD2ptCly7CnA HIxMAV2Jauoc3CKTTwsJWGYhUtDfMg0RRf2Q1fBz44YblZpRR0xPZJVo4mgL cpeZdax7DVvKDzYoYvAMOz7synvpQ+Z17YdeU/2UkqeI6Zd5QwzVyCpriEWH js3ZOc8KW4Mma45YEBnHVSn8oi+Ysmog62VmA4Hb+pfAbf1LYE//Et/jRbnj ZtQyHMK/hA5St6HuHfliNXASDu5g4seqJRcO7mDix8ZE2K9AeYMIreuDs17G RLidgwnc1sFEv0IDIvRDlrjD1RLh/u0WdJBhiTBwNUQ4dAkvV0OEQ9fwco2J sF/x3gYRWtfPZb2MiXA7Lxe4rZeLfgYGRMhEsZMAqeU3OMwBiDAcmgiRhgiH Lk2LWnPCqpirSc7YhwBMwejzW1AAW2K4JktjNwApW2MbAAMMJzIeVjoCT60I zWEOgOE8ZeO+8dpvL4xYRwbj0MlunDIGU2Oqpq5TcFvXKbi165R+iZtxriwL GniNCE+IBniSoYMMzFUD1UMCDu6tFQSqhwQc3FsrCNWINji4t1YQtkW0NTjB bsQrYzB1TmAsXm3prQW39tbST8GAE5BEM1BXIJjDHIATDC5fRRoqHNgYKhUJ rs9h0ELFxlS4GxnPGEybjOfby3gKmUXWZKYIeb5VInNKYsSY55Kiv4GSkZvD G4DEhhHwQkdDWNzkvWGqGxDQOPC3GwGNwdSuAVOfO7itz51+gnbXQL8X2sAP WGFqch00BMIBXmjpIMNeA2rhWbH/w9bfVSO64GeoRwfVsEo4fEE61BpWqdLw bu4iYzBtd1FgfReptG5c1aLtLgrs7yJuTgs9X3MXBUPcRcFAd1Ej0J/t1/Z3 ka4aSQ8ENAbThoC6siVWV4V53ZM2BLSr6kIRMObCUAA1CLj3+iR8kEEQsJGD nO3X1giodcO1R0BzMLIwZOywDLd1WIZbOyzrl7hZGKKCOsHRsOmuBodwWIaD OyyrJWnF5v0xatI2CGAn2oA5mDoBGPprwm0dluHWDsuwp8NySDz2HUwAsVoq msMcgACGlj/j1rQGCtbsRhU1B1NDPlNnYbits7B+gnbI108VDVHIytO6zXAR OISzMPwMRUAbkVZw+CqgrZFWCgVofWjtKcAcjEwBxs7CcGtnYf0MrUigh8Nw 6Hu0AieCqsMwlByGt0Vxq2KcYisGLWKCGtLz8OU4UZsTED2omMYeRmEj7yLs qMdZpwFtZUt7UjIH04LpFhU2WzDdsjqookhalgeldS5J+huHlKpt+mrDpq82 FL7ahgQSGKpqcvsBPbWj9vI2NSsB8ox9FFQM6wmm0c9MYEHbqotoa3UR9VQX I5fVKoidposaGkJdRIOri3GjyA0aXF2MW4vcNEjA9FVmAwmYgmn0MyaB7RRG tLXCqF+kAQkgn5GAG+lIYP8yOxo8wjWG6gM+GlxpjWH7A34dB40fJrtJwBhM o58pCWyptqKt1Vb9Ig1IwHcZCaBAQwIDqK1oeLVVKjFd2/9BacBrdyqtIaFW F7OnAXMwjX5miivaWnFFW0W56ldoQAABSap0Evu+qrii3SmuqIyQNVNc0eCK a+yr745ocMU19rsSjNNL2qE1GZvmXdRUnehHNntuG+aKBlae8MJbjb2168jz ja8jhWf0BaMX7LytWYK3tS3L68kWYsQrGTrM07SGbZ4/wMXoDU5/eK1tqUfq 8o6nNXwcnR+c1U/Pwj6jIGJvOC1YYGHn0TsN6Je8AQLDJC86DQgioVi1uHnB AJ4D3uBsymvzicpmRQHOzm5na5C8uk3TV2QbVk+zdf7q9uRknN2+Sh8fnedX y3f+fPwGTDe3OZjNs/wZaxR56mbxeBwEThJEMeGVgecdnJ2dmYx0cHJyYjQa S2BNczFy86nmcEqKPSeEgzfTBwleMFjPHnIlh4lPatfuoOiFHZwyiwnvZlLG RozQ3/dHQOgf7Vafg+mdxFJZsUQ+6tOcgLhfGixXPmgqK187h2FTWZmkcmMz 2z6ZoR0chQaMqiOKEbalgW0SC9TnYEMDAfNgC9T8xgLiEDQwdMyYp53DsNEq rS8eDdzdPpmVHRyFBozKmYkRtqWBbeL663OwoYEwZI9vappeAXEIGhj8NdgU /3aQUNYOTh3/zCrUihG2xL+tQqBbV2miVtKwxThSohYFyAEQcPD6sI6jncSw BWKVl79qJwbVr1uf/ho0tKO7wD65Le9mTotb3wVbBSG3rnIzLbouSb994qo5 DgXIIWhxYCuvq+QyrCYxJBl0JjN0ETsVT8mNzqZqkhydttxBZlA7OHUCMqsN K0bYkoC2Ct9snYMBAXkeqXrg+qork4A5AAUN/U7iKkWDxCSGfcF0/ahlK4ak 46CrZokbMTqOPQ0dGxU5IC13UeXADk6Njrv8wBQ6No9LalNptnMla12lAR3H LLoSkoe1hm1g/65gYpRhi7I6sXYSA5dIN6nKyqa2mwutR7kD3s2cEKwvtAYh bPPu2LrKzYQASf0eBxMCDDQ32v4dwsrFD4qD0KQEHZ3ajoSqHhUHeDdjHLQX qlQc3Mqjq3UOBjgIWRwR1D5W7N8jS4wydH375nPF4D5Z0Pi9YheFB+zg1Cih yylLoQTzcKU2XrqlE0frJAxIwfOJCAkD1FTQd+WbJWAZ+/2U6xlS64BBkzwG dw+BrZWZWF1zj72La+R9HlhEHUkUCiDOCRoKqEUciXbbhhzZwWlD5i2dUQSI nlFH9RkYhx3BmDnPIVfN1ioAHinoZVUkopyVdY8BHVMQbHW5rSOlPibHnr1b wJHZe2f0Ud32YxHg1CLobBnA1LrKzdwduaIQvN8UdAYIQCq3b9hS8KF2EgPX gm/1I20g8E7kHAs4CiEYpbATI2xLCFtqnX3imFjlaRaCgYgdVUMIA0j8w8ch qcXXy0n88aqv06ntRuC3gFMnBLNcjmKELQlhW9W3TzQTJQSWSv6EVFPWEMIQ qu9niEZCYUO2Hz4cCYWGqq8+zKcHJfRTfTvjkRRKMA95amPo26u+tjFNrNp7 wKq9N9XenYUklVOzkNeHD0pCcZM0Bld7UdxdyjumipXXKIPh07LjDcXKLiyp 7GCjWA0dmOS1F8ioE70+IMieeVjAkZmH1xnMWLsEt4x9ap2jFfPoE/3EvN1p ltQTL9BoVgPELpVT/2PUDVdMTl6byUlFAZMgp3q7jafUHuVkCajFsrRtnFPr sk0CnTzfJYFOXgQbFsABAp3EKEPyvajNn08uoasxiPpBuwNEzV4J9cldrO2e NnDKtGW8m5m4Bbc2RcGtTVGwrynKixjD9N2w4ZcLBzFFsVEGrlzqqh4QcHiD mFpducSDP0Z55SY5bp9E0A6OQo6G2g/c2iAGtzaIwb4GMd9h4Xo+UtPyCKBD kOPQdR18T/WTh8NbxHzPpLYOm9ouHuRs4Oj9XxmEbTHduoZiA9OtK/Swyu2s iCKt2es2MX3/QhMbZYjE8n5rdo8Gau0gU6sdnDqTNTUxwa2NrXBrY2vLKg1Q DwVM5iGlNZoyzwBKIhtlYCYbqs8O8DOYfP1Qdd+Gw5t8/cikrCmb2o5Y/VbF awSEbenNmtU36M1aS2dl2VniVz/2dax+7zVsxCiDsPrSZLoJs3bi1WMDpxWz 7MvSqJilNxcZG29a5mCAWSGvxOxCHWYNYHlhowxSi9k1qe/t09qwuxEieuR7 591MhYht36ng9u9ULcs0wL2ISREBjDVSxBCmZjbK0JXum0aLwR/HAoRaJjFk dgvUljGsSY+7YfXmcNpYvd9DiFDpzb4ea4PeekkRtAI64fV+M4UFA7qb12E+ QdNM8qLDIFeAb2qs83ckXZjDaUW5HtKFgnK6Rys78UI7CQOU41WVgiDWoVy4 Q5SzKV4gOgyCcqFJlU+f1h/dDcr1cFNXUE77EmjForZ+jmyZhAHKEcOvqO7u qSg3xFsiG0W+zfeNYlHTJFA5fuhm0DXxAR9Bg9iQNvTeDPa0YQFHlsjNnT/g 1s4fcHvnj5ZlGtAOKYnt8LLtKrsexPkDDu/8IVVw34CEO2LQFnBa7AWt7iUq HmzPhvt4hbCqy5A4dJDi6qGKSIMw4aEdOsLW/MesBjB16Ai9hkMH7HTokO9l pM9HbYSAfeE0O5rxQbQ1H0Tb80HUlw+GDvPpCP1mUgs0CB9En4EPtr6xAQUL WsTDBgqYOcGhXTnBWQHSs7uWtdk4wbUs28QJLoTUCS4MG0wCDcIz0eA8M2xL cGqe7TswyPYdVNm+gyRyiyAYjzOnyKbT0CLbd2CY7Tvon+07aM32HbAczNvH lloCKn2gRT+T5AHlGP3V0BJE/4cVZRZWOb9ZeKmnBtWVIPdLitXiB836Hegn MawrtklUHZ/a9vEAloBUYjDKpFGOsTUxbOMvoszCKvk3t+GpmfpKkIMQw9CP E+3FRuWjpc8m22uFloD0OMJB9LcVlyAa1GAudbevxEDsZkVFI6gUzSlh7hvR +DBDmIUjTz+2UbDWBpTciaHCElAbSrYpC8ZsC7bqERYY2UczoCm3Q17IyW0I AnAImbwcZkBrsusg/RwGrQNk8jQcMC/nHeH6di91JYgtcd23x3WFg3s9nvtY Smv2POxC9Xm4hDoAsg/1LNeeSLqJYTvwPrAE1I5hWzkxKrPoj2H2PgwsPTeT JF2kvgaXUIfAsIF8DdzWUmYaDNv+dcsSUPm8JfqZeJyVY2yNgtvYhksQfVDQ i8mr8IlLLLuBBgX3r83wYYb1OnP9WD+NgbN+t5EEqCvlqD3Quq4Wmxmjy4ab rNFKw42o1W6OtoWks0e3r8/cIN2+dBOLtBtwAZgUP1J0MncYAdgdXvgMWx9C FNNRK5aeKfafHWlkVoDarEBGj8ftY1mhb+/nYzdiFlg39puIN8QLcjnMkIjX mi1GRTxking7cSqzBNRqwWxl1Qribes91j7YZsSDDpNRoas1d0qIt71R0y45 T9llQIyErkkFwoAVxNqROb5Hfh7Rz9gc3yOztYrM20VetK/UAEXdmKa2xtpU 3EDQISRYsYGDZrFGqsG0nMWQaaxRGz3Qg8FKBTmYUEliw+ZqVLeGPXbsipR6 ZIwU/cxftrYnpe0ioZVZ2LxswZBlT4XEV1jz0DsMLX2GigmKw3C1hYMSU2yS +i1gtXV2QxF9kr+JfqYUYWGEaRXRtzWQtK3UgCSimPggISdo8rBBzCPuZ3AB Rq0uwCzZOPPjgVFzS7qcN1WTxo6Q2AaQjMQWVj53eyufu72Vr22lm5EYQY8i sde8iIex8bmfwbiGvLbwZnNnutDAmS6snOliD/re1B+PAyd0c8e3cKYLDZ3p wv7OdGGrM13IXZu2p0dbSCVBlh1NrpVqlP6SVgWjP1mr87ByqfNpgke/TpEV xP2SpDTzQb3ZutL/slTNQajZEcMkjyG34m9v4rGFpMcwAWMbDKvPo8/NUcHo cXVErt4HqQK6b0QV4wzrhdRhcAy5drDZ4li13B4f7SC1czyT9yF1tHa7eMe8 DLyJqGhNnIk0PHAI1BLjDOrJ0+ZnYSqVrPOHx5ssL5Kn+zXcJJ4ojbmc4idx Os2d8bhI4HQaJMZyigpuo8CidqBvGcS2cOKyaOSDcj8Xj2t81a/Ay7PVOvsy PTlxntnDGyBA7smevk7vk9UKXJ8C9ssP+KyzxdP0Pr/AF8G7xSwDxegarPHH zin+9on8gg/1RdeZ4WO16Vk9CALa7XZ0hH/9CMiZFiP3FHyRfnFE8a94jTH6 NL1Llhf4c/KxaCR/z+ePWzji+6MG+opreDa/BcXTPF1zoehke3Rk2EjncjHS TcwpJyatp7lC3uyTBSIvk9k9XpG3EYmrhhyBoRfmReaNx1kQTtE0MEdgCdRm 5JUa0wQ9NAf1aUSYlcDJBkpeHIDkab0g6HT6wxE4uwBZnt6vPzzmo2uMKifg B8xnCMJw8i8/POfijAL4QqDZ9dHHT5sQ2bKzhMuE+T4kszmezUfcviDTaTzD tKLhLpDQGG/eJctZks3Ss/wZbUKdelsR8+SkXuiG4/E0i0NkoaYp0DYikNKe Mb+Y8j63g/fdzp8E91PR4a3As3/yX8bjMfifC/AW49s/Jb5hhh/W0EqEabA+ gj8zzDQ5I/HHwdG5+PwX8jn7qLzN2zGLLptwGzLGxYjxGDBdLO4vcP/tWV7A +KYePuNz0jcX1Zy7p7z1vKiThQX7lJBrIwett+VkMI2SPHWL8difFtB1zZmo As2GDLySDHxCBv6OqKBE2tP/2Z4INgCrROsaHEI6l8vbFWe5BaSGlzqdUIWK rDw6pb524lvpBn6ZJC9P0dhhI/8TzFb4/sie0jwD+FKZ5oDctsenAK8IyNIx kCnrf5rd2G3OBYz6IPtE6lK+gK/JxE/B6m6xxORGae5+Mb8VosTi1+RDL/RH vinyk5Yc9ZPID0M3G49djPlxaI/6FJYx4tPWMvd3zPC+QjHCRv98CogYMU8e 8hLZuNSLt/xmtr7jShj55pA0wWex2kwPfSCoUnBBkPgjOWkO6DWWhIv7RbIm ki2AYyxVf/H8BWOwUhOKBww3TwHDEEoGtT6DScP01eOTOQquz5DveuFGBCzb CTux40RuRPSvPJ2iIDdHvwrSZuSr2jLUCwnqhZY612uBcuDm+vGCXMz4v4eH oFgs3yfLbMT+urlZH1UiLf4LS4+b0G4bSE30w8hKDd3UrkDMCjEzKjTWUZGO YL8U2Sts53hcjPjEXpPv8bcXo4T9cjQA23QZJor13WHyssHKMETh2UbjgNyS Y6YbZEUQT8djWBRh7k+tMLOEZYSbZWtTxqhFT651SfLr9UVpCjh68cJQ9de2 LLGMIcTra4oF+z/9oDz8cpkXBsefPz8uX2H+ncXtBy+34Ueeh24SefjI8yh3 SYG+zUdeg9Jx2LV21MRPhB/+kr5aL59SfNXg9Te267JG3IvFSDLxJUdc5XDB v4METIDTOBB6Gr+TzVssk+WH3d0NbFAHD9o0Me5jUCY+GUlFdK8fH4ozd8Pp 8zb89KMi8GCATx9lmeOmJpJQDcqm0xftaDwzTfnEr6Dy+Dl5CUI8J3eMdO74 l9HlZHJ8NMKCwVGpjXXuK9/7HlBoS9wQ99I/RL7kNuTm/Yj5DrdTc4vLebks wr4pl/Op2uMz6V/sgNSNzvHxCOsLX4JDMo1z9ct/8S/JH0VjHRwVH5NlPl/f 5avZb3lWzRnQzTi8VfTauu7QytjErm4fTsBmQxD73Aix16/uk2l+3yHoy22E jJX6CfTwdV+kgeummRFiS1A6EVtqR9/iybGiU2bPPpA5G15h3bQ2nYBL/AuW dPD/T2Xhhu/55U8/jX76SbQ4nlL99+Csc8+TLJuRmzK51xUQ6DbQ/b54zJfJ erE8PGzB+I3Qzc7w3Ww1m87uZ+sPr5L5Yh51n2aztbBaOBmKvHg8jvIiyoLI 8Fw18DacsKYHdQijLq2KHJ0t8JY9PJILSnmxYJR7XMyPwOhISCZpcn8PjKWT jtaKhDIH1OggnDmZ823lFE2QEDBrwyfKWAjk14dXLmYlc/eCdS4/heRTSD9t 2oHXAG9RvsQ4Ae5n81/xZH7ftRQEedQRm04xR+oE6bQ95dNi7n++KbMs8sYE cZ90iOhVC/Fol6OwiBLM0IIkznIT0VyCsQnZWStmoKIP/uy9n6I43cLVuI7Y T/PV7HaeZxSz/oYxmxqmwDS/xZyO/A5Gh1hU+/FvPwPpNFrw3K6vqv1Nk+WI 2p+F7kZBZD/OfgYUM8j/GOysw8Wlbk14uRv5LTRFiFvMPl49LmEQxE6XCKe2 48gRuoWbT9F47Ia5406RAXI0IHWgSKOtpLPFAk3+8R3AKtor2qiVNZ6Jy1HH zrBMc8kCRzc0+r3aeSxl5ul6xbkglh0vAZXxzl90slfxnt/ZukS0T+cC2Xhq CCrHuUyOw0IVKM1fWD8ZOYQh/dvjMrl9SABeO8DyGGZO+T14XM7ekUmPkiPj t7WtcZA7HJz3QMQO/qS2E1wqg3GB4HicJo6bIBPXggYkU0QUHIukhzzxFL2i PA/KGp6xzBzQU9biE5a5cCssdvHHJ9yLGKephZr2deG338pxaZ0IZdi1Fbsg xS7Ygl1BH+yiMsSiAAss1t0vkoyoBbvALc8Kt2bz2frV6gNWTToQq9ZICPN5 lDjk7ssz3yHVyTdjVR1MB0rVGzIrRaBaKf5E9p+dE7M4XcoMg2/yDp7Co1KY Y4b4P4Hbc0M96X6x+PXpkZhb3nVdIEqz8i0wwMq/Mx47qYdiZGKRVgF1bLHa lIqnFMshrOnCVwCrR+4puIRMbfqGIP8V34vDqSADbh2eNmwwkrfWbi5w6Alb nPEBzPP3m7efNRKbD+Mk8QJ8ebtJkBlZ4OpgNm89b8iwOyLYXdMKiGpavuKX dotjIHRDgPuPbm6+//P/fH1z/c9/fH1zA1b0peYYPJbv/Mcgx+yOtDycHZEP dBaGYd9y+LwKNi86Jwl/ShfiDcakBmxHS+jyZukElDZIxpj1tMK71GHcVZoJ 0TBFU+Rk4zGCyXTqm4iGKqDN+FU2bdzHeJtAMgclZZZXEFjhfeBv2ssc71RG NQxiS1s9JmmOmcHHyhbIpLQNpr9VzfDX1aW8e8vG7BGy25m2DGx1yA0BeexF aeLDwOg+gDfCcleMvrjjj57M7a+FClQv0y2ZFqytjG+DaiNc5u9m5DzYlImT GpYjBPkZsrzF+i5fvqIQ3Q5fLKWZQMzI833HHY+9PI+RbyIqqoA6EFNtyux0 EbHT8VemLiWjbli5ZBbk5+bTz2z+LrnHXz2t8t9nc6Lo3Of4YIhR+PcGWjZG eclfDUB1pGusjbeY2bj8IV+V4OMno9dx8shKDSS/ZzmZYLYDUYWZZw7wRKYa BwEqUDEDNHjI13eLTB7aCrOgY4RZpJl40vK9YIrC8bhAUzdMLDGLAjLDLNpU 97rOdWHkwdDvpwuL2+TLjQpx2bI1dIo9sMyW66fkHiMNUymYXMneyz3yXu7L jxIbp1SaXsDo8hAkQjRLxgw68Z9uoCZ7WOEGbtxgl2/lxM5jhVaoQ0pTmnG0 ylCOcicej2M/jbPQ5CZVAZmhFXJLhkVscUiyxdXfxelBiE+ni1vMzqmlc/X0 +LhYYmID0w/tgoeEgYSRGCPhpsateMiV3IZOSy9IErgx+ohhuuRV5JPOhMsY G2Fmu8EcaGqdY2fzuISR63Y4WyrNBNr4XpGnGG0ClKfTwsTdWAW0EW2qpkzE 94iI79ccYMijX/Ukys/y46djnXtXjcDLk8L9XjsXxLzVovsO5n/FF71ePuQP 7sbroWonjFQo89PIH4+nKYqC3ORtsAFp85FUbRkpk3BdfkM0Y1renPJHXiw7 Hv+VPRZhZowFslS4s4iH7OPF9JcjQ8eWTX3qcs4bcPyIqZANe5Mmq/XrN8cX I9KXkujo8ewCT47cHSx5JI3f8oSlhPTiFE7QBkNL5VU9kFXJuPTm9OFixOd3 lB6dKyg1IpwsAUzAKvcLY8zvjwuMzPnybL3AK3mY5svfFaHnaDf8oXLE4eTy vS1ubrxjqnYcN1M3jYIwJMaAOJ1OHVvcNLplpLZSYIvilsPEzQpRiXGAuCCA xwtqnTk4I+h1eQz+ZfCS2dm0joVcO/8XxrXH8jWTOk0Q1wkRKnhQPvtc0zkp tiGCX4+UVxljlSo4N9FsR2gVlmgloibwUl5f0tmaIBhXoF9RrbELw9SGInrK jb1oWozHmevmjmMkHjdAdeFYozFXmj2qNPul0lyMrvQ2ebZzdRSSjFWCh4CR B3WXkWwG3IdqbXRFlZuwvO1SjevNhAIzDXwYYtUYeQH0jJxXVEBG58OaUvpy iG5Mf2qYgKxz8me2K25XaOzn1WRyxc2vtNnV5lhnIT10wuzwxzrpGIejkvLQ Qm/GKx3ukOeAGWYOv3GnALo5VENyYxl1TftrxahRd+iF/A69c7cK1xqDp0+z +/VsbsJpqqYi1s6H0yjHmFxkGXQi1waTJWAm2Cw1Z9nV6TMaOg0a/i+K3nGC f7NgImc6s7bOxK3HdfkPTV7qljMWypW5yagVlOVs7HAlXTx+MEEU3k7cSNMs yn2EscTJsUhupCKpkExQRLSl+BFSog4ZUV8dkOuEPzUdguZTUxNBJNfI3Tr/ x9a73v3mpDQTnr8xjGCRjMdxkk291EjQVACZbLn08uTSh1U3kMzmxegtOH7m zzNvf/R+bnNprVhprcsIHYG3o0BbDu4lcZwG2l4Q9/rRdX7W2MVpL/sXIf2T kN25R/2elQz5gePUAmZq+4634kf/59ZNtMBEIVF3WUk0bcVtEaAoI6aSqHCc zLO6LWRoJogpt+d+bx71e6PYWT5DlQ8p0+Q3wMKMdBIr/rZ8Nzmr6UyV0aXs 3q0rabtTQyuNlmMwNoBoztg0dYDxnIXSpu25cbplb5OZKg5/BzRNDJAFKvDa uQDMMqXKYyuwWxXA5S/LZImvidescwrcprVy5+NCR4z720Ar7aHsPM2piG5y GVVNBfG708CZOvhCQn4RZZ4N8UvATGhfas58uiPi0x1z21zNdHbEPfjJ31Q7 kelTCv6o5PxrUJgHodvBaHq+/iZcN0gvPMemXvH6ab7MV4v7d3kmuX9VT4Nk /IuBzbflOZC35w5fsEZDYcD1pi6EWKvwXS+LUGGFKgKUEaKIxjR+iT4dn4RI yoXGdQp2BvkzXjNz/yR/3pR/7/e9P+TF4ZLpYrkGIzF86grX+Df0t/1OIuLi BR4XluNCMS5Jn/ZAq7AwuaXuEkK9E9ms7vJlDpIVeJ/f35+C6dOa3c3U0hxJ OXilfadjonJMNMBa+RVAxnKqYZ37I0NHyMdkucpfpctkddcR1VRvxVHf8+Mw C9Lx2EnS0IGxAeorcDrwXmlZy9bVlqvjPWdI7B3jv75fL4kF46N6AqW/SZYX 1EbC3gSxMi268NwD4k/yqNzFRsFMHKYdAP71ZMJ/afEll509q0U13S2WeX1B pFNtGv8q2YP45Dd97Oiuc25Qv2fZ3+0Z/Hu1V0dgIv2x5xkZx8UwBGReOx2e bkozThpoGuY0r5PjOonnmLzPq4A20kbV1CCpQrG6W7w/Sxf3Tw9zcFbwzTu7 z+e367svHXwyZ8l8NQNnj3mWzNckQw4NtQFn/2e+OCMe5PQHEM/8//gOvDk5 eeWGURBu8h+JJuYeJFJbnZWVeg/NsLwyS2dr2SuKyUPCjcR1qUGFZfXhRHB5 SAWnMhWOagc9+vJSdz+6cCK/9oMvyvl98fkQEnaELCrNRJoZZ+rmYTEeozSB rtFDiwrIDCFhFZ1Ii/VI+cVEVI4bO5FkyifeQHhf6H8If/rEf2VxVOTvT+cl gmX5EnOLx6fpPXng5X5EHIIGmXDzCfnB+TvpLeBOaLcRG6HRFdW6nmw3up6v n/SbT8clwWe5XjxWsyRDsCQF5ONRDTp308FNfvqJ3Vg7TB92ftAgJWfS6RFI XHC/oDuus2vFFkQiVJqOfDiNhuK9ywkzrPNhzp2hAhXmhCKD2kgqcmPGvb0q CVn9nfvPUhIRrb1Hn0Wk4zGznjH0Iyhej9ApgEc0oUgjCnwH/pmezdFxHXTz 0VUN+dFhMdRHLlbFYBZBVJjEYzdBbT46qTFLJRGTVBLck7ce9XWmyc5wAaR0 EC2PjHULmj7Fg6yh00RFGxCj51RK61jfWUj+7RjE3Wx1dkE8IiQYo7UO7xhz y7Pf6bYznWznYdIu90/vWlrGl1bmrdjN3EtZJZY9+MXztpyKpNpdNoXL0dGY uGn8Mbaw5uKv7taVPMnJhKxEO1PuvP4784gRpyG2aTPvWK7XM0qZsyxoZxz1 VkIyylJ/Op2Ox1kUhXFq8uCnwOlgGUpLZtyntn2/ZtrH554dtDlICin1fzFA 3BaobiH/Ft/k5Puffjr6XaOfbuH3zxMAGRzGOnVfZUvX77CmSU34MRRZ4RUu HI+LGDkZNAn7k4F0nIHcrBETJEf5/M1l+8xp8C1j4AC8Nbp4u1rWeCCmSqq+ 4NZMM3l7yAw3n6o0PcXorbFHCGRmEciymGvW85Gn53yLdXD+azF61tcza39J 3lWArnA4k+YJ2TwbydUvPvdpiPI2pGIRLw3QnHa5va/xnVHu8N9I0hK+y4Pt MULlHtc2lL8avOZpMLXeSTO8eKL5k/A3UCwXD9QAahYiIwaicbVdnqaNhsIx PffcLEjGYz/MnCAxsaI3QXXxgEZjblB0pBTYIuS0RYKr0LIKRr0+HEk5ImdG uSa3hacE6zd8EYl4UALE3440D3Ty9zvU+exQpdM9R20nApTz1HeCbDxOgykq jGT8BiQzPKncc0LyJhfyNzk1qcOIlj1pPSQ9/lySnGwba0FYdVWw4pIGsTTj nvaVN58yHqvjJ5Z91KHlNVsKgS0vnKxwaGkz6EET26oGlhESlK25UTGkRkVZ UE8FJd1g7pn+WuLHXX7/SCwvdc91fozfCJV+ep+MvgHFkcHbwob2+JuumLsy XNilykZ9DdWrwQGQ/qBhxEyOJ+MqK51MHp/w5rxmC73YaLbfVstgN5vAbwtE Y8nHO/yemy2FSDotPJfUpsmjxM08I5G0CcsE0arWzcIM2uf50iREHVuuweiY JWN0Nie4suioNRdRwQLPBCMKvXsuf4Q/82IFLG5Aa0DaSSLaamA6nW9GokrC N/sb2P5iy3J8TFk+X5+RtKMdj6rtPcRlh4IMRVgncvPId4x87ztgmiGi2otq TA7BSPyTORtwtkF8nT6KxP9TPGMwOsQKPtHyZ7+uxdN//cuieUodaTe2F4g9 KOT8chZ42tQQMfhUPCGWi8k8fKY9Cet78lDflPoc5+UcWXiWQ8OAfcQe4RVU kDtOq47Kpx0H0Cxxtu1ifV/ddTavXwfedD9qICKnlcGnEjgtiDj4RFATEaVN 0SLirxwRA0gzY8U1QaYdDX9tomHH9u8eDUNXLPVTzbYQeYSzxtCIs17/oVhr 7P1hWGsc/EFYaxz3Z62xR1mr6/j/r/BW1wn/GMzVFX5GGnr5DJOBfxD+6rq+ lsFeG3FY12ExMoqyaMtjWw9hD/gIUZPLWgjuLOFJh2tNs6XwF0+hP40LLKh7 CXQRtBHUK1gmAnrVmpqmqbs4gooXcGUKfH11IWILx4pTwC6VJMTvgmR8u8dB Si6Ptdd6eMZOh+E8vBg97m8Qzzj0tX7yXkeGkWZLkcfBzwo/wNgZhl6QZ/bY 6W3IMqJpTY1NtMYKDNSX7Wb0PElIt6+thlzyvnp9yd5VL0ZHnBb2gj7mz6Ri 14rlDCvdBgcrGgpDaAphAfG5el46TXMT/+smKJNjLRvzU/XoqfpalrOimzyZ rMEHlgt/8bQGr1/jv/ZinoHGkR7laqrkeF0P1NrWIl0gmgYpIagsCvLEMalU 0wLPZPfrPTS5uKpHifNa2d7LQ9mJYKNh0LyfZBckoeuNB04l/WA9TKiexCmp v0buPQO5cRyZtP3lu6iJLa/evKwAkxXIJZZkP4ZpYOJj0gbQDGNqXXgKArx2 koPARYJueciWeG28fO1gup2x4s81R6QzIKdUYrGYLFW9SUyEadcrVuuoKwZC H6rGp/pGyS5Y4Rv3AP9I8vMwnG56IO0N5XiWCzr/N0QeS/WRpfL7u+Wr+/0i Te47wpwbDYWvK3I8L4+xYJDnMYQmdTyaoEwQsmzMnjciXbEGN/RcVA9Zbjjj 0cPT+kcbhzS2g9CUIC/jZUTSLfagx1jX9xet0So0VH37YDprXkX3ucMBrtFQ 1FosEhRPUyxJJFHohiZpv5ugjBEhGGvdLzSP3Xzb//HmvzEjWCxhx6Fx76AG EHhRdecePuXfxGHnMH13BDbGyO4UtIRo5F+tj3hkPQNaiIt3gpkdgBfE8ehF GVIlNxwt3o2fv/nz199+dQrwrx/orxueaF/sBF1flMu6BmIGbHgTN84ST+b5 e5MXW9ZMROI609wviPs3chByrJ5rOSATFOZNJa99WmztjJV0AjzHYWu2+s3x 2FsAkjCrga3g4qC6KVtqS7yRHBBLH16at36+yHJu3qFpSw7JBzS1vjaBVP5+ Rx5tUeU0aGnNETvXEbunaysc0orMi0lZbuRP8zC08jOSoZlglNye5UD0SQ7E oJYzVTQ6qcnm6sZP82KxJNXE5mdCiPm95k2tD33TlkeQD2/fQpLIQ2h3wjw0 3uTCk9qWDsdRECE0Hvs5DFLPJMeDFprRCUvtebpSj6YrrSW63ugA/jSf/esp H1H/f1JEzDhz205zkFqcEEvuaaJmly1FSigvIgVIxmM3dmPHs5JIKlgmZ1O1 7orm4Z5cLcLpNctG+g3LZt5POt0EQ3XGuSLJVwRmkF40WuxQK5TuFS28vmhh Ysusmor8bMiLohCTbZbnKA2sjJkSMAvMEObMiKBGxFBDUo+BzI/5NVXZYOR6 v0dStJQ5lliB0GZlOSjTsrw+ZEp2i9FFn4326SGfr8uwod3gjHE2P+UwTJTc sqXwonI9CFOMMQGEAUytGH0FyxxhqtTnoZCvmJ7LcviSKFeWw1dKfKNuN6Ae gfS7P7/5mlajkXkPT9T9978JrRZfC8sPl/ezZJWvRuTzQ1DM7u9vHnKjxBU7 gyy37si9L9Tpxw9fPyfEUkhQtJkJUdOMzqn6YDJZ5kn2ocTx2mxn88en9Wrf CSXsHQQZmpi8M5Ytxa3oR34REeaHr0RklL9fA8sclcU7o9b1+Uo6ya/AhBRJ Uu9IciONvsKciyRCF3a4C2pe+VO+troqe4BqMegQVLE4rX89Jffr9aOJ7bdq Kl7eUD7NonQ8jqZpEhZWDwUSMJMDk5qzIDcSFOaxmDCdPvjDRT3O5YXG/MJ+ uaqV9mkkg2Q5Pfp3b2UTDZNvfQQB/7q07HEu8OL6msnP5AHqxYfOMAg2913E PuiVbsk4bYFyq2I2T4xep8qWIgR+6rp5ihEuR3GaBFYW3QqWCb5VrXnGSocK R65a6EPag/RerifJnwVIEyxzPJGCfddN+YllQOAHjMmXlWQ+PgI/pvev/3wx mdC+P5NDBhYy1bZgVTmLvmvQuNyyADpNAzno25Yv8NAG1R7zFBphGm8onkDz AIbE2FbEbpAnVkJVCcoIz0TjWtremm1E+xq0Wj4yZMI3GWMHj8kSS1Y3t+S2 EK9ay0f5u3P6XKV8tinUFJQWWN6h8RqqJMO0Exbo+k1soaKhMOmnDj6gZDxG mee4hUlO5SYo4wMSFtF6OUIhKCTLA6qh/tfT0zMY4T97lVHdYRpRYEck+F6F Jvc/b1dqqrmfhPgEosDN3MjKhCEgmRyAaEsJhCqp+CdzCGO8yRtdn4I3r/2L 7trPNeb4t5KQ3jKxrh4AVLgj//4UvMVAR0ed9oadJpwt4IgNeQp8HvuDqk/u B5gI9zDEe+pXyxefDLkjQTmR0epusVwf1eZjxWJ4UJWJbl01FUgehEEWFSQY s0gyO1cYCZgRnlfNWyuL8TZ1G7nmLGhVTBFMJhUc5cbyFmcVci1ojeX7VDDt HZye5rPiQ1ctsmZLcatP3Th3c8yystRDnpX4WMEyOcyqNc9hgaiv8aknF335 64c3VIz+qCoDwkzx7eX334tYyIdvuDA14nW+yJfEospqfmKd0cRzYCtQmuc3 3UzTjeDZ/Wg83+0AGs763eZB3i1w59l9bjzxrWGa7rjBQEwksV7CrkBrjBXi sq3Q8ZBTxGTy8FcG/bytQSoaDPmMJ3xtdRN69zkmhJz2CaXyjAabUBkcknad 6qB7xKNEdBNKZTTTNfg8pxp1zPhznKpXhlS++6OcqsclVd2EPgtv8Pz2Cb2T 0Uw7489yqlFJq5uOdagp+TyOVDuh9HNMCHVM6HMcmu937ZCEaJLZwbHyTWOi q0nqorKlCNjw4sJP3fE4z4IpclN78do0fVHVmllnQ2KcDevOJlp36u9PQWVM k37/QfodSzfvwJfgkPx3MlldHNS+uqTFWMHoe5CSBCPrU/ADeNpcJNisj1ye tTOnzRXzVSujqEWJPfb7FE+fDkjykZ6CBC9u4NhMNVQRpHR6VywbfgpGl7RC sS1amrhCiYaiikMexU6Bdb6pC/N0auVQUYIyxslAg5Id3trfLBYuGF1zCfo4 wRJxAki0GJWg/w22BwWUfTAISEAcH3U48IjBEG15WvVmqXG28De3Adp08Vly F5+W0p+iAeDDHF4lvwneVn1yCtjnQ3oFmdf2rOOHSUIw0bC0sxaBW6DxGE6L xA+s8oGVoIwRWGQDU4qoV3EMyHejNqQUGCGcu6/B4YYqTtTLSzSmyZq2wkYz cIoueljwSj7N0gqN8D+6OJ6YgA5mnIJhR95oxuUU6sdq4iUsGooXltwNUg/j necUwTS2Z5ym/sFl40b2WrxXf1/Obmfzyf9Z3Be3Cd7QK/wjX67vwOsp/+0/ sjy5n83Gi+XthUBU6IZxPJG8jBYFlpiID8GsmOXLFcAfKU5KK/CeFENaLua3 Omek8hWeMLvDU37VMpPINfNdYx/Z4O8OQFfJXg+kFw0eo1A+avAAsU8a71ye FRYc0wI2SmwQC0fHlPSMmezbyeS2NDcP8uLLPHKt3rLeJcuHRWYivZYthTML TH03DcfjIMnDKLMKN65gmSB81VoTJiS2rFH2qXIa0AZ9XVu4B5gDkNGr8WYg EsoCnihv9jP+f5YgmAC81Kas20HgmJlL2uI+O8vyXxL6xzSf/5I8zOavXB9z hhbs6OwhKh/5WRTBKb6NvRD66UYs6YbZhi3dvahWQOu0QcYpQT5/esD7VMyW K6xcYK6yVgqwU98NHuuXzH9ZrHKwmP4yoh32XcMNBsav0m3rjhznrI2mN/QR 5+Z5bpL7+DYrgizaHPCyCartyYl+LAAmJAEwoZxw9zHBBJmwE2K/8+yP/A/+ PZWnxIeHZTjdl/x7ba5eTcyyVX9TVzYe2MVnms1IrhRNfXhts1rwKr28+PcY S5lii3/BegVr3unutrXuauxoVD/rZT7PkvkrRjuzdWvy5429RIhWVsQo9TDG hk6QhRvj/TbDNcNZXc+mD5ywQ7DTugJShTIgXiw/EGlAyOOXh2DdrWqu2O1g 05dfT4LT1Xtdbe5VE3f4rcahEC28addrZHUaJOZIe0A0ezM0u8vULoIpomke +6RqWpTGmWd5mTWAWuFX1Y0jF6TIRbM3YI0AC+j/TXwUJSfsP90vpsn9ZZYt 8V53G8/OXtQajygocDzHktdR58MnO1fL3s2M9Qey1viCRJRqIBLllC6Dxk3M E1GYdZGmT8s8o/UJNrjZbOvay2KaX71qzpB8Us0SD3N9N1uB+9mc3CKY/y+X OU0PnuVb4a/XFibQ3UUkeAizALrpeFzkoR97G50ANwC1x1+vjCA4hST9yCn0 akJ8tgAkVczsPicbjT/903d//+Ef3+PLbbUiRaIxYFpK+OCMqYIlJmgKTYnv JhPxG0WBPh2bSUhar/YXtLbGLL/PzvkfCUYmjJriM8bw2SymT7e6CeCPJxP8 Q5rvhpYtWVJeiAUcAyzwYu19RSaF29Mig6vZb3l1BQlQ1VcbJmbToWV+9P7g M8PCCqEhMeMRgQiO+SS75ZddiS8NTgTovhPk3iRC7cYPtTdb8NsM/d1dRKaE LHWTCGvySRb4MN1YbWUDUHu24ItnABhGVE0L+VPA9/n6269ek1Jhy/xh8S4X tspDgIE+HDGrzX/Pnnk1YUBrRzItjdbaccD/+hI8g8NDXmnuu6//+vf//vrm zQ/ffff1367Jl8k5Rrtn3PoUJEcY4AtSJ0NI8KMjDAV8+SUdDfy7FsiEf/q3 v3/318tvtRr8+HgXqQ9gxFPJqa5NpC7SdLG4ZzsYUZ94GIXqDuKtW2PUXil7 yAxahjspNuuIah0vZgUYaffqqGUXtk4qAiNqzHgBqtfa6+9++Ppcejsrv/jm 8tvvv2YaFfKYfd5jWmR5wBdf8t0Q23RIHv/Uj4hbOttqqdq2+OjPabLKeeFu UWS11qwyX4oQJQZZ7gkuqr7sS/yPfwUuwMcX7MvJC/Y1Fr4nuobUBPnpvGzF FjKZfDtbrWlTeUiAV0ZvpjZYLz62d51MGK68oGhCwYybyMI+FyjzIsky1pT8 dd6cKP+re1rsO7ZO3k2Z3KFMv6wJnuwheOa4/qJMcTZqdD3SjTmZ1JAcz/zF p3PwQvgLix7iKNkHN+zPGwn+DeaAN+uHxzg+VzvXcKEdAL4hBYCDs9mciZfz 9YvKMPElkDG6EwbB9Rfmjaea+70alt6Df6gZddW/2TBGeU4Ylch9QHwFLLoQ d4LpRh8S/XX4bt0W3NPRvhTvw9RDIQkvzf0s6GcB4RDtLnHWh3LaiCWjjOop 7Kck5odxv/n8Q5Km9Bg4V2OpuuqZAXHL2S3zoT0+BPfvkvtTwP9Y4j8M7XY7 gMqmO5mwrhtMegTWAXMlwSsGHz6wIcjvxx8+vFs9CrmyDnXEGo5plCHhuKeA tv7R+bn6rFUKZsrtDt4JPLMMc1oUECltrKx4UidhYYHRNM1I5uxp7Ln+xoiD jWCt8FjuSHPwE6GB15QQuCrCmBOp9Ps3i4UOn6kqCDYWda6ja3enK1KlouhM iilb6HgOBZ/mUAjkF3ruJ0KWMeUeItMxfdjfN5a5PKE2Hc51jMKTOk+rLVBp UycR5JK4GNVSkg/ECTJnO5TrCl7a2LHx1gEEsh0I37USw17IbO3/JPP16m8k Dxv+8ffpL9TUtMzJPWiEedsAu5pMRI9W5ihq2VYruhQuTD51YQrocpl2QA1n T8Tcs16AbEbECQ5vfXOXLFd3czz0zcdkvpqd4i39BNKn37DSIbrjlc2/WNN5 gPd3yZpCWYBkShJPJ2yJRPga0w7S7LE0eDmZkDVjEWYzGWyvypQ1YKr6BNuQ gZVlW+pUpsUJojwKxuMp9BJ3c26KjWB7kUFcPfIj+siPVPsgsQQ+TO9zoLcQ cjj4mISR7c23i9vbfCksafzPjSWDNfyc4k6lClAmfcrkQpow4PhIn9tCsZZv B6xWrdgAzCkYj8ebYH0CeFckw+SbP7Fdqq44dRfbGhjs6ifwJz6aFbo/3a5e xY7jwvDGMZMylB5lJDzCggWxdjlBkPmWL9sqTDMsV3s1/ZSFswgYFTeP6+XN GnZHZ7P3X5EwSk7qhSEsFrqqGzv2UkCy2VRygSqd6G2vdb5J0PFvHLM7Xekh PJhh7LieR1IdRAH0LdUgFabVAZe9mi4nTBFyJhP+C6NUntZVo8hWtCk96fG+ N1m+nL3Lsxv2941TkaGA/rHNYI054+9ZTpLxZ7v0VjmvZqmZHvFGwHKEhgWt PszXdzmx8mfytPogDkLOjdOWu6SzR5kxGEUFRONxilWAONnowdkN0wpxyl5c LKLJ+WP+vCv7DsgbTdNs8XO/YhlMqPYwEh20LESR/jC9FhhFmLg1ze8X7wlO GMD5iigieolPA1NSkMHd6Ktj8FjmxnnMzi54yZduoYuMWM0J3M2yfEUkOFq9 9mgHqBzuiaV5jnfjmNl1lB6ioFQR5gkiJXtyGMHY8oVGhWmFmWUvytIQZWnM z50JGKlwRiKwqotIXE2Yz6WnqeZsd3wb+Xs6Ot+1PTrRQ7jJOkGak8xIyElh 4GwMR+iGaXV0ZS96dNSYAesVMjFvxkwaM2h6ZmVycf6xK5sDNN5APDeXgCF+ ucHM3jk/OGn5YqPgLfAJd2DmMZoBswp88anPu+8pK3HZlHkxuvLvEf/NOWQ1 pVplKqUbcxysiddflsDcwyN91Y4S1ol9301+g0Dh/mJhfFsC+sQVIN22NA+4 WuamTRGn7IrDdJVT1n5hfsqu/pRDSJaDf8aleKxpK52Y+IWMD8/rWEDnBL5s zLHtwtlRwQ5eBk+ehVvNQsJNOp+OC3BH86kci8v9pBU4bmbz2VrYC2NEHRdj v57aeH0DOYE1Zkl6z5L72W/czUrp4lTe7yyGhCJUDRuhhI0bnPLN+9XdzM7K 2YhfKgzWfmGOwbCJwTZXTX73ihTqMNJpq7alNpuFLvF6dfIQupGdZCBBM7pY pPZS5Z6o00RTyyoKwOWohfsRFC/3l7W8PKypsS0esFTWzOcpljZL8bV1lMvJ 5FJrPZfGPukamwLoknrlmUgOjjxWLqjS5kpW+PXygxKfvL5bLt7zZXQJxVV9 ITz/L4iD4eOHHVVPRdzAJo9NpzUn20acHlmcHvmjtX9p3EzJPMGI2aIsZbFf ktVi/qra69Zg+429ylC9wAtikgLcCdMi3hh4vxmuEfloe/IIs5BGmNVfmkqv kwXJHUQ9Smo2Scp+vlqUX4++Im0uDeqwyQpaKaqYQSrbTCZSBwNFsKYC6sYS GoZfaRhllEPZGiuOb4WOIQPRqY+q9IRVzbdnF5t67fzBC/IUFKNjPPXx8MP3 eNXlmEp884x0n3p74Y4Qe2kapuNxnKVFgOxeFBSINvQl+rCq1TR206klkP/b Iss7ZF4RucddW2cC3Ui3Y/Av7qhK/qJ1h/f+XtrDOZTtRPmcbeQd2uwj7Km+ j0JS3rSYJghhWrY/xxpUi7Os9WMiR7hR5DgT0cGssORGAYKH0HR1UOJmcNP7 xfx2U9tmYWMwcsEhcJ4L+s9xfvh275aRHhEz9b2HRiEHzT4Ce4JpEbsRiTlw siR3t8AeaBx0oOnH/Dk84s8h84JvWP16XeKCY1C4nNi/YZVv93tSrlmODM1C V1jsw/ymNcdndxfxAJy6XhxiTSJxp36wuWj9BqAW5yR34/WMEa1nLIoVCKLj D6Pnch2mUhAqwGgDtWsM3qXw09r7ss3fpg6HCjelob40y1/yGrQ0sYC8AP7Z HagK68mF/m5bdFohyJAi6S+xYPRS99BHGt3Nsiyf78LvnN0/5N+t0ZBAlOez x2PhKo0sEFnuIwQPP3Njz8GCh+d66eYkxJugWqByrR+7sIjKxx1c2nTkRoaL U1BW5SBuM2f0OYYEWf5wCq4N7jTiiruxR1d1SGUCoASHv/nhqAuaPimMWV9N dCkLUHVOgbv/J23DZDEtx75YJssPRs+PzT4CcYvMiYtsPM4S6AaJ3cu1Bqol 4pb9akHoVBF7K2LN8W/P5+JV5flcPjReSwcf2lv8v+cR7dEZfA7esGC/JcgW +YrYL94nGCzz1SpnVNlVxruK9sLTG5PMHAZTvL7LwYrk/niYrdbJrzSck8wS 8302T4ytJAIIEGfwXUywh7p2n7x/haEYmUWqtqKI1NR1w4RUhihSD07tjCES NCNkk9ozgYzc9LHk5gXSuzz9Fe9oDhbLDGPGopaQfSVsIpdt/lnFKFvgj7Gm 9kjQdbXOSOgTPqfXr/FlLr48+mn+Uq76buCrtSVgnd8WfbhugUe+2QyMmVTK ykptW9I2zFX3MF2b0ROkfhs6dvbKfGc/iaRk0KfP1D7VE2uyPfl3VXo8A5CM C1KweFPWgp2YYABzeh5ivLhPRg5Bm1ZspOIjjouQ6yOs6KV+7Gyuq9gKzoqR 6Fz1RZ1AEYXHfhlVXpHHNPpMrueKWc5H8nPE2orvzwQo/C3LmEHzxY5wSxbA ZqZs1F4nrEF+P5mwNubvDop/IAMuMvZF9GKPWDwANa6C4wWRtwjW/S2fkQA7 fJvd34O7ZAUS8LRKiKBKt49MHWMsifqr5rCi6eLwvv7o/0yUITzaWPYBGb1M slXxsoH2Tfvs4uyCb0dLl91bR3lG+Cr1b6+798HI+7pqK3TuyIVRGmBNJYzz IrJLyCBBsyCZh9LFOqaRWszZjHjz8EukrruWjxElt17h3RsVEBQ8dwAzt11N JtUXDSZOsAlj5xVh4V33jAhIsAKpJQvdMAxgRx1StdKCuCsY58Z9R9+4TFq8 /O6v4JEARU48Aau7xdN9xmjmkrYr3COAF4XlmGTNwhDwCVAp91TB6Foipp34 Yir/MMgp3jMXjV1Cp2Tm6X2eLO8/0NC4fMUmiXFdXgbbK3Fl1sHhad/mc/II n+NF8iws0zxNnkiatMoDH7xfLH8luSPxUJhj6EBJ2SRn5E2ECn5U3CZGoZxH oLOtZkzmkdTMddHGXMgN1CeMa2V+uZXNRWRanOdhMB2P02jqx1M7o0IdoDG1 Vl044/Yo4/Zrr4QN0+UVjapqQTOM0ULXukve4fOr8XWs4JBzIw/WO+Ks9syU Lbot8W97cyGGZIGbevF47IRuggJ7lloBtDwnkQoY0jcn6DRT4gKqGx9/4Fbl t/igTsFLF6KXR5zL4C0nFJAKvfjhCWP/MqdBWEzLlE6LEOqkhPpcQn2ZTNPm 1blTRtPjTarcqLbSea2ty2pUMA0jOB67ISbE3C77Vg2e3cGKYnq10Dy8f98/ Uaf2CU0Sg1nXHd61e0I+PJqOyZvM850wL3KwWEq7X6xII3rdUjhf4Y2egOun /BS44Pv8EdDcwRMUTTwPfP3VdRWW8/ZFyTjrhxdO3k4mbwl5zx4eMVuYrWVE EUE7G7rrrdxagNxxezl7R+bOUJAg+nP5iB9KbsJ08H+qRhZ3QrCVhOKtMIF8 IKiGLxGs7BczYlzBG5oIqYw0Ip4my2WpOv5zxAJHAZn5iA0+A0eNQbyJBAOQ 4pSzYpZSW4KQYkt6ms1ptftqpLPGTrmTSicGyRKfGxn/p5+I0vvTT0cvhTaq dwI40cBr23lGr5VbEljnz+tW7wIurhAe8DyjG0MfUqj1GXGHo13vlMiJ8JZA fnZGtDYuEaP+OZng41EHCCa6xMcMNJE4sOLwBd9MvJNfvNTulxWXQkjeGrI3 dKK9RHzKCYyFfNFavIGiaeJCLOZnsefFftKPc1kJ+mUPigfUbR9xeiQYML1f LLE0u1gcYtlaI0O8S5Y35Gl0OoLtosTuak1Nzy4SWphbOIqSw2JznLKrsbQ4 W58cyfVrFE4mNRYyXxihwMeyRBDEvhPYvV3L4IyPTXTgryhh5S5IUxZ/TfMW k1+ZC6x7Cqo/oPQE+T39Tz3vtJSVAJ/Bn0cEGFZ0+M7OjBQzexBsJpMJab8h e4Z4KMI6HwUsbHk+teUFTWnqex4VV0MbCmGUn7gNxC35+yfRnkhiqzFdiq7D DjO8hTUzw/PJh15c6GFGopzZ9IyemjSdRLBb4boRKUccZo4fFXZePTqwxjiu dmx4QB6Af3uak+RID8kz/j3He1scADnhEfmGOmclp4ydVUiYgAswBf+O/4sF s/POcGzGw3YEVYoiUbAI39vLBHxx/sVL8ft567sPnwwzedP58F/xlPhvvWZV eTf3nV4sZApI6BH/DJiptUocQUyJlNWw3fulnPFz+dsHYVip23L+yvb9aAJe kr/pMZz+ckS/A38tN4F/f0AbPJ9+oA2++Gn+xXk7TDF0HTaQ+mo8GXaQqRh5 fU3wIrxhhYwpvNZFPOtlPgphOh5DJ3O9yJ6+60CNqbvejUby0ECeUm/S+huI yqxFscxz6lwHlov3q1NwfXyM5exl8kETIl0PDLHvL1cPw2LoCNB+MyqI4P+8 piDwb3jp9Lph8cngx58ZRFq8ofkPD8Mb4u5McXSI+IV/RsLijsmgjq0kZRRN skLCn/EH9FvM+O7PmWWSfH98XJC4JiwrL7BYnsNslOH7P4OnoGgKaQSNWZ6T Y/zN19999/fvABUA1ssPRP5eL0g+xu1w3KdWALblZCqfaxoe2yP767TEVWPB Xu4h8s47Tho64XiMUt9Jp1sQmpWAX+vFXZ2pPd+p2/MPGlZ8IJUxuAKHWvcH pnF/EjLjBsGwTemlrmNt0ShXVVrFlojHTrC1jGtkr8hapq7I3kn+gGWKevpv Srw5p7BdyNs2O3iPOisPs1/zV/N8bcTqpcYc9woIPScjDkNF6oeWzrUyOCO0 kztwBQVRBcWr8O2SxAe2O0WT+CTAjZelRMJO8hIkI2dTbZUdOHj1Oh6785E8 uvzcTacuiTTykryws1nW4NmdEKyYgk95QlAd0Zu72X1WPfP9I1mSuMWPXadG 39p0L2QMVjqieh57OuCxoPnyJWhGR5S2g2mS7So0YovHW7pfjy7+Z+RxWmsu ThgiL/NDkpoBJW5hF4BZB2h+xGUXGvhN475lWyves6RMUIz5IZbR5/lSuQje zZbrp+Se5b9kpZAIlxSB7/xbAuqYwFhjJFkBljoTzFitaCODQV9IYtosczXp s8F8wJb7tKIr1TyYldbqAz4X0nQyIb+7Vc03CZ9GN+m4mi/+g5V/6sDqz/Nq xlEijozEGLm1yFERBYGH4vHYi8IicHpwKQHPBoVZD+aKEFI36ZgnLSfpTm++ +vZ7mrd8lSfL9K4la/lHKVn5P0hG6i9ZNnaWi1pKRc0+bmQvJ8BI0nL2dS3N c8OAXYXa0qmsnqYcB3eQDNCNG3nNRSL2elJzh72weBF9jfKiGt1/f/3dt3/O MLrSqo1ic2jQwfSp+NF1fi7LPfBgA8LPq5TJI5JkMX9+XYdzfHF4Ctq+2Vyh qLlb+xy7EjSUUYF+1DpQPJjyQdcYxZy4XpGXKowh4GF1K1X1otbIkUDkR2Xy 4PjiyM6SzWgGesjIgUFuLd7Fp1MYeBGm8Tz0orgPjXN4FjTOezQK5IokoJQO FZfVy9ElMK3L1tle7yTbTDwqxCI8FTKdF1cviM/PixdYIKWJvNuZfXeKCNMU oC/sw2XY7nrIKDRPaizi34MsDSDGhSAPo6TooTZwcBaowDrQzaeZXehPefPZ L18Jni5jBcvdPXpDUr4bIsaGLl9NJolBLm/wZjKhuqW4cJr+HdpmZAFfgUy4 GWfjZHRMrpgO0YF+D4SHxylYLYQ/FsEY2noHZsk+jhvs/CInTMyxjbUWpkgU hfEUa6mOl8apZ5dxswbPAt94D4pwPk1Uwt3BG+kV6n7zL8r0Mpcb0tGs9HfA yUYIHfcHu5yp1+EJ+flig5hN8VUwqs7qewKbimR2D5IV8ffDyEZbzHCLcQ+U iJ3AggGx1sJwUfie75GysJgRFb5d0EkNngVK8B6UhqmDSuXL87h8WJ3Nsgkg bSTH8AX+b548SGGm4nBfvxbx4ht9wDU4Yg5MNGlz/m5DIsFYhS5Ek5E2UoyI hxsw4is9BPd3K2FEw9xzebcSVjT8BTFN40/Gs2YsdMnI8DxXT+kdmFGpPJl/ wKtcko6jHaRodKsUVni/DgnjnbEQWhv0nc9+xZvzau1CI7W/1lx4bueFEwQ+ VvsT38sd3wqB6wCNMLjehQlUHhGoWIy0KCfDqqAfXx+xVDvnB1J0c+UcIEIP bgGtYs2TchIf69tRQaIQMArpj1eSfprOUWZGYb0jVNn39+8nk5Z0MqYuUb7l BVftrZFwXWte5shwnYRIVFMnjaFvl+WxDtASHVwdOsiHzk7aZQYXjBscNcpz d1miTNKCnr3eaUKVkRqoBFsHgHwACP4YyAU/F3YZXZa15kJej3OUJu54nBZO 4hVhT+wyvi7rXRh2oQq7quQL+H+8UomS/uCyM+E8dfYnT5/0JUB6GKxkKwmH MYwrQJ8GVNws8WUHj4i2p7qq0osYHWutvRCM/awIiGBcJGmRIDvbsQLR7GDr fZoZkng8ZptRtp4h6baK0hc9QLcMWv5xCiaTggSSkPQa4N8/T5YkvBtPxBfb NT3BsrWwmyIP+il5+vVQWuTW51fBMz29qkfDpnIA5gneu8ckzYlEdyDJrM9g RApEbjTalyZ7g05SIK9oTgyNG5rXKLzqyXhIn57cu+fcsCfF+IBifCBj/ByU ub4AoJtM9nAyYUZY9sE0+U188Ewyf4EX3W+VW6N0ZI/StDoirxVu5PSqdOCI nXhxmvukGIxbJI5rp56pII1wW+3EHIeIQ0NY82coWL4mwnOWs3ye8Y9vbjBU qicxq7mQh6vPmUqjNBNvU/9XZLdgHg9Sr2l+S1479dlEVUWPGmhMO1P8oi10 8ghVnkTsRZWIWfa3E8NcE8sTU9jI7hw+l24PdIj6uql70/O4mllD3COxR9R9 iUddND7ZiX+cy3Mjd5SpeKn81Q6DPv+cg9k5ODmZlSGLxzM7oypDQZLO1EgN qDUXakDk+7GHL/QodIOgsAs+qwO0oBrRhRk2ImLYiPiVQMKUKBYVsxyzueXi gUYrLfPHxXINph/A9TJ/h3fvOvlwj//zer2mv/zH4+J9vnx6HOOjHydPF1Io /HVVaEJ6LiMMnJCPgXG2grOxBtOJxTilnUQXxaTWxrO2GLCNLtMRWiCI3Ee4 DERpFJE0P9M49qaWUd8aqBaoUuvHqxCRbN9Qyqm4elrmLCa4ihR9fMznILnF Wzcm+8i9NRfv7mt3t4aelbTOjWPDvV/yn01jtVdmc6QjFXjm61ZBc9NItPfL 8r/64OmTjeuqEO7d/cZM0hvnbgOtJqpUpp15Un7AhEJaABx5VbAPy6hFHduX t+kpLwx2jP94R5nlCA+OlXb3qOHOSoK9f6VNDtvaaE6BRPIRLKRpIwhvFliH +c5qcf+0pu+x5bjNYfVAq+AxSaDbPgSJx8yLFWo3oe8KD1h3F43R2B27+DQy ElInYu5JRGixuL9fvCerSjDZ0TFWmCvR7x6XsweSAKvKt92DaT0+FEY5fOXW wkrvoTwjRk6XZMyO7PKR1eBZsCjeo6Hf4H28erqd0EQK75MVoLIi3beCpAS4 nb0jf7ANHMtO5pKPOdcbsEg0x/R1s17c8HQjZp5Mxn3VNh2VMQG+CY+XeZrP 8OenUp6N0fVkcsy6H42OKKF+/CR4tk9ZdlCz5f9p/evNVbLKJxPxW6mfNydN XhtPD1d3i/c13UmTAE0YAPG5yIi4owJy7XPDYy1WedMh9HGBORk+8PWCl5Po mGQv7endAmPN7D63uOSlLiK8KvWjkBiE0wRGeWr35tkEakE/cjeu7vpU3a0H 0BEcK6M9eRdQ3DBaeVdQ/cgB/078jm7e3fAvsNw0IV+2Pv5UVQgqoPe0hPWu 9OEtvD0f16+SJ4xmj+ulydHWmouI0AQfa4aPNU+LxMvsOGIdoNGR1rtQnuhQ puiw673kcUQ1I/Yf8PZC2GFFR64Mvj3GO3efU7bA6kuwfI7H4PHLx+dz8Pj8 pVNmdnw859yJsiJMTvl6RFs6cl/iQff4TDzsHo9E0Mvj8yn+H1YyGQiqT4uZ jMQvN8u8eI1nuqygTXCv0XL8SELEutSIUv/cAVC58pNmK/95UdWaqQ3yzwt5 C4W+KYLylJblpmNWRpsyJu5DYoXyoZolRA7l/3AuEu8WpDv744790UyG2nhF wVy8zN3F3e53kfzD9+ztUhiPmW3H6A1Ebs0JD6LMyWg4W1rkWWz3wFaDZ0p3 VQ+dwwDdv8Ujy130siWN7uV33/3zooxbfZqTIkE0tQXeMVLyckQagMNkY2xb HwhydFuJnKTPohiR9uXvPzo/H5UpI+qpe/lzQG3c+VEVVf784/xn7uTEpvPc vK9V4V1kfvg8+XrFwQZGL/9yayETT+M0QRgR3STJAmjnO1eDZ4WIgTPWRFOW PAuUTOv7P38lkjd//9V34IKrib+OyDf4zLNT8jlm5UTWZIIm/huLmkeYVY9q cCaTa3AETGpyGfeTck7zW+prYs7R+CYULFUJe1rkXlwe9eKS0/frm5fPWBz5 8eK/Hh2d4pUeHzmn4PB78uikk3tlXN1ZKl+7EGB84FiApWZfM/dOpYMQVHzf c6CH0TRCbu7Z+aeoIE0xtdZJqhAWG2Y/Jyf45zIUmFosftmQ7VwK/e1qL+Gd +nT5OjwFLrwYIXPWtYM0zz2yPMsbbBTpoXQQabScNIQZyY4f+1mU2lkfVZDW mBH3www1TJy/1tnhRkv7Ttz4fwsvPCOdVekgrNKOl0cu5hh+4KDQsUtSpIK0 xQuvqikYE7ygpSd7soy9owXPp0MRZHYxCvUIUs4RH/ATLQ3pEo9bbqnYAar0 eB6WdjwwyrCodBDGDeQhJy7G49SJApT0ZiGBcZZFtRM3bATUsBHVSsVtOE1W 2ytZVkS+WLwmAsHFaFDZlRszyOi3F9zqPNjoIuvxFvgT2uJPKOfoLNzCC7Bw Al2UuL2Fk7AP/oRhU5JWGQrLYPOXi0osfY0/+8spgBdV4DT9jPz/BRapX/+F fv+XC+L4VtcFZYjsP/9ZMSwB+D8pEAGw06tc5l/m3TXsjOH/96+xSEz+/wKs HJ2oXW/O2J5zMVrhPivIrBJF+deAFNT7qjRLnVW1Fd56kTuNHYy1TpamgW/n 7SVBs0DYMj+WR65Fj1dkbtx+kjakQ76/lOhGkr2//gs4wXhsoNaZ9VERS+Gt uDO60BVZ4ZjxPvlATPlZnj2lOfgL81EgLwC7qKXSo6Ia3vjH9fIhfzBLCVBr XlZC8P2AFEwMssB1QrtQyzpAU1yRunACJoVVyH88SVu+LD3npslvzDuc18Yu 8aXU468vpOAQgkWj46PR9VGrm55ioN0BxMo6awTsktgwBLzNvoDUjYHBwD3Z flRYC0aHxDP1aENM1Q5uYq+UA+gSCs5Q6RTYB9InhWXUcIkZRhVA5dZC0nNT 30eY50V+hvLQ2uxawbPD5LLeJzqFkJahQk7tsVPlc8ySxXDgCAiGR2+tT4ba QHvjksXV+SoZTYx0ZzNSe2OJmTaTrdy+pkh5MWIYcUf/nIk/8bdXHWLs7lD1 jg70yx4H4i4Zt69HtWM9AuX69zRwJFY4EufLxpztb0zktC52v8eJoG6x+z1Z 5LUt1tnjoIFmofscL2IEvN1LNUnAjYxS5UuNhft2mPt5AmkppsyHdrUqZHCm TLvsQHh2dIo5xQn+KZxQeUqMl29eUpb2+ETS6VAnNOa1TAuitgkhpAfJRE0j FXsLHhuhbBI2KgA02YSZgNGxpP96et7BkjqhmCyJAeDnsJOFXeFjLSEeV4D7 L9IYosmCOTAJzAbpU1r2Zqiq8+D2m/mb2WwtNtMQotlm/tZ/2RUE8gs/XSz9 MRMJ+a3M30hb0Q80b3a7Fsj5bUGPdKgxudxBGcxAYwq5g3KAocbcNl8fv2ps rsXqVoyTPA/9giTLDF0XWj9wCGg2l6JfPmtAh7xrQNj5rtH55HUN1u4pwD+h se1mUx9tCeiL8v1czuZ9dN45vVt5KKrcmKlcG3vppsj7NqcntKsyLBWdgi/S LwY1Swrl5XOMHZXZMfqQlamRgLcV78mBn2VRToRNN06RXaygBM2GrIR5oOYg LoygLj99Ha6WFWetiMm0l5JxrFnZoDGnHyTjLfyjzFtmBbwER0hLcMTlc0BF Y9+7YOVSA8TKHX8OgmOlNehU4GuiVVyAFWQTgp9lQqif1XntmF5rtKXw84m8 KMqwqjctvMLNrS81BsuU9lhrifKimhta6fd4UaXW2iBcApK9SpdGn/87qGWC uxpdHibJhvd9Ea7R1ViKXv+/V6UhnEfXXhHr3gWY3lC7MmombdPhDZOQtsOc uAfWmIV5i5bCiTEPYOROx+MwzNzUMhlkCcsYa8qIbiOvnxbv2jMVy94yJaQA o7ekxMhbWl1EyJYQdVc0pziyC4iSfEL7EhH+qOZzi8GFTRzajUTd7w30aT4r PpjijWhcvghMi6TwyONWFseWNbFkcKbYU3ZgCERiWei7dCsCNRClfCuitpJN l6Zt78bDupx2SYRmMruYT8xiIgzngMdllsIqGN3q3PpreVMA2Q1elW8H8uK2 xa/F8ZhKjqKxyGsUJY5PSsY7uZ86yK5kvAzOCpfKtyVa+ZoWwPZqsTTiwOf0 lefwYiSiRxa/nrLCiDTBPXlO1fRhhu2jrl4UdeeL9xgDfs1ZvPX7HDwskjl4 f5fPyR/LPLknFZpp0sYKpVWcXCwqy9jRpriZCretwahIXtTcp8Q2aYWsZE1G XZNH/ukTqRZAW4vRdmewIROp9t5sKqy9WPguEhTCSgVTcvJ987heHo3sH3Ap zpp6govG4iHASachisZjBJ0YWhZDlsFZEVhUPgSEhOGVMTOaIGmeTaDjgZ8b 3fkZHW+yJHd6HhjA0jz1NsDUDdLyI0Y1ipw9YIMzIm0v5wcwMJ82Azt7g5Ic Qqjh9fjRFbTN7JGuzjLYSPe5e9dIZoEtR//7f9reTsvFNF+u71/lU9cxcphX OogCT0nuomkwHhfIi53Q7jVNBWlESGonWuWDersGQT2tw6gqcUSvFJBnt+Qy md3erbF2ckrSCCzzYrFkyXvA15j9feB1oP60TB7vXtNKYytavOWUfX0B/nu0 Xj7lrZk25Ohw/DvJEgZq5aY3PVFsxoEgEtHxGM53eZLRyY7++xS8vF0m7hj3 fXkk0muTNtlshcn1A6mzTcoFzNJ8RbMMEuTEv68Wy1Vf3HFtccetcGc6jaKY hC0iGKMY2annKkhb3HGrYAtaGYwl0trsVf+anuhVZXk+Mvan17aUIxE/1R1b ykALMmTbtT3egZQQi2u5JxKY1V1QOggLqY88NyMqU+h5PrK7hVWQtkhQFmCQ 6sMhyScwoTUYSs9NUamTEJf0Kb1TWHnv0haJhUYu2yQ0UwXJxXDEb596dF17 FHdvSCy//2SC+7ZlxhbmTNwq4Zj2gg51+MvT/FfQxLWSqdHvSXb0Oda3/vWU sPRZZzRqY9sicZSx8XngrQUaF0OpSNZyT9PoU2aoQiqzcmj19iKOO4p9NHXG 4ySM8sSzMx8oEC1JAUp166jixxmiWh2xqo9IGFVVGUrYgc6FofyM8kmpmAxr +NcPfyapyRORRZ0mKp8emUljJ1vDrPoqcp5UClEUuCJSakLqH03PGXc0XBL/ e9oedm6/pA6YvZZEf5uWge3Qo0lzPCYt73qZBwxipRbz6SAyEwpGl+aq/Nf+ 7P4Sf9RqKpT3xTR9tVCXO+3nbem1YbAN2wgsBalAClr1HN8lGbDdJEtiTLb9 2EbQQ4wKSgmcco2AXZ9MiFnSWsFSNDtNT/rihXquHdRxBsrC2c/U2oxBuudg 8wO6eT/leY9PlVwukyqfqrBW0NQSc/L0Qd/QaDQHKS+eLPE1Sj8fIfpUr7+0 ZMWQCBfTZLWL1D9eC9KyRHmkaDL5tbUnXXg/pI2NTC/19sJUXky9KCBp2/0A OqjvXRcbG2CUPjTNDLHB+NwGQ/6pJsDTelaRb/P57frugrVlaUfY73IrVqqL uHVibLgGo8Pnox9Zx5+PNqOteU/plQ7IvF7i96xzWSqvEb0mJVSjzLkGic9j qpHBup6Ht1dvWewam/L/B89N5BrsmwMA --dDRMvlgZJXvWKvBx--