From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 19138 invoked by alias); 21 Sep 2010 19:41:53 -0000 Received: (qmail 19107 invoked by uid 22791); 21 Sep 2010 19:41:48 -0000 X-SWARE-Spam-Status: No, hits=-0.4 required=5.0 tests=AWL,BAYES_50 X-Spam-Check-By: sourceware.org Received: from smtp-152-tuesday.nerim.net (HELO maiev.nerim.net) (194.79.134.152) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 21 Sep 2010 19:41:35 +0000 Received: from hector.lesours (ours.starynkevitch.net [213.41.244.95]) by maiev.nerim.net (Postfix) with ESMTPS id 784B22E021; Tue, 21 Sep 2010 21:41:31 +0200 (CEST) Received: from glinka.lesours ([192.168.0.1] helo=glinka) by hector.lesours with smtp (Exim 4.72) (envelope-from ) id 1Oy8iY-00005X-VO; Tue, 21 Sep 2010 21:41:30 +0200 Date: Wed, 22 Sep 2010 03:03:00 -0000 From: Basile Starynkevitch To: Basile Starynkevitch Cc: gcc-patches@gcc.gnu.org Subject: gengtype improvements for plugins, thirdround! patch 7/7 [doc] Message-Id: <20100921214140.3867b748.basile@starynkevitch.net> In-Reply-To: <20100921213151.0332d8b3.basile@starynkevitch.net> References: <20100921210301.d92889be.basile@starynkevitch.net> <20100921210829.5f2ea8b0.basile@starynkevitch.net> <20100921211217.df1ef337.basile@starynkevitch.net> <20100921211628.969ed469.basile@starynkevitch.net> <20100921212431.f07dad12.basile@starynkevitch.net> <20100921212926.f7688cfd.basile@starynkevitch.net> <20100921213151.0332d8b3.basile@starynkevitch.net> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="Multipart=_Tue__21_Sep_2010_21_41_40_+0200_BlL1qEfED_1=j2nD" 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-09/txt/msg01745.txt.bz2 This is a multi-part message in MIME format. --Multipart=_Tue__21_Sep_2010_21_41_40_+0200_BlL1qEfED_1=j2nD Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit Content-length: 1744 Hello All Please notice that I made a mail mistake in the previous patch chunk. The 6th patch [wstate] is in http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01716.html and not in http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01714.html which got the wrong attachments (no patches there!). Sorry for the noise. References http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01716.html http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01032.html http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01081.html The last patch takes into account Lauryanas remarks in http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01081.html and is a documentation patch. I added some more explanations so please check my poor english language. I still hope that my patch serie "thirdround" will be Ok, with perhaps minor changes required. #################### gcc/ChangeLog entry for documentation 2010-09-21 Basile Starynkevitch * gcc/doc/gty.texi: (Generating GGC code with gengtype): New node. (GTY Options): Documented that tag should be unique. Added ptr_alias documentation. (How to run the gengtype generator): New section. ################################################################ The attached patch is relative to http://gcc.gnu.org/ml/gcc-patches/2010-09/msg01716.html Ok for trunk? With what changes? BTW, the dates in the patch series (and notably their ChangeLog entry) might be wrong. If Ok-ed, I will put the date (as seen from Paris, France) of the commit. Cheers -- Basile STARYNKEVITCH http://starynkevitch.net/Basile/ email: basilestarynkevitchnet mobile: +33 6 8501 2359 8, rue de la Faiencerie, 92340 Bourg La Reine, France *** opinions {are only mine, sont seulement les miennes} *** --Multipart=_Tue__21_Sep_2010_21_41_40_+0200_BlL1qEfED_1=j2nD Content-Type: text/x-diff; name="patch7_doc-relto06.diff" Content-Disposition: attachment; filename="patch7_doc-relto06.diff" Content-Transfer-Encoding: 7bit Content-length: 22322 --- ../thirdround_06_wstate//gty.texi 2010-09-21 20:21:19.000000000 +0200 +++ gcc/doc/gty.texi 2010-09-21 20:20:20.000000000 +0200 @@ -0,0 +1,552 @@ +@c Copyright (C) 2002, 2003, 2004, 2007, 2008, 2009 +@c Free Software Foundation, Inc. +@c This is part of the GCC manual. +@c For copying conditions, see the file gcc.texi. + +@node Type Information +@chapter Memory Management and Type Information +@cindex GGC +@findex GTY + +GCC uses some fairly sophisticated memory management techniques, which +involve determining information about GCC's data structures from GCC's +source code and using this information to perform garbage collection and +implement precompiled headers. + +A full C parser would be too complicated for this task, so a limited +subset of C is interpreted and special markers are used to determine +what parts of the source to look at. All @code{struct} and +@code{union} declarations that define data structures that are +allocated under control of the garbage collector must be marked. All +global variables that hold pointers to garbage-collected memory must +also be marked. Finally, all global variables that need to be saved +and restored by a precompiled header must be marked. (The precompiled +header mechanism can only save static variables if they're scalar. +Complex data structures must be allocated in garbage-collected memory +to be saved in a precompiled header.) + +The full format of a marker is +@smallexample +GTY (([@var{option}] [(@var{param})], [@var{option}] [(@var{param})] @dots{})) +@end smallexample +@noindent +but in most cases no options are needed. The outer double parentheses +are still necessary, though: @code{GTY(())}. Markers can appear: + +@itemize @bullet +@item +In a structure definition, before the open brace; +@item +In a global variable declaration, after the keyword @code{static} or +@code{extern}; and +@item +In a structure field definition, before the name of the field. +@end itemize + +Here are some examples of marking simple data structures and globals. + +@smallexample +struct GTY(()) @var{tag} +@{ + @var{fields}@dots{} +@}; + +typedef struct GTY(()) @var{tag} +@{ + @var{fields}@dots{} +@} *@var{typename}; + +static GTY(()) struct @var{tag} *@var{list}; /* @r{points to GC memory} */ +static GTY(()) int @var{counter}; /* @r{save counter in a PCH} */ +@end smallexample + +The parser understands simple typedefs such as +@code{typedef struct @var{tag} *@var{name};} and +@code{typedef int @var{name};}. +These don't need to be marked. + +@menu +* GTY Options:: What goes inside a @code{GTY(())}. +* GGC Roots:: Making global variables GGC roots. +* Files:: How the generated files work. +* Generating GGC code with gengtype:: How to run the gengtype generator. +* Invoking the garbage collector:: How to invoke the garbage collector. +@end menu + +@node GTY Options +@section The Inside of a @code{GTY(())} + +Sometimes the C code is not enough to fully describe the type +structure. Extra information can be provided with @code{GTY} options +and additional markers. Some options take a parameter, which may be +either a string or a type name, depending on the parameter. If an +option takes no parameter, it is acceptable either to omit the +parameter entirely, or to provide an empty string as a parameter. For +example, @code{@w{GTY ((skip))}} and @code{@w{GTY ((skip ("")))}} are +equivalent. + +When the parameter is a string, often it is a fragment of C code. Four +special escapes may be used in these strings, to refer to pieces of +the data structure being marked: + +@cindex % in GTY option +@table @code +@item %h +The current structure. +@item %1 +The structure that immediately contains the current structure. +@item %0 +The outermost structure that contains the current structure. +@item %a +A partial expression of the form @code{[i1][i2]@dots{}} that indexes +the array item currently being marked. +@end table + +For instance, suppose that you have a structure of the form +@smallexample +struct A @{ + @dots{} +@}; +struct B @{ + struct A foo[12]; +@}; +@end smallexample +@noindent +and @code{b} is a variable of type @code{struct B}. When marking +@samp{b.foo[11]}, @code{%h} would expand to @samp{b.foo[11]}, +@code{%0} and @code{%1} would both expand to @samp{b}, and @code{%a} +would expand to @samp{[11]}. + +As in ordinary C, adjacent strings will be concatenated; this is +helpful when you have a complicated expression. +@smallexample +@group +GTY ((chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE" + " ? TYPE_NEXT_VARIANT (&%h.generic)" + " : TREE_CHAIN (&%h.generic)"))) +@end group +@end smallexample + +The available options are: + +@table @code +@findex length +@item length ("@var{expression}") + +There are two places the type machinery will need to be explicitly told +the length of an array. The first case is when a structure ends in a +variable-length array, like this: +@smallexample +struct GTY(()) rtvec_def @{ + int num_elem; /* @r{number of elements} */ + rtx GTY ((length ("%h.num_elem"))) elem[1]; +@}; +@end smallexample + +In this case, the @code{length} option is used to override the specified +array length (which should usually be @code{1}). The parameter of the +option is a fragment of C code that calculates the length. + +The second case is when a structure or a global variable contains a +pointer to an array, like this: +@smallexample +struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter; +@end smallexample +In this case, @code{iter} has been allocated by writing something like +@smallexample + x->iter = ggc_alloc_cleared_vec_gimple_omp_for_iter (collapse); +@end smallexample +and the @code{collapse} provides the length of the field. + +This second use of @code{length} also works on global variables, like: +@verbatim +static GTY((length("reg_known_value_size"))) rtx *reg_known_value; +@end verbatim + +@findex skip +@item skip + +If @code{skip} is applied to a field, the type machinery will ignore it. +This is somewhat dangerous; the only safe use is in a union when one +field really isn't ever used. + +@findex desc +@findex tag +@findex default +@item desc ("@var{expression}") +@itemx tag ("@var{constant}") +@itemx default + +The type machinery needs to be told which field of a @code{union} is +currently active. This is done by giving each field a constant +@code{tag} value, and then specifying a discriminator using @code{desc}. +The value of the expression given by @code{desc} is compared against +each @code{tag} value, each of which should be different. If no +@code{tag} is matched, the field marked with @code{default} is used if +there is one, otherwise no field in the union will be marked. +A union field can have at most one @code{tag}. + +In the @code{desc} option, the ``current structure'' is the union that +it discriminates. Use @code{%1} to mean the structure containing it. +There are no escapes available to the @code{tag} option, since it is a +constant. + +For example, +@smallexample +struct GTY(()) tree_binding +@{ + struct tree_common common; + union tree_binding_u @{ + tree GTY ((tag ("0"))) scope; + struct cp_binding_level * GTY ((tag ("1"))) level; + @} GTY ((desc ("BINDING_HAS_LEVEL_P ((tree)&%0)"))) xscope; + tree value; +@}; +@end smallexample + +In this example, the value of BINDING_HAS_LEVEL_P when applied to a +@code{struct tree_binding *} is presumed to be 0 or 1. If 1, the type +mechanism will treat the field @code{level} as being present and if 0, +will treat the field @code{scope} as being present. + +@findex param_is +@findex use_param +@item param_is (@var{type}) +@itemx use_param + +Sometimes it's convenient to define some data structure to work on +generic pointers (that is, @code{PTR}) and then use it with a specific +type. @code{param_is} specifies the real type pointed to, and +@code{use_param} says where in the generic data structure that type +should be put. + +For instance, to have a @code{htab_t} that points to trees, one would +write the definition of @code{htab_t} like this: +@smallexample +typedef struct GTY(()) @{ + @dots{} + void ** GTY ((use_param, @dots{})) entries; + @dots{} +@} htab_t; +@end smallexample +and then declare variables like this: +@smallexample + static htab_t GTY ((param_is (union tree_node))) ict; +@end smallexample + +@findex param@var{n}_is +@findex use_param@var{n} +@item param@var{n}_is (@var{type}) +@itemx use_param@var{n} + +In more complicated cases, the data structure might need to work on +several different types, which might not necessarily all be pointers. +For this, @code{param1_is} through @code{param9_is} may be used to +specify the real type of a field identified by @code{use_param1} through +@code{use_param9}. + +@findex use_params +@item use_params + +When a structure contains another structure that is parameterized, +there's no need to do anything special, the inner structure inherits the +parameters of the outer one. When a structure contains a pointer to a +parameterized structure, the type machinery won't automatically detect +this (it could, it just doesn't yet), so it's necessary to tell it that +the pointed-to structure should use the same parameters as the outer +structure. This is done by marking the pointer with the +@code{use_params} option. + +@findex deletable +@item deletable + +@code{deletable}, when applied to a global variable, indicates that when +garbage collection runs, there's no need to mark anything pointed to +by this variable, it can just be set to @code{NULL} instead. This is used +to keep a list of free structures around for re-use. + +@findex if_marked +@item if_marked ("@var{expression}") + +Suppose you want some kinds of object to be unique, and so you put them +in a hash table. If garbage collection marks the hash table, these +objects will never be freed, even if the last other reference to them +goes away. GGC has special handling to deal with this: if you use the +@code{if_marked} option on a global hash table, GGC will call the +routine whose name is the parameter to the option on each hash table +entry. If the routine returns nonzero, the hash table entry will +be marked as usual. If the routine returns zero, the hash table entry +will be deleted. + +The routine @code{ggc_marked_p} can be used to determine if an element +has been marked already; in fact, the usual case is to use +@code{if_marked ("ggc_marked_p")}. + +@findex mark_hook +@item mark_hook ("@var{hook-routine-name}") + +If provided for a structure or union type, the given +@var{hook-routine-name} (between double-quotes) is the name of a +routine called when the garbage collector has just marked the data as +reachable. This routine should not change the data, or call any ggc +routine. Its only argument is a pointer to the just marked (const) +structure or union. + +@findex maybe_undef +@item maybe_undef + +When applied to a field, @code{maybe_undef} indicates that it's OK if +the structure that this fields points to is never defined, so long as +this field is always @code{NULL}. This is used to avoid requiring +backends to define certain optional structures. It doesn't work with +language frontends. + +@findex nested_ptr +@item nested_ptr (@var{type}, "@var{to expression}", "@var{from expression}") + +The type machinery expects all pointers to point to the start of an +object. Sometimes for abstraction purposes it's convenient to have +a pointer which points inside an object. So long as it's possible to +convert the original object to and from the pointer, such pointers +can still be used. @var{type} is the type of the original object, +the @var{to expression} returns the pointer given the original object, +and the @var{from expression} returns the original object given +the pointer. The pointer will be available using the @code{%h} +escape. + +@findex ptr_alias +@item ptr_alias (@var{type}) + +When applied to a type, @code{ptr_alias} indicates that the GTY-ed +type is an alias or synonym of the given @var{type}. + +@findex chain_next +@findex chain_prev +@findex chain_circular +@item chain_next ("@var{expression}") +@itemx chain_prev ("@var{expression}") +@itemx chain_circular ("@var{expression}") + +It's helpful for the type machinery to know if objects are often +chained together in long lists; this lets it generate code that uses +less stack space by iterating along the list instead of recursing down +it. @code{chain_next} is an expression for the next item in the list, +@code{chain_prev} is an expression for the previous item. For singly +linked lists, use only @code{chain_next}; for doubly linked lists, use +both. The machinery requires that taking the next item of the +previous item gives the original item. @code{chain_circular} is similar +to @code{chain_next}, but can be used for circular single linked lists. + +@findex reorder +@item reorder ("@var{function name}") + +Some data structures depend on the relative ordering of pointers. If +the precompiled header machinery needs to change that ordering, it +will call the function referenced by the @code{reorder} option, before +changing the pointers in the object that's pointed to by the field the +option applies to. The function must take four arguments, with the +signature @samp{@w{void *, void *, gt_pointer_operator, void *}}. +The first parameter is a pointer to the structure that contains the +object being updated, or the object itself if there is no containing +structure. The second parameter is a cookie that should be ignored. +The third parameter is a routine that, given a pointer, will update it +to its correct new value. The fourth parameter is a cookie that must +be passed to the second parameter. + +PCH cannot handle data structures that depend on the absolute values +of pointers. @code{reorder} functions can be expensive. When +possible, it is better to depend on properties of the data, like an ID +number or the hash of a string instead. + +@findex variable_size +@item variable_size + +The type machinery expects the types to be of constant size. When this +is not true, for example, with structs that have array fields or unions, +the type machinery cannot tell how many bytes need to be allocated at +each allocation. The @code{variable_size} is used to mark such types. +The type machinery then provides allocators that take a parameter +indicating an exact size of object being allocated. + +For example, +@smallexample +struct GTY((variable_size)) sorted_fields_type @{ + int len; + tree GTY((length ("%h.len"))) elts[1]; +@}; +@end smallexample + +Then the objects of @code{struct sorted_fields_type} are allocated in GC +memory as follows: +@smallexample + field_vec = ggc_alloc_sorted_fields_type (size); +@end smallexample + +@findex special +@item special ("@var{name}") + +The @code{special} option is used to mark types that have to be dealt +with by special case machinery. The parameter is the name of the +special case. See @file{gengtype.c} for further details. Avoid +adding new special cases unless there is no other alternative. +@end table + +@node GGC Roots +@section Marking Roots for the Garbage Collector +@cindex roots, marking +@cindex marking roots + +In addition to keeping track of types, the type machinery also locates +the global variables (@dfn{roots}) that the garbage collector starts +at. Roots must be declared using one of the following syntaxes: + +@itemize @bullet +@item +@code{extern GTY(([@var{options}])) @var{type} @var{name};} +@item +@code{static GTY(([@var{options}])) @var{type} @var{name};} +@end itemize +@noindent +The syntax +@itemize @bullet +@item +@code{GTY(([@var{options}])) @var{type} @var{name};} +@end itemize +@noindent +is @emph{not} accepted. There should be an @code{extern} declaration +of such a variable in a header somewhere---mark that, not the +definition. Or, if the variable is only used in one file, make it +@code{static}. + +@node Files +@section Source Files Containing Type Information +@cindex generated files +@cindex files, generated + +Whenever you add @code{GTY} markers to a source file that previously +had none, or create a new source file containing @code{GTY} markers, +there are three things you need to do: + +@enumerate +@item +You need to add the file to the list of source files the type +machinery scans. There are four cases: + +@enumerate a +@item +For a back-end file, this is usually done +automatically; if not, you should add it to @code{target_gtfiles} in +the appropriate port's entries in @file{config.gcc}. + +@item +For files shared by all front ends, add the filename to the +@code{GTFILES} variable in @file{Makefile.in}. + +@item +For files that are part of one front end, add the filename to the +@code{gtfiles} variable defined in the appropriate +@file{config-lang.in}. For C, the file is @file{c-config-lang.in}. +Headers should appear before non-headers in this list. + +@item +For files that are part of some but not all front ends, add the +filename to the @code{gtfiles} variable of @emph{all} the front ends +that use it. +@end enumerate + +@item +If the file was a header file, you'll need to check that it's included +in the right place to be visible to the generated files. For a back-end +header file, this should be done automatically. For a front-end header +file, it needs to be included by the same file that includes +@file{gtype-@var{lang}.h}. For other header files, it needs to be +included in @file{gtype-desc.c}, which is a generated file, so add it to +@code{ifiles} in @code{open_base_file} in @file{gengtype.c}. + +For source files that aren't header files, the machinery will generate a +header file that should be included in the source file you just changed. +The file will be called @file{gt-@var{path}.h} where @var{path} is the +pathname relative to the @file{gcc} directory with slashes replaced by +@verb{|-|}, so for example the header file to be included in +@file{cp/parser.c} is called @file{gt-cp-parser.c}. The +generated header file should be included after everything else in the +source file. Don't forget to mention this file as a dependency in the +@file{Makefile}! + +@end enumerate + +For language frontends, there is another file that needs to be included +somewhere. It will be called @file{gtype-@var{lang}.h}, where +@var{lang} is the name of the subdirectory the language is contained in. + +Plugins can add additional root tables. Run the @code{gengtype} +utility in plugin mode as @code{gengtype -P @var{gt-pluginout.h} -r +@var{gtype.state} @var{plugin*.c}} with your plugin files +@var{plugin*.c} using @code{GTY} to generate the @var{gt-pluginout.h} +file. The @var{gtype.state} is usually in the plugin directory. + + +@node Generating GGC code with gengtype +@section How to run the gengtype generator. +@cindex garbage collector, generation, gengtype +@findex gengtype + +The @code{gengtype} utility (which may be installed as +@code{gcc-gengtype} or some other name on your system) is a C code +generator program. It generates suitable marking and type-walking C +routines for GGC. Generated GC marking routines ensure that every +live data is ultimately marked, so that GGC can delete, at the end of +its @code{ggc_collect} function, every non-marked data (which is +unreachable and dead). Generated PCH type-walking routines are used +for ``compilation'' of header files @var{*.h} into a @var{*.gch} +file. The @code{gengtype} utility is used when building GCC itself +from its source tree, and also for plugins dealing with their own +GTY-ed data. + +The @code{gengtype} utility is run once specially when compiling GCC +itself. It parses many GCC source files (mostly internal GCC headers +declaring @code{GTY}-ed types and internal GCC files declaring +@code{GTY}-ed variables). It saves its state in a persistent textual +file @file{gtype.state}. This file has a format tied to a particular +GCC release and configuration. This @file{gtype.state} file should be +parsed only by @code{gengtype} (of the same version which has +generated it). Following GNU usage, @code{gengtype} accepts the usual +@code{--version} or @code{-V} and @code{--help} arguments. It also +accepts @code{--verbose} or @code{-v} to show what it is doing, and +@code{--debug} or @code{-D} for debugging purposes. It may dump every +internal data in human readable form with @code{--dump} or @code{-d}. +The @code{--backupdir} @var{directory} or @code{-B} @var{directory} +specifies a back-up directory used to store, as e.g. @file{gt-*.h~} +files, the previous version of generated C files. + +During GCC build process, a file @file{gtyp-input.list} is built and +contains a long list of files to be parsed. Then, @code{gengtype} is +run once to generate its state with @code{gengtype -S +@file{source-directory} -I @file{gtyp-input.list} -w +@file{gtype.state}}. Immediately after, it is re-run to read its just +generated state and generate @file{gt*.[ch]} files with @code{gengtype +-r @file{gtype.state}}. + +Plugin developers using @code{GTY} in their plugin source code should +run @code{gengtype -P @var{gt-pluginout.h} -r @file{gtype.state} +@var{plugin*.c}} + + +@node Invoking the garbage collector +@section How to invoke the garbage collector +@cindex garbage collector, invocation +@findex ggc_collect + +The GCC garbage collector GGC is only invoked explicitly. In contrast +with many other garbage collectors, it is not implicitly invoked by +allocation routines when a lot of memory has been consumed. So the +only way to have GGC reclaim storage it to call the @code{ggc_collect} +function explicitly. This call is an expensive operation, as it may +have to scan the entire heap. Beware that local variables (on the GCC +call stack) are not followed by such an invocation (as many other +garbage collectors do): you should reference all your data from static +or external @code{GTY}-ed variables, and it is advised to call +@code{ggc_collect} with a shallow call stack. The GGC is an exact mark +and sweep garbage collector (so it does not scan the call stack for +pointers). In practice GCC passes don't often call @code{ggc_collect} +themselves, because it is called by the pass manager between passes. --Multipart=_Tue__21_Sep_2010_21_41_40_+0200_BlL1qEfED_1=j2nD Content-Type: application/octet-stream; name="cumulatedpatch7_doc-gengtypethird-r164437.diff.gz" Content-Disposition: attachment; filename="cumulatedpatch7_doc-gengtypethird-r164437.diff.gz" Content-Transfer-Encoding: base64 Content-length: 59349 H4sICMv3mEwCA2N1bXVsYXRlZHBhdGNoN19kb2MtZ2VuZ3R5cGV0aGlyZC1y MTY0NDM3LmRpZmYA1Dxrd9u4sZ+lX4G4d2MpesRO0t1tvNkTr2M7utexfWyl ac7uHpUiIQk1RbJ8WNa6ur/9zgMAQUp2HG/vaes+IoGDmcG8MQA1iAJ581pM ff95EPvPp/myn8sb1Xzz+/+avV5vDXGjlcprlak4Ervfvnr18rt2s9PpbABb xOmViqbCj5Nlu/n2reh9+6fut6ID//+dgK/DmcykCOJoOxeRlIHIYzGWYu6l VzLoN8UzcTz8LM6SHEhlr18L8/dp5uViGstMqChTgRSeeOvHgbwF8Far3V7x 3OMDcRHHuTtTiA8esTQN47EXimsvVd44BEwInSI0zT1SMFaZh3/v44XIZ1JM ZSRTLweGJwgncJ39ZgdI8gMkgPiQJ7FQ+QxngFgSySgJTyzSIjLo6KHBG6fE wyC6jolXgvHSsTeVgDIMpQ8ghEkjUggpN8MBqrcyCsRcRkVTkBJ2v3+JWtj9 /pVVAwgiLKSIJ4RE3iSpzEjBU3UtIzFeagEHMvNXQjWF9PyZHsu96Yrnd3kY sCxmCj5ks7gIA1RpoCYTmcoo7wsxmIgobrqTVQY6z/2ZDLpEf6IkTGMzYPkZ 6hOvCHOaUGTwTE2aOCGVOBJHwECMXxcKzCqKNR7FUi4iXM9ChaFrY519/YBh fS8SM+8aLCoX8zjLEanDKQizCXohfK5AYjJRZv6vf/WLFJcqsjwt/LxI5fY2 8lcykYP9NoXKQSyZn6q5isCYMhDNx8zg/WZ3hZqdS4+pWVyg2Sj3VISGofI+ KfTl7gtU6MvdV93dF6hRDxROPIJ9307SeO6odCVSCYgiZihO1RTIhyRHkcQq ymUKnAzLb1Zm3rWnQvQWEL6xS83tbAUmkfleIlFEnbcThTFJJHk68kLlZTCk cjkvB0SLeEOzX0H4aHY+zcDOvCQJFccBT+CzriZg54Huo0D5KC8SIzEBbt+T QbNDTgSSBpkxkTgV2TKKo+XcmDbbc0kbLABMUbPrz0Cwo0je5PUxEN51fcxX qV+EXkoqePXdC5R959X3O90/fo86yOK5XKBtosnnVoi+B44ZIKpQ3pLb94ib 0Iuawnxin0B+I29u3TIrxoFKyauXNICQBXo7AGuzQKeIyEzPwwI0m5FJe0GA /1NopRD1MM6JnOIeMHdRuAZtgtGq2StyFap8iQ6UEDJwCQy2WQ1U9M41QFzk /RmvIouL1Jc9YBgwsR3CinuhysB/6TtPedb3Vyt28iVMMZQosOqJJaA2PBvs yUdMNC4t3mFmRZj6zR4a9PHBgRgXCvw8TyVJDbOOzTvoIei3ij2UVgv28TVi IPLTvFfhoJeC+fMDAOtnOTD7cBl0HieDGhPNDsmBHXudGQqoBZjm0oRLzYM1 OLIpYCbCtX8xzwFgBvMw2D0g2XXe+uxYa9mra8AovDrYtSeWI83OcN2GhdFd ixPS3FuiosEtcnZDikw8x/d75TwMHDF6HqYT7YQRKydbZhDJ2hRnBK+92bGL ASOKp6k3Z6c3asnAdxU5HCUelBuFaPT+hRfSwEGzk4KuwIUzMQFEIFhAcmxL DZCzmWvhZJRhSiBrldcyXTY7IQQ4EXi5RzoNcwWZVYJaOeF1YVkMTnqD0BDI UOYQZ3UoxVIhnjQ7KrfmPfVHWh/gTEXksy6IHCTZqKfzNNHUclYg1iJKsRqg ReNiA+kF7cqKzg/eV0Vg1+WlkhI8WC1IAjJqPE8g9SBlyKUQDmeADBTD5ReZ 8zP0NMhXmDn0wNSv2/0d1mHKiQXmIAoQZNkQLUAMMgRxUA5FmXBYo/jRpWV5 IUgUuUx0vIV1hjid/AFEqlIRL6Jmh5MUian/JXMFhtBf4ghIZYn0FXkmscei 0PyRnoBBtrbESzOJpVS0JOY1ryykFpYz5N6Q0jEJIASLEZQVSB8yWTWuILfI VkbrrMxjlHaS8SEzy1bVoG/gK4OCKmPpYbTBCOOJBOhCLsB4C5uFHGIPq8rN jDo6kfZAJPR45qHfgcDnaLG2WIC154rTcQc5TMGsvYwtD1LjRE0LjiIG2ToZ xm9r1maH5AnuEIHYbAVcKqtl0jJGh2tcDtaXZP8zjCvlLkHlaPhH4ETxgjR3 +hEMDgJddw2p5/syyXWxmJFUGKTX0yQoOOmxP69ogQZiJsMERtJpAdV+nrFV oIE2Owavg2wcZ9JFdk2ZBNa/gFWAcKE+BTkFUAROydRLTgI5Lqbu1HcrcgEa n+IKkyJNAL1mAcNuUMwTE6OsLXGcgpK7AKMFnXkBhQvUrlv3A0WY7RIMsHAr PajXG3v+VZFgtcHeb/OWO+untYfNDrkXFP9oVYikVyRl0uOwgFKBb+jwEHL7 0741nh5Enf/VMSbj8h8rRRUXmbUIsJLSErTrUAB4V6QmzHBRAqnDhxq9i/Zd 9YSeihJI41w8gVIQPmed6LoP2Q9jQIcwSJNdVBc2ZMgcBKN1m8NobcONW0yU Lusooyx3LikPA4tlrWdk3hvcxX1vYWa5voc+PpjPZaA4W3kTsJCuNsFU9qh6 iMlCiKu/FVnuehhzib5gmTdEnvV/9me/rsxWfX0hzU4vFZtYQiWd6zIILDeM MWatl19cMClbtumwS0URRxMW74OrxQ3MrFWBK2QONgxUjt3fKQCoWi12X78A N+Z3FmM40acw2hyUTSezpB7x2vf/qY2nOnKn+bRT9p3uh8IN2k53R3R2uy9e ffsn2J01O8+pW8OqcHIRG1ImIYGF6jdaqngK6u9VhsA0BO3WJ0VIkc9qtbpJ IBMCyIM4WcJGe5aL1kFbvNjZ3YF0gFuQy3iSL7DaOYqLKNBl7iDyzcQy78G/ mOPQtSFimOdUowAE4so0rj2sU6m2S8GfsjxV44KcGf3jOTALnKnJEgeApkwJ EdoCuNw8M5tNzFFcqoXivBiHyhcnyoeCk3Y+CY5kM/C8MW9FcTWEaMOK9oRU VEebkPiyi0G5BTmGKmrunrQF1i1Q5GmONHBtpeWCbGNnBn7JNa0qt9kF6aYL kTIXnwbD92cfh2L/9DOh+rR/cbF/Ovy8R9EA3A7zEuNSc25AwApSL4JKDKTx 4fDi4D3A7/80OBkMPwPrhOVoMDw9vLwUR2cXYl+c718MBwcfT/YvxPnHi/Oz y0OIaJdSfkGWhGlCOgGRBRJCeZiZJX8GNepyhHpSEF0lVPdQc1JH9cuaIiwe pQWKeyDDPbBtqZtsYFUHZ+efB6fHL01bLsfHNO2HWZ4nr58/XywW/WlU9ON0 +jxktNnzH0vDjqw6wBL+W6ZyrsCsvfC68H0lfvgbj/QzPfIWTbU/SX9k3iBg /+RlyMll7qXL6Aq8NocC6ocxjb7N3NF+JHOY9+w5Ev+DivywgOC3Neb6rj/b ckd5m1YbnMocjK02KNM0TjMYbEBMOAJdTKAqCUEiSKgEC2KQrYRcVp8Pxd4M 9na1UWO+JVo9MkIDBo08FcnVtDq2RjMegwD8qxrqm1RO5c3a0jgC0TD+B6gO qXGIAc2WzhlZeAa1MlYKYEShvFE+WE4OGSHiei3DQXBX7JVlrCcAjnCTZ6oL bkcy8hFNhSVgAZQWXAVJeTVynrKd680jEDmpUKX9Hmgxg7pVN3yxCeciyLRs nJUZziHz4Z6Ve8+8KJqiZ8iomFcYRW5ukaHL4dn/jE7PTg+7jQYq6RTLUyr5 9FQNMjgdHh4fXnQJaAC16xTAXBIa7nJ4Ab6kkV2yljeAnRweDSFcMLoTOaGN G+SemYQkVAW9GBy/L2EvKIPcCXy6/+GQaaNF9lCeIE3uXaRCBTALC91Uz1rt WWle2uYyOiTNznWfV5e/M9RQiYI6q4jZsFCxB4IbYYFGYkZ1nb07ey0+oZIx moENpvE1hyGqTVMMHth9S6+pr+0QmuhwK7QlX8nlIk4D3pRiTxN7KWZUgK7H 2BcA9gD5nEpeSAwLrsIIDbXUzcSIGzzOQYHKaqvQtm5l7YMsYEwFIxTAz7u/ 7pHMPT/n/tlYTdE+ngIvkIowp1J7P7BCR/TgfhgzRlWRwcjeuvNa/3IOART3 iKrOaxIiVsm02NL3dQMEtjFXI/IXXnHl/KE8oEBowsjOj3YBW1ff01G+7tx6 04ud7YyIj7w132cQg8Yqp3R/zAuEndHkMU3bFAZoEs2BnORF6jcuBTzIyEdn sAmKr3oeNjbE3wtZ6AyrqNu3gfdN9mvkre13QwApBbmHus9r0ajZaeAfEF4X MM0sohKEj4S0cSkqQQEC4q1kwyLk8M3Ydg0QqvO9hgWEb8U8qoJiIMjZbJ/R FDQIyzdlhsSDkMvQGyWhJ6I27ET8woan7a5cEgm+y/0qFLg2fr3WBrPrioZU Y2X6REPfssfapcKqWCSE2A3NeoJ1zvhKZ1Ryz8oMHaS1v0I+/E3SBlizrr0X g8sm/+U4tCHWaQnR1xrFwbvD06GdfR2rQAMnecrrIUrlySWDrlgbZC17Zbim 2ieQE7SI048nJ7Cg/eHhCAgdnorWRu09a+/omJJXY4o94bNNBLbkSU5nn+Yc 0zjKcMbe5CTtmgfqKkHrn3fK1nK6HJZtSCg99T4nRFmVDL9ZW/OeXtrHrNyM YAxC0lTGWOQUdY8GJ4cGJfmBfVJ1E3xOXsEUSzBlNonkovB4p3xGlTY/HMch PUP1xpNJJqlsGkvYGdLRLXyh+U5NcwAbJlQGHp+nKs9xS4Lt1+oCSvoaaIRA EAZgsuZG4zvCMlZQdQtJL8N+Y8ZmaeRjzYGVuySVgqagZJfhkpRURKG6gi/c 7KZWqJckEoREmChf1jffdsOK3cBll/DEaZW0V26ZdYeJEsQCSlTchZSdHVYp pzO30cptNcaApyUHB9UKkVev143Yw9IuzJqp2Na+REX/SENwhmhBpul+yKZt iOOxuG00ftkQAKyTibEXwBfQAUzbs8BqIlr8pE3hUQ8LJihaW99kr78J8L/Y xvFCFThpe09sCWCgi7MaPI1x9X60kbzLSDc9Rgu75zEki/ZeyZIMM9m4j8eH MVj6TtdxlJLQipXR2mm7oWyD+EcJRPB8Qlo4mufdfr/fZkX8S/SALPy/6aEr RqM/74/2L44vR6P23u/WCTFb0tuskzrRDephV6INVlpWb1BAlyU6Rn7s4tBG A/cOfLOgGrXuyJn83IyMl1RSi5YbinGkyzUYJCiZ5iNuF1HXKMraukg7H0IR kIVxXgZsrhxgfkiJY2dvrbxxkzeI0M6kuWAvT4idf/xD0Iefd35tsxL4Ao0L rSlTTY9H0yMaaNWK+67g1WjW9ywdhL4Tt10B8I4fWoikrVeDbPPE1h1La4ub OWkOICBTQ9zcDNkWHVsF4R+TZTpzOccM1kJ6XbHTFV/CVJkNQD5symk2mrze OrE0GMSoDh/qZWtB6JGVtsWzQpcQukcBWQYqiGtFJ5tZolJOGR8OT4bbuo/B qYu3sHioT+IqryzYIhj7yJD3cjxsyNUcE5npsB0cEEYxTr3Inz0RsJUlLBCv 6GDWi/Lq5Qb2Rj59kdjKWtJGlzbVmj19EEl46C4BHfc5XZnyQLxbPVTOEs/X p7J+PKejPk6yXPZnXbdHwFLO0O+xIM7u8cuy5Gp21rdxooWlq/E3dC3fehUV PlAuQqWz2dNK1PmV46HeFKrO19ghuMANG33t8hEbnQBRp5NWWG6/YfpU5r5x LlRd2/FZeP5GHJ4dbXQnaka8B8HhQS9JsSu4csJ4WPZTLKLtX6JtjenWBOAy gHY6e9VBrvqsIGAJUNjXGGX4aYzH1rhePbSy0WBweXm+f3AIHLQ16Rowdmyu VGKVj8TTvDQPOVc9yClxtGE9e3Y5DcNKAFvtxi2liruE21gZYC6kANmPYkc8 fQoznmgp2aXVhadx18TW+BqZlfTvkJuxoExN8QqcdoTK+geX7wbHgyGKFUM6 c9jbLj93StE09LbM2UWbnWiZSgSVxywu3+TVqpYfYgnI2yTzvWjiPu+KrW+C ra54GrXFD2/oqKuxoUYSrfp+CCaa5iqX/sq0A7ZKmuSEfzk4Pfx0x5bRBdVV CrWN3lS23etAek9U6nodxHf13SuNYB2SovIbp3hZB6EmhJPxKw+LqG/6BgAT 6SDhRIX8yhiRa0Me1hYy4g3kHd1ZrMscQ2+tBYmHaP73akE3kv/dtPBQIfth TA2C9M62dk3K7X+JlE0P/j9SzE4n3fRj0Lz1sdKanAeX+yfn7/erMXLkxMj/ cj4/cT7/YUOWJFFrUsDISH/cq0GsleJuJa7VTDsBFWT1BxrlSEUKqtOnJZGv C8E6qeHqTz9+eOTqdZozLO1O03hR4QlKjfbe/WnWJM8fOODTThHi/RWlwFqC /VFnhS+koPv4aaFg24CmRE0y/svZT0eD08Hl+zr/pIcSmlW1cQsHiLpicHp5 eDFc54WuK1RRA3ydi1pQ/31ejIdj/yHpiiSJiOxW6MvRVFf3tY0Cv5EBBeHf CxnRlkGEnjh4sjm8bq2HV9K3D7jrTFP5n7kb6w0+P2am1hy/5rU1sEe5bmuj S7WpON3a5kLVOMytdbTB5fkFlDLk8GUt+8u28b2679Q4tQ5k/NqJo7aErxbJ vxexrqtLFm9tS+meoEK6WdDFCuAId/k4reHjBdltb/s1fnkAU9u/eFTmN+4L YQ0nZGkK46+gMH4UhfwrKOSPohB9BYXoURSuv4LC9aMoTL6CwuRRFNKvoJA+ isLWV1DYehQFcK6Hk/jlUSTEwymIRxG4MQRu+R/cqOqtMUXuGx22+dndO9Cd Fze4B/Vv2na/f4Of2mbqA5YAky0ljGPl1IftZ8tj5fWNrb5KxXluq6Rzn6xc aVEabTT0e6VaZl/Dlu6VPoyzlQ7GKxvT9cCjNvb9fp/x1gvDJyaXP7hh8DFy jrmZ8627K8i7kpVTRuqSwa0j1+2iVkyacsJ0uRFHbRfXuqOniGu98e9rctsq UXSYUFfsfqFi5IsC/541o+mor9WOpgysCq9Wd6+rQkN/qdY8jvEOMcQSeZNI H40Flej5uT1lF/cc5D2gV+Xl5rD8mzDYYh/TsWKtBGw7pwJ0+O9eiKrcLbiQ sF55LbPKRR1uaoOlpF50Ret8d3g+fN+tdVN37jgyN9eqjvGSpL7Bwfca+BU6 8/whzfa1C1UtjNKBTPKZ229P5ZzGwBro3/va7M8Sc2HiqfPo3sZ8fFVtLujS 2lLV9XNlh4ARx5Li2WWJXfLAuDedKTjbXgIqcax378suMOPT+K2Zl0tuGaba jhOV/mCW1OuVBu4cOcEEx7YO+F5qeeeJzMRegsG7dKm0N9ocdeNxSbOzdoNt g3Lv0EhUVYTWwmYluEJ9UldEZEMMATgyYelzXHAg2m6D3kg1qqhAp6+Hphh9 0483hnKe5MstN+KsqcNI/9Kb4PtAqXbhtat26GmeqF7l0/dkKFBvvP3rfick dyWWxLofiDhxrNMxTnuLeM/sqSuPEye1OFY1lIBfWd75BJB/nIAaKKoPwaNy zr5xeeM4DqvrUZnuwNy1pK6oH68/YJETD9blnLK5q0J7sz2Wu6fpoSeYu+ZJ iaLS9th4PLwqbyLYVyjrrwqbF3HMazoIg28X4ssUGGLFM7x+zAe1sYWS4jU9 sn89unIF9WBGV93rD+0F3M2PE0iG8xEDbYYof2/GPCWIy7grFpLf8sBfHNGr oxXRtXZj6vT2MN/lnXtQZuIdMHoBF5CYSWBKOCxHztUuhjZJrITkiRiXDfAH vPmn0ZZSdhCOjs7O9G+k0Gw/TkEeSRwx6hqJEjfOo2TMAPRqacQvA2suoGDK 6O11qJolo1t4+uYZvhtEb//pCjvTb2ng1OfaOj5tTNQkWfPrQnizjQ713Fc1 Ib5kUl9K5Bee+dKZSrX38PkZ3nrANyT1i9z61ehUml9O4DtqeM0gqPpq5aY3 UqIre5m5uXihsw5FtmiazzimuW9czL2AfgUk8VS64T4gDo8QcKQRtGgkoclt Q+cT6pBelVZpPU9VFEwAGoWdnZZc6nNRw4+5rYgvPPHbSvRjPu6CKLCRfPAK do3b9fXUmSHo+xdFr778X3vv2tZGkiSMfpaf/RFl2hgEEo0A36DtGRpjN2d8 ewzumTluvxohlUBrodKoJGPWw/vbT9wyMzLrohK4Z2b37Dy7bVRVGXmLjIx7 RIwC/Mucgyky+zaSVfaSQv7HPRR4GuLT6iVT6ERLk5gyFnXjJY4wx40LAWNS CEoXQy6OXXaY7YYum5kFJiir5Lc5zswEWcmmlceGRpJk4w06Wr3y4naAmH/B KwJoOs8kHVwMhh30koGpJCnhzQG6b4nTSdnAOiY4yXPBSu0YD5KL8Wwa5+Aq hwURPigOmtImsIPNJJVVGsWZDcdQ+zIMVjzw6JSw02idzVdaQEKiuYpPsO1e NNyj18PmM2IC+X5iMOK/IajNz9QdbXaEhLShBL5iID9FEk9iTEjxhbx87q2m k25vAEIw0oO/z6Adxx1MSPU+ZRI2QQqPvic9l9TBpCNg5DM5jS4TldnEC+Ro phgm3pt12c/JucCOXC4ClfuB8txAxyai8sqiB3kPAYNxSjQ6TUZwLV1Rdgkk YCz7YNauBgdHDvrWDRdHF3SR8oVgs3xFndM0GSKmoEyb5vHFGu1wYiy7M89i fq/14b+8+4bxwCeGwUV9FP5uPiNeKIcz9rB40oUt8326xaek2213UvQtZPjN Z7Tjho223wFK0O0oXmEcUE6BUZyFzmFBmkjo+mUyQRezxICA/zEKkLzgoYFz M/FGehZPaX3aDLtt0I6909V4fY8SBSMjDvSNPO4p+34brd6FVmbtl0QGyCcP Dnw9TyqY10+1TnDqlDqAF4DZWjVhv+v83iLyonFY4lYp//v6byOr+rr2Gfr8 BqPBkKcRUg2XiCEe9iocAfzKkj3+6RM++eRpznUvn+/5VDK1ZLJsJwjoci+C ZTJ9MCAHpOA+1h/rM2QbPg0gli/5delFaBSTxt04e/81Is4uEt6BsfqGLsN5 e1F0C8pu0M+uSDV9QE/YtqXot6WlrAGerqI9aIuHcHMvStfXMyQKFRmp0+xp Mx0eIzFKsJXO9ffbb51Mf9oQIM1OM81OqzSbZppNqzQbZZqNqjT7kmn2pUqz fqZZv0qzSabZpEqzpUyznB3Pafdbtt1vpe2UMSJjpTZ6MYCV5/ERWBXyD/1v X8Wss2psQsbOfK3Inh1udpLaFZt98Zty/0/Pkd1AWTWVVKDERiDzTedrMu/k GcU0e/iv8r8p0EMJRTNHMH9qcmqXnGO9NGs+G4z6yYa8v+spOAoOfk7D+l6V +yDyL4TCqRL3f8OJEscn08zKFf7Y8dn80YCMDyT2puPh1lVHxF83n5mR5W2V +YYo9wQYABQkFt+4PDCLbmO1AcJNc/vhTZPvi2M33E7kC6Rp/goQJ+ZPNx/S copshdeu2gy91bd3ooGDFMa/R4nYvn13cvT2jRjudq2HUDF9Mathb19DhEOQ J399d5gL0DvFlcG9OTw+OXyeCzA4iKUg3U3hR4Zxwuxo2jmLZqPPo+TSY2kr MmIF3Cwm5BZ0mkfM5TONfvCXQb0MTipEg3eBGvpbOddu0UXbL6tM2aF6agAQ z2ZCn5/iOPdsJLTgvHvwVCG30y74W5q7l5V2QK3/6WB60RnDzCRJLcfQSlgx pWScJDAKtD2arMBzNwg/bAvgVf2D/yknEiwxoC2rbr7P8PAmVheJHeZrHCSj eWMyTTzWWx7Op1qmdc5N5GiwgbaASHKQXFwAWKPUBmJPoEW4oHcYQo8Ygfow zBuQjdzOaNu4pYnf5uaiFYwUsnh4kILMg4KNqDutzWB4RXoZVk2k8VxGi8B4 isjwblAUHw/jfWkySkbk7lFGvf1PzW44J8Ys1KogQ3jSRAjfB+eYYJKxFUza 3i1z90NthI/ckpWdbA28GycuEz1sBxo30hnpweGbu5UY34X2wzWpRiR99jik UvMmn6cQqbjsbqABcTswR6enzpRLcoOZB4oOUmb5oE2b0ovkLqJv9CQJZTox K/v855ckYb2gqGqewx+j5XH0AxC5leV0BQidNGlwFCRG1RrIxsPWXgS+zcg+ nm2kG3All5EdZpfM6PYWxc+AS5MOF+NLvVFW4NJyD5LV59JQUe1Gv8xQszMz 2i9vGFpzlMtXeF8ja5H51LvhvM+DK8ujscjjiCZaTnYV5Cs7u3Nw1SLpEr+c L0jhFGhy3EBTp0s1Cyk3UWESxUdn4TnQ01tNwTKd7rWjsUBfsTbCZND9fEVW DMwZMu4AjzFDpy5OQsymsMuY4iFcnDf573DqK8n72+UA7gESabH5ql5ZmThj JWZDcpRQ0pyUjYJBWrzzBA7o7ALT/zLd4iSJ5wAx5lwpJgeeBGhwrhUQDjC7 MGZm5GzNHFre01issKwSX1cBK1lTTGOmz4y2WL4+n15pS4kmoNQGhUDTpDJy qLEJisB+q4dNsoKhUcVl9Mboed5vY4KnjZJbLMAj2V7KXajkFhrxFe2MdJRG NrMcDbWZmrgYfR9oyOZOWMq5BfLJv5IoeDWLsH+PVtuKF/wx/NcTK+z9rjZN haDrYavp4iWG8MIbTQEhR0s3J/i6wZ37Vxk98i4IsYodkmVRPCvEOqZGQHug E5laSyUA8ixf2orw4Q2Kym/fozz/4eCk/Y7WsF7PNdvZoen9evo0ysjPlG7D oC+qUxUq6/nl9mJcl0ybYEmww02PV8q/NnkA7D+y3CMdudqM74szWQKMi3gD awz5NqEX3n+xKUZ4NLxlqtAk7Ro1lygN9spkdg0qT9KbzyaV3koaPGp+Z2pD BkTwokH0Eyz66/a7/ff7r+Fn1qoTMGIeTPrxcfBJG2arj8i0dihtPDHna0au Cxm1+0XdGZtpBh0kc1ylvedvS7e9YKull99hl3MmhUklJ52rSnOiL28wI+5h 6Tsw952NoefrW4m5p0bVlcyWuy/4pAqX18lba0qW021zEbfq2iHTZJXceuVX m3/MrIHW6Iv5UaglfnnQ/vDmw7HSvxZMDsGPsIOlEo0uQqsIaz6k1/t//fmw /e4tptd43j55WwHqRefq1JywXnuazOlhIdhzoSo/7Q9SueYGKrI3CWy2uBaZ im6KUQemeW2UTNe0z52UF5mHLlUUbBWUnCWs3Y/kVtxLKGmhmzDnRqX6dadx twNbbxlR6zYqCxp/HQ8H3QGW5nF+lL8kl5iLuuFJQJS/ih2GTIkygYH+tzGl KMaM807EKJMJTNJ5y3+VHGJLwJPsebdH0n4tT3zZ+oST6yeTaUfc4Zy/r8EZ 43VseIoUKw1QiYJ0miQ94z9qM52DNEhfmZo7X/hiSgfklue5e/LLIQpV7CFy it6c5NJJIqRd+VJ8WkA990+yXThLcOaG8ObvfOMKriVeGvJOZpepEqR3N0eQ EyubkbRAPDE7TcNHmeSPIJskQ5u/m0ZQBDOQVqpIYIX6ORsYk+0m65ITmB+d ew6aB0VM2c34s3k8r7rQM74iBIWkniyQHGG6GAYT+fdZKD4jNhcOlsn4axaK Zn3mwni1/+Zl4dJkFRXz54YsdyHAHCljLsTjg/1X+zmL5ZlI5kMxRudaFBUq 9vOhhD4/BWp1F++7uCk38P6fL6y5AIDvSefqN6ZzNKLKzghz2OA8N4T8JoUa 7uCCdHJ7vnTlviR5qopOW/TZJVtcIKajBhN5Db5jKwRthL74FaIv5jrk+zb9 wKTOfvkL2tS/5RmtGFEzSh7Pu1/E3tDJXy0dxozQcpB7KTEppNO1qt204WxR GBvWUIFgrGn2Ir8aEZxVVD5zaknRKrOrLgVCWJ4DqzKx4VDwEGsWpjqHOUc/ xSMOGgMRFVXGHbSsk/KafVr1DnOQRd/Vo5CaafGFK6Fi8QUdac2kqjA/FBiX yQM6OrXv8pyTzcubuCdbwFZP5kOb66Psf17opex/Ns81HOkPF1AEkQfm+SUe YnT0lqCqaY32vMtJAuu83LPLTNPAIrES4+h1fZ3ZHYdo1cxQpD7P2SGjEvVV /KXH1AFc+LCa/ugIlu+wGrbdY2cR+r7DKqTgcyjtrTZeTZDyggDgDA4UmcCo GLQiLc10ET1rLiLQBzfABg/wDRBC9VsBK/xpWMRQQOq/xzBviSDZzbPxvnP9 nmxgcM6ewct80uoK7d6Atrou7fpiRxUJa9B1IWV1IH+Pw+XWN3OmTMc5Xjsc uOZKm3NInw3xS5U9WD6mIbiysKROIBWCUUppc/JcSk2RXP5Gl8Zk9QaTcpc2 iTtbyKNtNtJ8CFcZYhUVIi6Xqa0Qt5cafAiwdmAx0Ft7vzytqpGtXDVcLpnS ALKUYAnusiMisEDtMw4XS/PNNtnvcu032tiNaqrC2EEXn0Yfwh8YsyegPw4+ /dODB8PRzokf5DEHybs1iHlhgzZoUGLIsL/Q7QZ7KI3083tcNKKQ0eE2/edG GuqG1wtGDS5yT+hjcQtPXvqw7BwWnybXnJ0b7BmhhQSsmXuY7Ie5pwnrHNou qBxBFNQTpCQNrO5g78lhDGR1onw02E8DdcHdBHkpLDc+OMPQIibUmHznaKS8 RhrRwfo6HiNUzXcUFK6XYuYsJTmwTmx3jJ/Ta+9IFUWWpkuioMdzRdNSdtkb oQGIdvDJXP2MfOZvNinZ0TMqdt4WcB+eclw3ZWQ4esvpM1IWZ3uD9HPUnw2H KK6qTPk29gtQA9CQ4r7CSD6/yoJRWfVxXD3ty0llMGS4H5fTTwDlK5w6zuKx Cv+MEi+TF9oJ1FR1UhNcIMKNIDsJVQzkcHjMcsIFNUbOTNClmoFRhxTGWBDK z+M1UIWkTDkO1JJOZmNUA2BWslPSCBCOGu86kKfHyaQDvADRHla2cOYetspw /QpgFCiNiXAJSNcxvxSsFvA4suiZ/Q3iTm1uOLPTrsyYTsCLJUvawP8ll/YR A8ChtvMqmskH+D6d9fuDrx93Nj9ZWNHqfYBlGF82dJnZz0aDv8/icBHYDkMF 23Elepw5DVMKwGlmFmqNdhANVYnNK6BWX698g/bI8lc2A4LAuUxGK1Mpbj8d sBefyfZhncTCEQo1uIqnAsWMVOxpZCfdUMfBFL5xa+SVv3GPRaeXjsyJ1y1y Po+aUQtIQXN52Gsu9zamF2MkvLizddxC41XMFBaupzHg7qp0kt1QwBc44YbM cJ0nPQCXx8AdYcyrjHUOeFht3XTpUrHkuoUf8iWH/oU99ASO72KuT2pOKsHY JYrJE8t0mUsUCmWC7VyZQPVlR2EQgAsEwRMkZCaK1koL4bqpoVk7r/U8NelM uICf8HMmfdK7eHLeGaeuqtCMDeNyl3D9W4zJQqoymxLWNZDl6xE+d9lVdIDM wFQVDs6/SPb29qI//vGPxDX4pYcsP5LXkKdPrZ+/fbNyEh0+PzqJTn45Oqby iOb8eDX4oIsVV+mvKnik5uzcweukitlPB4wzHXVl6+J+WNCv8ixo7aiSsOrk ckC13XGxyaqsF4nozKgzTDeqT8XAlbv1VGoX26qT5NGIiHieiIA6mG44dDPY VialYUcGc93yJwZvNZ4y0K6i1ApTDYaOklFTqgRRaRySUKXakbjI4sjNsntV yH1e2cZl+RXLs0KpEW7znfGFSc23lRhRsl7gUsy6TW+a5tDbkuT0jWV7eBs6 cGPyIYMLvD+cpUqoIh6IcuGcx93PnHCNWCQpQwUYyryTZZZgIacz0RMYthJk jSjuTIYDlQiVOCnuTactxaoRfaF0OpupT1MBcYEJk2Rnl8ZAkSVvzFItRlPz lfrZd4EqMfuB0lnlQDY8qrp3mF0pyOZP6/UvXRgaAValictG4Hhc/vT79CvM Y/YuVjdR4UCk8TIFJeSNJzMUHmCFsXFq0Jw7seR2bhVq7PyxwaFdRkJ6NTWq IBDhdXa9uXe1wapiZ5G6MfX9B4oXt/0fJSo85FSMYY7Eu5xosTQdInJFmMGS 0hbe9n+q1m0yuexMelEv7sItyrTJ3OJY8VAHk6xZ/zDnhWZdsTJRirplYZYu 4yNc0C4nDnxNrNsFLTw/qzWlgi/43vNXWMN/8WM/tWJo//bso9kUhAF03wa+ ZlIQFq6Ul8xpzUWyFTSoHAlst/x9DIhG2fwTVdXbJZekSqxNqsRq8iFKheVY bbuYmCn5IX3qnPKAEHQHE2bLbCpEIjCDaZ5+YkID8rdOYlP9Aq1VKqa6eTTE jVKXEvJCMrByqoA0RUSxhVIpmHpj4uPmEjnmT8NuivaJC1BST6wonfamjGq6 iaabTIbvTU1EswmJp5ukYtHV9kKtWm7JW1WGh4YMB1Riu75pdyeSYvn/rD90 I/q2eR1dq6zM0ngj8JibbmYL7LnOq+7rfYEO0unbdlgpihaFIGWS1+UlnJ5u UhUDynUR2UDj2rWbSk4ablUAYE3WyOTktJiaE/X8zUu3kTuSn7ESpcEyrRi+ VucXvqGD68fKV8BLv0UJZppZBaH7kvOynPiseXmDcoe84HgXHOz3Ganzvps3 yJwA/ILxuS9vNb6ONnndPrFHGC+al9djzU/sUUS5DOEqpluFVGsu0ZIhIBUp ISJlp3Wx42hO49Vo2vlK4h0PoORUdgwPOicG3MeeTFzbQncEfMt+xVi23nkT V0Iw53xYdtVUuWjYiXVOeQGXYZ5oHXlIOvLMMzGpB+zFVPP9vyd8JfsRuZJ4 wcTY2jpB1tObbwvuIfTxLjAYhsNBKac3G+PYcyun1AvGmjNCiaOtPsyGP5rF bqg8Pvz+qgOo/EoznzMzqr8WhjT3e8uu6wbIr+d+7dEa3UJITW4jPife8FUi gPqt7l3cZ66/ZDasylEvT5Sghp6TJ+F2B50c/v9/cs7dKv+bHvPsAL/XKf/f M17ljFc62m6TlnLZKjnS8yKUtYSfF6Csj3X22EqMzYIHN4NwepDuTFQ7C6XL Pa6XrU15nLOWgbNhzrcjdxRT9G9B7sxKcRx1NZqRjWRjCmeX05IN8dBU1GMB yqGitCtww15utfkEvHQRPD1ClXmi2hatbDzfqlNdeG5VyAOPjmasrv2SM9Lx T0lGNNNMH0oOnljQNHGnvXgMwhmWEwGqBAKbFH7IE9qMCblj0hfZUF20QA2m OpWRqUpC6Yw2bBIh/CjMHCRxvzZ1UFmIXRXR8cbSjEagoo9aVT7a8ivRZcmI Civ878c7lXBIGby7KZ9UzKH9vhxU0QT+eXzUTVgKHHWOyLAAQ7YIM1adEVuY CUM3LfZdD3NqsTtVNlHWIPXTmMkS+ymzSGVr0mOVnyA64Nm3sj10srNvt+zo 35ETh86Q9BPjQ5N+PYt+opm3nkXkpsW/Rs/qyuhefn5fHb44ebf/3mDS/ftR /rlF7yw3iqV6QQPpYGuu4svoFLHoGGVqup/LGSvHcpOcTRSP060ShZnv6Uv9 4S7RZmhqWnh8tlVhlMDL143COPcKzchcrTw3Q39K0KRmKodyA2vjNUtj33B0 Tqa0QfGxtmWZl9ib2GYZgCNhF5OMeVQuNshGF9RSzsckU+7w/dHLXxCVCist m+FwiWg3nnq1wXxHUuf6Vgcrr8+MwOAl29KcUEFCsHm66eI8YJrDMEnAbiJh 6AwBtxbPMrPX93H167hcVMskHPNi2yrnHCunyzfW8OTnLtManyIUzbAaVRfB 5jir+xHcZbdxNmtZgU3orBtVSTuleivJOrU21nmnSnB1UcbT3xqVikp2nToG gNZ6u1dRDLSZqHIALQYmm3oqCzLMaLUA+HLAOSDnEcHBiCM/cvKOCb0tQmSH RSbNlRXcyPtKMCub5qowefWCvh//aleDotw5pZ4A85Sdyl+kPM94eVF5dekv HZqEKYg6ZzBEKgmsx0yer0aeqtka1640nMnohR7FdmdVOjLx91aydB5xL0yd lUdW7penzvJVd6rjDCrl+01Vok6F4noF1Cpn+hdiy4G99lNK5bLlLKJlsuJm 8W2rvve9bkftDaSvycLLz9vrHF8inQyoQCYvPc61eSP2vT6WbPGwb5aJLhl7 oM3P9Tnx0xnRsa1Vou7KxeO7DOu7jInUGrccTnGyp8VGQux4diRrLnvBXw7e HP7ZumIaFvYmI3aM+NqNhywp3/8ZI9YG2JsP2JN7/hnDzipWbz54zer+c0af I7XdYvh8Jf6TRu6Z9m4+aDIu/HOGrG1uJQM2VR4L+d3TjqvHsnrX84q86ZV4 MyVItHQx4Khb0nx4PhkVFRw3sW3Ncfl0+6Z0Y5U1KnZx2bMsX3mSXzg8k1xE JRbBsHgsWcFqWLL05GQWyTB+FQpoR9Fpkgwj2AhJ1/AUZgcT3bs9bxjWz/Yr Z3ve2hwcpt7/a3jL1RLmUtbOaXwxYmtVr1tJY1dAG/Dxu3Oo5br18gPr269o LWpRniq7lScNCkfKAeUSdFxgGXLqXbtmWaopwrCKc8fkEfEYQHzc+kTe6s+P 3rePD1HddfL2fQP4KSwRFm2Sg7pA4eFgUF4YB0141nBAGxEHDBm0M1pkV+39 qUrl0j69MtXGBbZuQxFRmRdZwjwPtmquqtij0j5XqK4V409GfqigjkbrlyET TMMakc03SsspyVHQNI0jW7qNLHXTi6N0lPV//S3ibbJnY/G2dPMmtkl/3ksF 6kyxNmLGxyoqgoLQJLki5On0YlzFSj//diix8N+a9pcbE38HYyAv1e0tgWzZ k42oYNcLM7rNt+C5FvlhbPdhgxc9zQbm3ad28AVHVzRzRLGE6CDBeT1ILzCS Ou4ZnDWGfnugl3vRWTLlJETSX8P1tsAlp4lL+QGeQzDNSaTxKgteWFB3zW3n xTiPFRRiyvb+arEo2erNqnzubVTBVHzXGs28qsm3coIhqLrS+iJOdb8bAc8Z 1Txj+OIG1tci4HAGoJG/3fnCAUkPlfChoFS8X0w53E+0hRZZHt2SkJCaOzyp 6V5pgIXV4xdAWDcm6TmUp6WT8XTS7sE+FCIyF9eeP3WvDP3v6RuW7dKrav9v dkgKxvj9jwwSVtlqry91Zv4VezJN/t13hEb4L9mPkEiMVDn4OSQiSxvWKhKH /2a2KbNcv7d1KjvMN/uvD52ojsuboaGy+soFq4I7CClMaLek2IL2/VACb/BN 5uhQukd8NuhRP3vz7GcVPMiqrYive6huB6KlLBtjLc/8Y1DdJLmo1a5t3xWo gTVuLtq9xybcsHMmADfqPmACigaAT8qJkEBwCuv5R6R2E63DnGFIyDAwczyg Rob/r6bbX0Bjb7jIzApcLySu0H6i54Mi3QtfBWbSlx1Oc4Pw/JIjJlTCZI1m 2lKkeCjKAuM4WHl6jmDVBefeoE/oICEPoJy3os83CPhd9Bf/prdL+v2vl8tz 1GEtcHoyLsDm4N/3N0IRa95Zl9DDJ8uy735rd7bV5uOXhafrW6YF+xBXA53/ yfX86+j6X6qIvMHJTrVekVQYzDDI4mbkQcn711DJ8jpnnQHq73UKQXGPUjX6 yrhCm1VQJ7wNMgz+z2MRZYJL/+3tQ1l6gJUFCDdsJU/yofMTTJosqpQws5Oa Q2fOo3wsqGMZPS697SNHo8gIZRnXSp6DtaVggBeiq9xTd/5ySknCSUGZGv/B WjAeeVoeNHVrM47jFOyxm0STwdk5JUGFpTyP00F6s3vfrkSJXVvVkMtx8Ne5 2P5NfBC/+xHG+WXPb6EviElJ988SBa3SQ46lPkEFuGmuHS5in7lMnSdKjhBY eg3ntKwYXGjAVnOxNBo+3Z/V7dWKwgf01zZqoFYUo6e/5ii97ySpakq6gPdh ybJXEm6QqUfcbAhrb4EWlN+oJnbw4fBLVRbwPfkyu7l9on8Ljx99XxSsnhSo dH7lahCC4VQ0NiCmCyWnpNqMFdJSzq3NGApY8jhPurqJPbicfomcAR/lm0/z pQ1vlzOXjW/OzJM0GH1l4myhq+WKFPl4n5Ek8kDIswW867JlKiUAQXLBA9GZ XXAdg/oeR5hgpYtJdDkYDqMYGCybijPizXczyRa8vA49B8oKPwZ0lVNEGzSz FQuLakB66Cbj+l9vgmwMAy7X9/InyPER0FtS6mVwS28Ckw33xu4ECqEWcCgw 8VyOeLr6rNqlwHLtNmrT9Wj9DP6F3gV2l+Raqd+McQ/BrCoUK8/XnVdhj8Q2 VbY0IltQfvVKv3jqmsI6qvRblJmzWsCwTv1vIpvcM52gKedqk8eGSutnTK6z 5VEbXLU3qJD5v0SL3Vvtwt+ebKlFvwVxqqzZXJDjMCFYmvPJlTeE96hFGm/o Tl9E62kZiu+k6iyCp55/d6VmFSKlTrNSMEjZQXXu6FqQXHHzGXNcWpB5908O 27CNh28aEXPhS/oaUF0HNwL8z3Tmnf6Fy5Iaoqm6KiGbuhNF0gp1sEg25xcD LojaUdTTe1xYHNjxEviKViX37c0p7//SVFElqe34HmQ12KbbEteCHDK/m0lp EZL735y+RtlzxTfH9ye8Pi3waO98D6vs6Sf6rJ/MpdI29IYYeImsyeHh/YHm uQbb1v4IGtnFFNrqgywjr6XlurXdylU+MkKxq4ft+9KH4q9X0ft/mUttFjMr +HuKxLLw/9biMFUuryYKR0tHmRNk13G+GIw9/atF4D9rBxN0t1F4cCMDlj2b HpVzB9TJpTdi7hycEt7OKz4fSL7Z6vOl8m9OsfjvlYDz38yoxlP9n2gWl02s bPmSWu2ckxfe4B+mPvwcG7JR/PrmF8omVi6Z8RAHI1UitijmLI3/PsNyULcr UZJTsPyfmln298xk+Z2vRrtc3+dq9DNFevXb592Nfr1zY+j+9fDA9+Fp5JWP v53AsUDx+Qr5c2pVvEW1/3CV5IpeTXl7lCJ7lGpRtl78d/CU/lcndHCH2fiC BvP+XTJZBr1mVzvH5GUIF8XLUsnZOXRKl6X9lxGq/3ZxsrBmuGS/F7E640j6 31G5oXpw9M3F8Bv6Zj6rVyBS5tuARmWScrzYf3V8qLxKMiOcT9jKsKFWjg61 hbChZnd3XkKNpTrHCyyeSmOpbn35FsKjQIOj02efSgGyraI8C2XIUyvDnuqh CnP2aBGmlFc2f2kKuFIT2qGv7D4sfnlWD/bv3B9SRps4uo8UdBh1zGmJ4NKa XJmkNZ0uOwPZrONm8WN4KoVmEaI+Vd3Z5EwpS2p5eUTsvlbMJEL6/TnZRG6Q TgRXS6UTqdk8mTSBualEinOJWN2h00XW5oKGf0zjNJ76ueKpYYOQ3nxjaBGz H/TBXmGsz9aiUTw2BXfEaZJob+F6dhdDDouwWKiMdKG4gWqdXC+olrlbXQtS hVfC86AGmGVZviOjZHot7S9HtpO67fOcgkx19/9liqoxRSAcm3uw4lUWuL8V MzMLYYOMoxQXwiTHqSXkuVWmI6oy7SPMbJQOzkYxIA1+waGJoqEUOZHTplPy f0IefqpTrduivDmvMN26bJT4uWUTr5s5uared9aB/+8M07LxtBqR/2Brzghb JUNkHX1Bw62ShlvZybXC7Mtc6Horf9K0kViP3maqNqXo7T422J2wF51eRRcd QAjSZ9rInW6Bh78v6NO9Zc+/EZkwuVwyxvPEabeWJkuhXoQ/s2Y7i77R6tIL pC09TK1NMByeYgwGoqKZysfl9NOSpPbiGwP1a/Fkglw4/DNKJLGDUdLTrY7/ qKeSoqlV7iPVCkWTUDU8oAoyaqR7nkrYjcC/YQqUzzW45GmBV1d+G60o+aI/ nMGJgzXsJbNpkIQmczqf8muqxd2FQeLmbW22HjWi8FQ2ouzJaKgkfgya9BJt gJYLeWdzCyHjIwJv4gpW6VH893rEIQgabl4sWBD/FX5nFOK5FXJEp5hbvsfI 8VmIysXsvvItsxjbF5RysOrV7Z1Z55Ql4uEiBspWch+DGK+tnbMAqXN9dO/7 znjF3iD3fTeQzG44C+d9Z9rM9GvYgPotT0+0PEQ6NI3TjcCW0p/GIGR4Sz/v NKix9LvDJI0Ldw4G0LfEhj+Vcr+a5JjtQALD9KyUzITZ4DziI0+NZupw1DOq KEt5m9TA0N+jUS/+uotZNH90pPnO09v/706z2QzA1lbRk4FOYevhzs72I1ir 9fXMR5fJ5DMiazcZw/X9xz9Gza3NRuvBw2gd/n20Hf3xj3eiO9EPg1F3OOvF IATAhdEfnG2cL+mn6VU6jS/wYdM9tN3439Jap/CwBmuGNwDvHl5Puu00GU+D loAYgLlNwDZ8ob42UYbnS4gNAtYnPSDhjj+f+c94U1QHSOqAvgXQv07is/hr 8DA5hZ3tfg6eelO+gyN5DpPj0hENuJi7kwQtuVPAByoXkIyGV5RGF4sJIuLI kO40oemfBiNOBsgXwCWGDGDF1B5MYtoZSSxJk2qX4CfEdn6704yk6vjB/qv9 9w33mxQM3u8PByfuNxUvdj+lKKp7QNU+3U9VtU81UvV67jTh8MJMhIhZNlJr EPZkqvvRJRajTOBIpmnUozU7nySzs3N8iFwO0ASis3bafhaUO02auP8wWuOC U01fOcJa+OAhZufZM0OGEb3lCHgaiuGYV1zaqhUvU04zP62VDErVRMp06/IA Fb5CTk6PbJ8tEhi63VHpIZsqPFE6Fq+V8kUIRxdkHUaOip57icB4PIYttVkj eI+0Lh4e9bEJvRGlKc7jB8AI5NVsFaSotWnhCRx07cGyH0hPKQQZC27ySaOi IAk6a01BtrmYdc8juJ4mV3QdiFHeHSczCgZIo3CL2YvT7mTAu02JN9WSZmoE 4ULQ0kauWA85mrtn8ER+ofSFh5zrlli25PIcryaa/4DRFE72eedLjHFCyPDB BIAmIjcRjxgSOuChSo6comBJOq7WcIJVRM3qdEajBO8bLuUa/e1vXNYHSUZ/ ZWXDAjuCefaxuWFVgATR+mEy6zPsi6OWcFR6OS0AVW6HpjeYNrAVHF4OcqJw JkA8gInsaXSK0+Ith/OLSyvLFdYUcgvpnuEjxn4lWgmK+8QP/6OR2mK+8WC1 BVz2bGOvBJT8oLdcmlp22wDY458ykG9mQfTJmnbO9szzosNEbBOfTk42aZ+G xyxH4y2Us+nVIvTKDtKr68hAJbuElNcYpFRho2AewTT9iQ3jkQXdKQeAj8MR ciEwe+A/VVika8+DkB5eRzOf+BAxlEwVRCqw7hJIwEY8NsSJ+fQcOyFObo1f syuRIk90J7bfrX6tUyqA32AEq/DDpCl8qm5ONIeYb/I+UvdlZD4jawt+GRSO zIMPvG4wrLfvBZ4ZYOnwTJ9otcl8Eowr9xs1gbpd/fFwdgbEQy0uXUyw8CDW iRYDqYt8d5EAl0RMT4dJNezSUPYN6BdICr1ZN+75G+S05GtrAsjcJOaTdPBf IMBEo9O2/56J/LEhvkDv4MpIQfDlZNj6xgrYCrgxAp4CnsxjKGQYp7M+l9AO HlrSws3gCaOyZZG8riK+tRjTJQ9LPCHqLqupRk+rbjwV1GL7Kyn3oKwRN98L DoL3ktaRpyf3pddrI0pnA9IY0i2g7rQGXwLIsMKVBm+6QHw6wqrBxl/ATYxD PXrz7sNJ+8XRq0Mum52a8rV0v9Od5DwxCCQsIoNwTWGSrztXRr+GUllmFeg2 /wq0f2QWASQMPck23phtFJhOSWFKXaz6HKL5FgTEpn4TgmJdsf6izrv4djbJ KRNB5cJTqbouG6Ybs5IE94kxyTmUmV15hxJ4A5buM2wEi+MNZA3eArQ3STMZ o/z8FlcXF2dDEN1aA+CqERHesGsND7+PG1igty70ev8EBImfP5zAtU31Ndtb PLlfrZZhZrgew17gFLGQuaeyzJlpoOQRdxn9hS6HHuJmOSva9M+Az5H644eV O4+HYy7XfmYFRYzaB8ao3ZtRYID5hR/pIVQliXJAUiaItLidcoLY1Ac1JIXN OaSwOYeKENLe556zyxWSDAD2gmXsU+RmL+I0JW2dSGuAARO1aIEWSa/WLXj9 Zh6vH4zbY/nXuR4gcbWSs5k4atqfGWa0mOIE0niqDCTOF3sUXw5ZwuiI2bwn ojk2SmD5gGX8+wwrDJ7BGL6YVBDhbcYMbJu6tldUriNxM2sQd9RAFvC00/08 Gyt6kp4nM1TAxZEpTEO5PGAFmqymwTRN8Jxm4rCB0KQRJfBmcjlIY0n4hGix ulWPpClaGaJL6gCVbRsEBMQJpCuNaJSY4cD2EYlHGSZKYLvM8e8EXQa8mJ3o mkBq02R5kV4RhSRbMOuNcXD+SmVIJDscRXciHy9Yz83qvcDZMaDbUe4u0PXB hns4wbkEv7wZ9D+8YVOZ3CQeEpaxNjJz3Sw0aO24Mbdx3tADAG69Ed2xJRzf /uAr6fVx8APUhC44b2m74FSDVtmB/gfp6d4ko/+KJyBN9/vIGLJCGEXXpEup ZoQEo4K09fhJ41G03tp82HgcwQP6tt2ZsvXJtwLa4k3jJHWohd1G0ZcOXmRY SqkzbkQX6RljW2SucNKFA/BGtLSc7i73diNUpicp1yiRP12xU12bCV6Zwkwo Y9hGfjWnsn5w/ZR7ilS5MXDqfu84mQwwmFAjIj8V1NCjDYwNYGg/wy/4xflg 2ubFfhrBkgGVJh1061Hj4Q6s8faDxuMHuMhfO6npwHN0IjWE8Ce4j0f22oXd G/WGdHuTShXfnhCvimoeIGMZiTAP/dasr1/mhtWOgHjPKSlFPc/92mryXKjc sNNl1omTCFmpVhTDxE91bAEy/EkXIGlsUr4zWUNMtW5Bwkq8smRwRbHwSMwy 8IkpykOXrNIhNn2KDmDYv9EtdZMLEL8HKSrGRpHhtorXCsdKE/yInkhtYs3b bb6pqk7VadC7S2redM3oud9g3nxVoXzSGVKd+7gzYe07Gswtt2J30c3HXbbO 0GFZNGS66b6k2m6U6Alm1p8NcyBy6/a5VUEiTv5K9zYtTDxpWmHHXOiDUuz0 XdBzcdR51PusdKbten4jHiUIflTLMGSuCyVAGDSs2ITWKBnFeNajn/ePDwkt jsW/ENvEHeDozLTF/uFf1mt42/hHR/JtdUQbhpZXgEKqRmDi/taKfvrJ9db+ CcE/WyHODgh8ID7iCElkOb2K+MsNpsMwATx9xunCMVbIzExjKhiuVZ5SJBB1 bASQYAxYNQXc74yxF3sDzhawb4NYJxjv5SQBtv9KgKUZQA2RDkg2nhhjM57X SZzOhtMKgIA3m2pgxK++PIgmSTJFXu0K54WeRfCBrCYqlJnfBnwBit2cJk2S dlAsgR2/2LjTlGVCThFY+w5c9rIh0DgF7EXu/eIi7g2A2xpeicOo1dWtpFZn gQwpwjqd9fswRdwpYCNPOWua3EQo3OFUp2a8sxEcZbQpNVBnLmp02BWCRMZf WBO0RDdPr5r4r5wke0yUXvVO8yzjball/Kk4rf4AG3r4Zv9nQKuDXw4P/kRO u8rRygqNFnEabCE3wi9a4DHA3MkfpowkyxZWhjUF5w/Ys2d6PpkRgOc/vyTJ u33w9gP8F5VzbFpUTj5R7/SMemUxg11B0P1VcdgwoQbxZ4BWmu1do5vbGobg Xv3GG41GeF4Hclgy5LFuzR0nTJRF0e8ZNqkaJshHaIHtCG1scgY4Osmrq6tq 7eutOp5gP+4oaqJjT9M5yXFkMPvHPN3EUE0pIm1+kJX36aaK1RYFq3xAKn75 m6ib/C03oN9S6WfNZ0o5/dTLoDF+aj0GKIpg/HS6F43h/56OOe1Aneih05tr vBOZpanCJuwvG5PQ5GgEJNmAKt7acbTCpgQnNGsIb3WE63nwy/779s9HJ/Vo PVq19lhyn+Z9/ThwanmTc04FS/NS2yR3QEUAcYE+rI5ZV2xCIUiroYzQuxzz ZLbHZNQ5hSP6ec//nozU7nvawfLvPxyc6O9Vxp6c70kXbj+n/S/5Wmzg9nvB i5IWZCS33xNOlXytVOq2jUKzspEpQ7sbnsLHTFs4lB24KvhjlBVmowlevXR3 r0rsWWTdkrOywW+jJSsgwD/AlC8vA2O+bJQgu7vo7cOeNUo+BLSqN5jEEF0x WOQ8sixePNtEy4Pd9mebxr0nMxbXN7cE2YpT9SD9ccNQOKcIgt8zrZbtmTCi WscmUwX8Ta0y/UoSIgPV61YwyfZLmFKpX2nJHVOzsGP5wlE1r2eFX7Z3jTiV BqGA8EA8B7RgPOrjDNksEkR/o0oXiIo/xKMeDP3HteDStW4yx6KuE+rJZIu5 ueBGZ5aU7U/D+Az4VJAdjQREyTitxGV4vkGaw4AE6nP4keEcFM/Q8Il7XcxK jq47mt5C0v1sHnFvNuXGtbeHJd4AZBTdh8u09cGj9010lJePR9Ez6MK8MpbW O034P+L0j1EaxAV18nEjenV0fMLlAnox4NYFajrOk0tmDzlA6BIVn+R9d4et usjpyZGMSMDaH6aJZHYJMuXmST0EBXs0EvqJbZK6XUa2AvWLccq7mYp2Exix JCaulxQKO5uPGq1WtL698xD/hUfBtvrcHj5B8iXXtDXijUwk4eaeeaM3tzub 4E/8YLVVxMBEZiPicZJuiIOh6dCl2lAv88KE7AjtQKiFq1EbeQP0oryrBXk3 s+GTxQ2z0ZN57UqjLu2A6Tzs7cHaAzNBm7fTarS2YfMebzZaDxfZPBOBFEmk WVTztnOgAvTU0ODvfuGys8JLWmmdm+DGT08zE6vlx5OOdAxps1bTid1VVBdd nrHL5Y5uk8cDzNhgD2mbtfuGx/77DGUtdGYkMyVJdCb2DA/3f85wrUi7Y7U9 qYniYyZfxZTRQvRxMWu8hDXL7U+AAnTIc+/cHHUkAwQft4gpRqdH1i/TkuPf KHm3s+yy2Sj+ClvHrtMIayWNLOFGmsvtc6I/M5KbmoALxKvSkKa6Z4aKa0Ff 3rdHu+6mEeh978ek410ynsakD+oPgEZdsMyL/ga4bUt3IhdUh0hhlwFrUdBu 850xSmjT+Qw8eMBn4Mkj/HeRM2D62g0TFkgfQJU+8fnjD2nG/3hqp7xnVj5z zR28fXMMYuj+8cmqIQZ65f1AxZz2uNr2I+mddEYYrnlxgUqWnn1xlgCWUOQU ewjR42skp+ZQh+B5Je3O7dkv7SD5CK6vfyISPIodPSgYqwK2XgYMvzYnH8Zo WGt2Chz30COdjLHD5LQzNFqAERwno9D8jD86aHtgzQldtp3RFSHDg9ajxtbD aH3nwRP8dwFkYGMHc0HsNELckJK9rAey0SSqcCYpiiexXN9C12JMuAv/Z7wg o2+b12icKW6/nts+BMHOf2bc08skHDfJmMIhDCbRbMP3dYv6w84ZEcc7srOk uBuPJ+j3gFvxpTOcIecgjCSwhiPyHwPOxOmGC5aEuxrBycaunmYdsOevShbE ei6IvIUpGdNtB3SD0fA2vQJ8S032MlJ1kV4oXEZTkECCXNxclBMh+8xmXnni xl4I0ca4wCHNdLKeA309H+x6Fp4zbEqT/mDU8ySaGaOZydAKIk+B/2OdTV0P t3cara1o/cEj4Ex38CyP4ksHyz/JHEZDokNKQmWD5gEExlXkGIg7Ido8tM2P olTlpRA1eCNiBZEqwx8NkWlLLXPkvBVQqcCfpINMXRyqz2LeX8QX3fEVjgau MrgVjSijv7UfD1Nb9zlUi+hPAidJGaP/3pZuZ/2bGazN9alzO+BjPwozanqe GfYr5zecAzk7rGHK7695g3eeNIBWP3iyzebiG20v7uzQs+mmLuBS711atC95 eynrUGkZ7BLmbMWcXVIw8heLlunhJi7TQ2NVv8kyCZMvN3ghhsp7OyOPFCif ZbdOtkXpQml3Zsn+nO4ZnVrEswQRZgvk0IdbjxsPbz5NOuiZ1RRpNc3xJ1aH /h9PIxV8QxzJ+xgvRWNfbafAeFtjK0YYIF+xcY42Fo89uSReTcwtEVnFyKGL 3BkvOpPP0QR+sc2Z1f2Sh4FlHJ7fkut2qY6IfVdmawRQz38hx+5gtSBGRveV 5axNj0bRT0HqnhGLXd6QHC/3KVq3yfrUU5ThzeMlWZelesNwyJF7Vidu85vw nGlIlJ8qvvGT4UxFWdsk2mH0Mne0Nj4lpRjj0qNWi3QaD3foBoFHdBlVxSbB Fi11Sngzj3XaOWOhE04v7IG4wsPH9NQHosdHpqJiMhSVvwwum6Jjmn/O3D0i w4v+oF3gd7XNgMM5555otxioW2Nv09y+3QLQ3mw/BjK2/vDRVqO1abcm4BPK mQRzzqkTS+o9EjeJS9c5yllOaeZfuNqa4H8lSx8yRuqLChQxzNlsdtDCmG3o TzbwH3QHsh8ZbiLvY/rRiOQfw2fwctajNRdhJvzWo4cP0Xvr0eZW4wlujHgC GqeXVWX2FHoVTTUHEO6BfD+50UYE28DmJre+lVZ3Qkvirdc0YFkm9haiFcA7 CK7aR63HjQeP1Rqwg4dCyiD6hyzBbspf5AL5Ujb1LyW38Bd/+mQ7yyEC6/Tl nJX4gqvQUesgD9gFlH3l7SH9IlRUe5KMXC1dez4pio4Uf1TJjjz1R/0kOnrz glzrD/9yIvVPiVrTYZHSyeJ7C2tnfYu024ooyxbsklZU9TqvRxtMdmddtjgo a++izRBSI8peGGGMbLbGd5LZYXnHGJDYTX777gSvEBb2zTshMBxXI4+4sKRV h8Mj7HlD1uyp58RQjzhy1+VXSSgkP6L1PuB0FuLsfaMNpjWvtNxuTe40ZbkX XWfOUyPrLDAI0ecDWosYkBxOhsHMUbBXxVvlvuPfJTsbZXcvyu5e0+5e8bZl EASJgbfxoi/iFpHeaDrF6/5WcxC29WKsvOnsH5g52YufMYkCr7xlOv9dXhj5 WlRw8OZu0iJHzN+DN4fHJ4fPvV2QdX1acODW70RzqCl7sC652S15QfTq+ET+ SuJCFK2mvazoanvc2kR+ax2vOH27LwAIEazH1WZhrp0eGjPapFaQkiXw7SYf APjMxe/jxZOEjykL09NIQvjtigXUgQegF6YR9ep6ifMxq6gdSQ3kYNyjau+i vqLt7kXHxrcsOuGjYHbqrXXcAhnv3dtjTFrzHYAQQ5JEf7NatBWjCGTrOe3b 9hYyZY83W/APSsWJSlvjyzGp2nONMjDS10k6bXJ4yVDjHW4eL2Ey8R1MWcF3 x4WD4Dajb/iqyp3Q0DkS8mi3F7MtsqDnpE4mdPG0M4kvw3AECkHu68+Y2dJh 4nsi+T3eadFyAbY/Ulheffjkko9fW0Tn/A/usUch3GOYIDw1oenyUEu14i+d +86Zi7QpeK0RGaub30ps2WLtsWfBrAQzs48fPWq0HsBa7Bj1qXe4OkNZlZIl Ea6ZEqwRqqAbMbAMHTIALLWWNsQTGMO+LtFXGPH5Ap3oqYwXRRR3YwFDOSQY jj0i6KHZi8cxmS3Y9RZj8mMgk0uYf2IpOo3JPXQyMx7Qkn+gbRWaeo85EVVD dnRpqe4SFkgDs1MBpcl80sCsOtOlWwOBxUIgLUkNVwIl4EDnjOjWsPTA7KIK zge6NxVisrSctrG2SrTUh21m/y34Neitr9cbUatBVlVRTw3jr/GkzbZGPQKb Gq0pWjbhUKYWz5DzOMM4wYH4w8SXEfYnqSckEQnTX8YT4lG+EygRFTtnrNQz 5mpmeoBK9MiPn/MNiUe46w9OA5WqsdjqX1SKEvF5c+veEKanySsY4Bbmt6Th EaHq1Tk7rPsu2PHs57IxVkko3hPMKpr8CbkkgkdKQ6QREsDabxzyhYn2gOI+ efyAKa7HF0ymX9sYvr+aczFF++9fUqKYQFF2X9lClY4YMGWUAP5nTx2f+OBs BN8Gq5NtQj42ONzp2LWyqo9QfbgkE1tCjofPz2T6Je5Wbo3fqva8kg8eAWu2 3trcesAs2k2WEn1g3rw9OWwfvTl+0369/xcbw8HeX5F4uwq2kpPFYCR+QKJD QB7D2CRJC9wlNZuGyjpcYkb6xfSQNoEQkfq021PSNNioAghs1VtoDEzu6OvB KB2Ro8fH7qebDacYmOCyeDXQF3LCx1m6atCoTd+ls1NDToWO1kIqaodpSShj zsNHeMUD6mw/ECe+mx3DjGIArnObGcSL0cDwQrJkH//19c9vX7XfH75oP98/ 2bdkT9SAwlukVxc0bqH5kX1QdH9PYpDvx5hTFUQI+LFk/O5Mw8VQbl6v5oVw gR0MDJHezYNFR6DvV9f9aTKsghDypY8SrPy8ycqtl4y72omb03fF9bvBOAL+ 6far6Ny+vKPlZiAny5zi0DkR1ebvT/7SPnj7/FBcFOkQtp6w0anVevDwFoew ZocHM52dkneS+APAT5/ZozXid0imp0imPZJTN0a2sGWAs/57yzoQK8KjWSLy /6ejN8+j1fvLm3WXzr4IdrCfRV1QjnvqI68Lb2rBxn/HyZH8tf/mpP3uLdCy /efP3x8eH6NJ7/ea6twOyTHO3CZUHoJSpltiK0i31domH5lW69FjsafdnAHr sy3PVm/DxnSzDdTNxqbjC05TwAZk+fGTtf8ioLp9gSckquGzj/IE/QBP3n54 9+7wPX9sXzhaCT3lERo+orDCJmxiacl5ZFemyjxAm3p4gZ7WC3sqpV/SYWQs 107jVUi7NNHySRWPjDqQEX0vWMRpIxfwC2YIiKO/Sej26hJdK/HX8VJ9xQj9 FAUrH3C6Hgy9Z7Tc2WS03NrcFgu8ry8UaPl4icu6f3Ly7yMXlF23DgMrYB9n slqyMh5QgpP3h4ftt3AS9t88b786fPPy5JdodRUXqB4ZYlAOvO9RmvDWro6p dnC2skmlwVXqo2SM0Z1iBDZ4shAGMwY+ekD67tbW9uO821g01vnYV7f3/h5p 9CKr3PNiVLWDCL8Tvx1eSBOYYKJN6Gl7zFn4m6bGTCEUtuUPUoFjXLQxAyF8 Psr/Htbngf2+hh5CR8fPj14enahvPz74VDdvMx1H69FDAOb6NZnE7VgrDda4 gFceranuVDBcV/ypynhrxj2KPjO5GpURzW4KOgdSFPMMrRH5nUd/iPTvqBmt bK5EuxxKxMj2hEMQWlsPnoiudSFkIyGbS3p/hJF8ssloOE4niKbQyL8EF/Vw QIWq/racmtzLSw03YuIl2Fsjf3rMRunesxoMp5/ekmn42n7pj6xxwi2VA7Sf b1jnWCvR+y1V19HcvvO69rtSEvr8IyiXmz3J6wu2mIOJbO9XuNisefYchtUW g4OdB8U7V/huw9Q0i7wAKv058if2YjfkCovnZQx87sKm9bY7FpWANkoyA5nO yvbOA/T/am23xBA5niTdOE3bZ922MZWt+najMB2x2H88e68h2IkYYeAZGYAT Q7GbGYrtaNEUjtdw0DEkBPeLizrALy/hct16VMbTthkQn+4qeCpYKpL8bQcD aICIVUDg1osGqn0HWBr2oGr5Nw/Z7UBVBu3wqltT7/i6461HwRi5wu2tLbmT b7L50gffpwx+3ljTz4NxZpD4sPQyts2VHdkAETxYc6/Qj8NPcRZ4K2DNI4MC bF3cK6IoxT1rkpLZefZNsHt/w8GJP4MdozWam3hy2QxnyztBPeGrw18PX3Fc 4zlLD1RojTIgDDDqsR9PqCqtSTVDNvTvCjPSsec5qO9u4GyCczpjxSEpSHMI iXcebBL92mk9QPMqPCvq1BpWXWUZ33I9VklU4BsXPc2ZUeCni6+hHCnob2ro mV9pxmS+eQFMsx7COFoeRyvIGUgXZLujenaw4UChxgbV+L0599m1GzM6qNAm ly6P0xlgexsTcL1XUihnS4av6+PQcJd70cuTvzbhLzvzoFCOG+a1idl7gTb0 i854jIZi8atHhHhhUmjpcP2pyrxl0nVtdDmHP+3vgye8vw8eihssVudquzxb phgg54C/GAMcjFBEYjI2uRBdLJS+ADiP0pwcl31Ymsr5JCX8WNVtY+epvgTw ZtIUOncCLyXksJNO0yEWuSNf8kn3HK1WjWjlx5VAQFt1nxoeFdhj93A9agFn 3BeC/3CT/WlbDx5tN7Yeq8PirUskOXNfSFYu3mlTFI5TaHHaWEroCXThBVdx uyc1S+uSS+wOBzNPkcUk7QTn1kTntBeMry6LaxhzV7BT81OK4o55jdcrNc7d x6blCliPVo+eqYytKu7j6Ljt1XqFbz+6Dz/V1afoIo6XCuynqfDqvvSuM+NG ggEeLk3seqTr+wmCCa9ZhmTrwVxIGPHns142H5JPvDmtZ+ckcRmF81rX8xJ5 MZybKfaqlU0SymZcob8PdjbLsFMq6eCRj+yZh3vwRYiyJsP00Zt3L9Cd0K1/ +ajoexwYLUo4uIKBYaP8sREUGB+BzZyqOfSvAu2rRPeCcgNma6UK2ZxzKEh6 cwCGmipt7qoGoCikfrxblDC473k23gqUGZrR55YicJAHxWIOq/WTvv0IUzEI ZQcproXOCg+xKBrdk9VyGffr6jZptqqeMXMaMulwriTW7gVlHOXc4w2TXrIz uioi+xVP0bx+xTX6ndd9edflJyM3lbN3MErSNttzwab8l8JbzydQnEyIc/G7 uZ5e3TG1bijfraRpFOpAzq0562JS4R71eVNGyRTT0hvBTRKUmzFRanRSCyG5 GSbJZ04QOcFVs9SEuWTCU8KpvaKT75/QSiQghDTJUIWbwXbXoFfIQfgpDq7M aVjPuYf4yD3awRw/cOR2nkiyn1xmyradqMOFLpxn06ZXGIVwG0WNF+5iKf0O 8bwigee8W3NIfPajEmQ+ANTAxKd0VilVsaljaCgUjlsNGDHclj5C6igIaIlk J8R3CQSlw2vZQ3/7bOOnZUQ8aGRO7NOc3Os5KDK/j3zUKuvGXlVRZPGcEuRG T3lZVs2nf9AJxZdgTZfTJmff4Q8adgFFofdoE/ByE72PHj560thhI/QczKSu TZDKfyDmrUWHVlRrS5LylMKlO2madAdUFkFjJWdA5tQmzOaZDyU7HRKt2ZTT 3U1ViWj+eE6RG0mqpvo2Wa27MEys+M2psdJBT2eaQhqGY4YnVKqItBmUgpfT 5WEObDsuKm5CcDD5ETqh5s8UqQKInYMN+EaGjMvfTOuUuWXdUGgz2U40mQ1j 2qZeRBU6x5gF9xzE4glcSrPUEHIuF4wfp7KCJo+1ytFP79uU3W8fqQAz+eTz DdMy/TbQxxbgMhyVZdynIM5ZVq09ArOlL/ZQrzOQ8SR9yiVNZ1QSc5G4bU68 WnhcJCFjHPa0BoJY9J5mP3HTpwq4PGY9DEsPzASb5NuG2gOA4rqBHlyZlDT+ +wyVT7a0La2kzBFdjtnh8t3b46O/ABQssjTq8ZbMhnAicGRxmkoqgYsO5ovt 6PI4UoaX6NQlRmFNJ51Rip53sU3paUtwdpMJQBujdzKGTwbz4qom/jdmroLr WeCmYFzUS4aYSnQ3ureJy4GoTKnq7dnCumGTmOfQiO618r5hTwrGEfrQoeEk xeqcmPjsPE6pvo3wLbh7UhU22odp3LunIQMgQncpDYSKJjj9FzJcmRadhQSz dFPlHMCgCXqjWcJhomLIgQGZOMC0hr0bYFRAx2i78IPUpDrvUqQC5ezG2FPM AS/151n/hNnkGlzjBVM/4gGZueRWidma+3YTAAj0+SOVhrLcp87E5BdkO5I6 QF+Sz6ZYLnWG9QBoxhiiNxmcncVcoOPP9DL7qpF3CgCGPeiYCM8SF0s64J6w 6GKQBTaNq3zfuwcosIlGjnstqj9BQCQb/pXdPWYRrT6uY5awwRSAE4/2cHWP JDKkH1/yLvCoZcUxbx9zn8MrvXh8QcB1NZsCjFk6I+oLsCkJH+9GWkoEkG7L fvcnMW4RfH1hUrXzPGRBLgTb5tVOW3cJVNkkmkqxPaq8NaIiDUBRxrGoLtXQ +BrBuaQw5TSkoilnR0dyMMb61sksBWhUNTVk5lJcVKaUlDHxbNQhfwsM0Omy EWYwUiRN6KqpxSejXe3DyzY3QKxvT+tB8BJX4zL/cvF0m09L3y05GkyEDewx 0si9misDJbjGJdSQOsjYWECgVhNKarZH2SBfUH4zLJ3Mxc+hDSJzw6CDuLqs Re8PX7YP/3Jy+Ob54XMLknpoT2U0k5hhHgAAKqaepePWcyY5RbrJtE/6tFAz 08TQy9mUZnkSHiqc6EXns2CZHa6HFiSIAc3Fk3bvCTlhme+A5o5JrzPiUmv3 Nu19cXmeDB1AIsjC5bjaUQWjBRB2tHMHG+l7hmFmEGdNP9oz+ewsOeiDjAh0 dDbErPyphbsmJIKPzNTQep4KFuwaqU+nwQ3nSLD6SI30CNkNovTnwPcS+Av1 pdBqCixSRbhV3a7rPTlfL8w5MgTLVN+J1jbO88qu+gXaeskUy6IAgAqna053 3ZLumF+j7rpVu3O1ql+hU+rLw79gJhI+NPXN4P2L9x9e7R+c5NAN+taKn6qY ykRYqjPMY0x5Bx07KRwjB0m/p8/olifO8YKQPr0bRQd2+1LLoOF5AW5sEl/g PT2J7xq+MY80KSaZqvcQqZKKgd1mv3MxGF79mK1dOUiNa6RF+2/R0v9ZXf34 f378tPZjfa1uG69+/LjbGY5mF7uf2s1Pa/Xfftvo3lsSJwFNmBpqoeU1CmgG UPPe9sY5etVZyPAAA8D08l83cKILDeb8uw3mvGAwsJw/J7ApXSryA6fiPvyJ LicbhpEmyFgrFY8MHDz50Y3uFq4ugqo2ehk4g+cxM/Sqa4dD/X26gpXpjn/s jrOrYR/Rcox/pF8l62GhLLyjpicarukoGG/kD1h26r79u+uNXG+k/aBk5PgF DPtj9/zTgiNXC206Kh85CX+ohpyNg+X238jY9cPSKagPb7ABXt8yG6/rkkkl p//Z/RH/0wSaSzeOzIme6RdYa8v7uHhG3neLTijoGOcT9FsynZdKXjNWfqmR ivcpcjlCjO191zAZ+GkIa9Zn3TC7WNXWeZf4BbdMt8cBTM4oTvJQnj7TVzMM JmK7DCWNrLUrbKgFRFatSK2j7H3N0ym6bm52y9B+GVIu10mm5+uGLBKwxhfI cbiStajZmSIQkB2aGAaD1es4EhXmptlY2RsWIa1KVmKvuz5MXHvesZ4rLgcT P04MFFNxARYqy0ctvFDniy8U/pvpueACyelxMFq8y8Go+BJ5DavVYfMMsNGs TuNCc1jqqEP8ISVh6HsiHwyVwxw2/Z75ofuv7VHxvcdyypRqTDjSPhUQVUyw 3lzmvYnw0vwD3CG6q9GMBRtzZjKIQzAC+Bnm9856ObMtCUiY9UXNrmSm4t8w JFaHr38rUeW7ilnOjGUfaykL+qrmXaF9vqgww/LYNl5OIxkm/ikjpCz6xoHQ +ICZ3CpjnpOanpsZdZdnlsgzSXjTKzYKWytCZi4W6HKqgZHnmnnXUG9YFmGT mvr+mXMAsW5yImIIPgzSLL4AerwE3Bt5pBplRKcVArkBhHuqVUjCRU90P8pH jGUYqwPG5tZewecqdNrTCAhdzUa9HCL4R+PNx0E6dg9dzx/dAnySb/Jf1m10 wLoXZZX/tXHqw39MjbmyZZUTisnkgdr0J8lo2ozVlFIh1jVvmanKqX/aWZ5G 4Cjr69qB2HiOto0LQZJdG40yOTuAar1o1eK8Ww37KEjOQ0e0EQzTNfPcMIX+ rehvV4iAuVO6ZI9eZidsnTxa92tj16hOV7vaBpMys4KKv0oMS45OeG0RdsVU lPK2l4FMmz9hHvNnzZ+wDukz4Tyz2K5H33BjmPrtBNX0x/kkvlzBsRiJ5xRX 8aWiiXa7JH9dfOkwyL37Pej8ZDA4G8Ad/t0pvjeHnFOQa8incWcHrmAR1rvf ti+1mGWdBXdOblfqCuG+/Nsm99ibh94SaDrghiyvzCI/1T1oFy7Z92s5uaYQ qjUBIP7OpWFkTmSAfIA60QXm2+qimzQZ1QZTss6IFpaFkpP3x5hRyxraxGL6 4ujVm/3XBMaq0rRJ+N3r/ZODX/j+8o8RbcOddQPQoWrbjSHw9RgMR5h5eBKf Uav2NBrTHx9bm59s+qIo8o/FdJKaY2ayNgL4Tvcz/mzL3+qgpRTcEJy+Secy fK66GE/1G406PGTGGv5bckVyt230PIlW76uR1FUp0ylVak/3ADWwqOl0fb1u 7khakS68x1cu/IcS66zcW7G+rVgjlIIBpx9bn9zLGr+Ru3Y/6iUzTP/Hhk6x impUyDOL2phMaUaWMTQDGMeEGdo3BSRKBdYK5FqSK8IfuB4WybOyLq0zLHjl LUyDhs4BeXAAXLCYjUKkOdYzs5PQ83ubyqaB81G2UDtVJ8bVTEVYmAAHc/IS UrDmnnqfYlSY4CF/+2ljctFOE/1RnP9RbD/yLvrk6XIPmuB/+eOnxKtiSb8Y /p+f2SQS5BSdPHtKkV0x/JEmNmTVLmjeegpyrgtgzLefBAtMP7jccEqG0XNY NmRmrYFYqbMRabAi89Vds4L9zhSuEbxlKIWZQQY0x4eGKToi0wmXe0KcHF52 rjgMwiSCnQBbAuxgp4//pdRTxi5P3Y11AYlrFwllHpXiVpfP3bU+nLkf0vVR p7ykSJcNXfjL259fHL05Ov4lA5hIF3/Nn7p0GNTYJwh8afgg9HcaT4yNTQzg F+jIQstov86SLZM7fzrZszygqTqvbE6NwmLzDc5hh7iQxpj9qwtbQGaTlLxk LzrkwKSLvlPa35RLqmMCYODx4i/oO+OK0iFIJBdBvXgX2eUBfrEISONl+EEw IXBUIlDWqYnvIpMllxm95rwbddXP3G2+E8/E0pYhw2jzSLMNbUKuf1JtgzKr F7gPZl4YtjnzQjHQjHjSU3jnORDZN5oJL2ZG+9776E6US0mIiBj1Gjtrs0FN LVOCfihByRdTH2XlC7b9QoXs45HypwKUIMeM82QsHw+mK6mA4WpwQMOol6Ff NkV5gdlqEM2gcuXTaCm9Sqfxxcb5kg1N4WqWpol49FGBS/4WVUGUtNVUgzka RePhDJjt6CLpOUdxcvOejQA709AtzQSauQCQSEC0taiyCHTjba7grufB/TM5 Idlqll45TLhPTSh+/PdZhzweBcqfkU6PVugwkglWHz7nRzfwBmuzvhHvosYR 1oRw5UWjgtKfp23d3tYA1eGx2ldff4x5imwxUL3B4UcU4y7LK+/4jKhaq34g kMo2Azv13Fb6DWz/kfNzaFbQmBnKI6rBccWwKhQlyjanQS53kytS6qIXEbt9 jazHomz1bAQCSZ5XmFjUhc5OpH5q1zi+WD8lk5Ju2PmvwfDK6YzNWZoi6IFT c/r3IbrlsOOYXT5ScHEe7eXU2TrULJ04myPQ9k3CC1x9rm9hws+UAChkYxWf P4u2dDyZ+Wod3jW3GtESGTy2gqBvTGpSqfFVaePtwsbb2JjU+ds2qYlf0ckn 6UWCuMMvV/fJtPGuIkmHQXaui9hq1tF2Q3G5gE+6VGvsVHp78DFiAnqmSbEr cps5RYTTPDvQ93QcX7ILHZbCQuWgkVFYRfYTcgPPNs4F0CpbyEb0kopWI1mi +lpY8xPas7sFwUUegviKi9lwOhgPDbH1ITubwZTLmYNcFNfR5ABXIZXlvYwp OhsjDchnRMCYdnTVeWq1VXEVhTZG4zeeTcZJSgEJzrqR1i1d0PH+I2/3lb8E bP5jnfknN0jStPv4+FPdfmbIpCU169ETAsyqso1zP4mBj0qeD4dq0tC445w6 7Bfdpb1watmZsXfH/O6t1d7vU+z3FToSh4Xv3VF2s8buhM/Zoa3yHdomaFUH rlwyvJFb74x/9tBlIeePO3/FrW/GP3vcvmPF/OGHjhjBLHyfjPmTQY8HgLJT aTo75dN5IPDEqWLOXLI+GHoqoTuGnUlwDWXMmVXtfTa9mnavI2bh04b2/TWB r3vMSSAvqDRlmpug9z8s9yLTUlTfuGD0rjGvL8M4GCVNxpbYrM0zknGiraJ+ JnFG2XViwxwmFPCEwZKn6LNtma2reMrMPDNZjvuRL9Cj3TJkoTIsnkyE+aJH xQNzpXLEf9OqqxiEODFjLvMiEFajO2eZ537HDtyevgwG4XRkuHw1t3ZhLA2v C4eB9TuDYeq0X4IO1r/TqcB4icmdt4NFNVHKRB56NqKQXmlImdiAZUtTZjeY h8CYEmoQk1OShH2IB7Q/TxczBO0Q2ihOZkYIrNVIXJ98hRens/7H1tZjwqka 8IhYhXTVvCF3DFPPzzzkvGs13D4aJa5ZI5q/XQ5oBmKzxTCNWtBaHCM8ZwZt uTtSZMk5swBcKfhrUVNG+Qysb0/NY1dZDmsaWLkqjVrmeyOwvcLgURAnktkZ BUCjKgzwitURVhvB26nEOYIlUT6yR+RLM5UgNrMExAKy8OT80Ad941Vv2n4z 6lmj84i/dihqBaPcWNvcJL911uKR6HZvs0FhNPe2rOBzb7shenF33HNtLLz8 BnvGEp2lcIcfmYx9RLtoSnF3/kE34lYjagFEC9ymX/xm9z6wX8LakphnF3g5 teEHlohL1IIl4rUCYc/gHH8zn8CbMTlMoQNWbtRynck0JZOzUWEU9MqREqpT z9JkBsC2JvmlPvYw/HcdJPRUMEg9BhqneqCaIOIUwWfXBErg+Y3pIWm6MG6N FBh+2JylhFbRmfTV+a4FjkIciGVAGNzxRx15K+2sjkKrvEgabxtqlN7kqalB N2+GvAM6yTdyah74+yF8PRk2k2Tm0n8KR2WhGclBSfpzJof70NeBdCZ0kZkc NCgnF/EUUa5hK+icdrqfbVW+wcVF3EPhHkgYOeFhaDRF71EUa1/tJqJI0q+b pt9cZT/8EPPOccD0U5jxnntp6ui5Z0j8a9cW9Qwb4AJ/eiZdXA8zS5gYIgp6 AqFfptob8JWO7NbEFOa78jR5aBzlCCAi1eLqZa91vSWJ5/YCxJ2qVZOSwyRP SRIM77OtFS5pls3WuV6vuUvT2vU0TQ1YR5gPzYWWwIeYyyN73yNKZemtYJMj K9WJK4YND0azWM/j2rP0XTuPvbt6Jf/xj+iuxVNuYWwQHqPVEKdP3B7i7sQ6 IbmMfCOnTfM+GCFvOIyntGWG7zPeYIbLAawRPLBh60pDaVy2jKrRONjegsOQ 8Vk+A04lOQA25EAxp0HJGryDZYQo5M91ICjISntkIJoUZquemKx/mqD7ekqX RES7JgSHFd/W/GsNPRcncsMnk1LSZUjVxMhpxfQqMxqnjD/C8ECsHsqFawZT z6ZCL+16mk8aJfQK566TvWOZRTOW8AYka8FZt9vGCNMJsugonE+0b6VeHYa5 8PpEE8v7Fa5QlpBO9nJywRjz8YnKbdS5kSmZ8ESbk29kSiYonu03x5Rc1EsF u7KYkAPbMu5yNnGNtvxmM9eUGopDjbufosywMrAp0QIm5ro2+FZuLPkd6cL1 cwlJVlmNFiq90OOdzcb2ZrS+1dpqNR5uZhKbdodJGre9gHOTCZOzMRt+TSU1 vZwM4FoZ8dec3NQlau5nyBa0ZX4v6XuU65uvl7krBezaZLpEtsISLauYiiLC P/TRNOU3MY8ndmtz616qyiEM2X7tmZGFgZbrAcG4DBvmUtgV/thCR68RJ4iP KC2611cfFyfmAZH43eLm8DeaXMhrkbAAVWDqRe6gENZ3GRTtsl0I6nszt0f8 8HY9Wo4gu6cRb6qRmMOtNOJAZL0qup9n40AXwFGl9IattMAqBAmj9NjPps0X b99udKNOamjtz/sHf/rw7vnR+x/Ny//LV7pJAMP9uqBfx3jhlPgt5tXLisTe iIHKdIFAqQaAnD+qOhwq85NZ2Tp88n+XXA5eJYnd7XQxpbZG9Rftt3+q080U gGmokdCCO11Ph7SPQFBllsuYiclusWPRozxY+Ruvudq5B9MsY+ZMiirz9sfR 9HDzk+gP5RaH0A4l//z5/dzi6NHKe2SZfPBqxZmaEWsUjshQdOLmy0kyRY1g c5uM9vhx3GvO0EcdfmP6ZoMsOouzHkMjF4dkuNZ+kjO61vzxZNJH53es9iA7 W3byC0ZmyZfIZ1a591ZtSyZU6K6mEAWZsTMz+hyPp9mpeEO/tv40MFaDya5o lzxwelHvMZn4LWrbvPqb1u+lOJN3KyeTN2/Ack+CMUp3wCbyXv+POzbrGCWy IabCe7KGLMGeSQYJzMmEEthnXOasr1w2p6C4c1lupY/d2zIuT1pUa31ra2ub a9kqBigiItHGFJ94PQmzw+wLG/ilwq5OIC+1jGiWWViYdh7rY4xsYnrrLZc2 5sHBJZD0XGk7hUF1MKO8zXCP16zuEYd50UFfi17buYjINPw6FYhPVZs2ctY4 nCzKD+l5e5Ik0zbLFav+tvaHQaWMcf+rriPtvTNxOV7ew5SfFrWRU8J7/GC7 8RD3+OFOgxKSyx6aGeICeouDejQC1jZry6ciMSiPHyz9v1JFm6hVCnx59xw2 gws0WC6WIwEwzxiW6Gi/efvmcNdGoglxn40ku+Xgv/D6lRqsPLolc6AdDK7b 8X7XnmhvVO+WFAkonCd8CSOdbYxljbY2d3aodtbW9oNHUlTwsjP8nCmiINto 30khCZ6wquKRqIzzRdUn9APffNNDWSDupW2Y9ZTKZ/U7sMqsCSh8acUMFJx6 VHpsD0cS0YOkpCxMUlTHq6nreAkQqcdTFQiV7UgKCwGtF/TgKvnklwupVJRF vTJFyDLgRiE8uBraplTXE3FHYhx58IBquWxtP3wsFf4WxxFyQjQ9tDlsw3T+ 8QnHv/y2uRL9AVZu13sjYR1z18NCT8PlcG/mlGRzwKiMZ4AN+CyLCxWhVEOH oItFkGHyuX2eJJ/DuVeYa3HJm+Ckzq8qU31pMp0WLFBQ5+amI5JCNxVWEgtC ZtZwbiss/alrX21tS7XWrYdbD294aIxPhlcRjsh3uiEl4dB+7PzuOQVXL8I8 i6aiLilPa8bbk0w8qFi74pyup66RJOK00FZSQ9eNkvV7QIlqtnSXzCS/gpex UfOJ0NUAC45oTR8fg4VNeA4XAiZJbH/pDD9uUZG4YQ/+Vnbwan1YwTu3HJM9 xznjsKcYlrBwNP6rlrzCB/B7yxR243rIY0aOb4JpcIVvEabBFb61c2NMQzbT UeixSAU1G9KIWhkeqlnt5rNJTInY2v2RijYpecnv3G3dL7mtlZ5jzjFt1mpc 6dXRH9O66pkFEPBz0PPpe9Uh2JqVZRQ+HKRDi4XGqtQxczsMp6TKBM7v0i+k Vqvhb8tNVGhvar8qEPLI3sIVoAgSeXsdoFZ2w6oDXGQ1i/otXdVKbFakB7Ga xxb94x+qpKd7X6/TuvrHFlfWnGkcBO1b3Y7OmWwjISCPt0kWfvjkMcvCNyIf XGC11jdSSTrtoVsaPFtaTneXe7vQlBI77krhNypiOoBrZMCxIX8DbF1Ba+3f BE1MiVPSK1EVZdgBvPiaz9h6ZX9KdWClJKnV8iNrPAj1EhAwFbVQ1rVNLmWz wUKPcdvuAnCL3rBddPbqwg08eNCigg5bjx8+bGw9UsIoLSVVpdNSqFES1K18 LRGPGbsQGgZVGWVPfHWqhTXCjtw6OoTKqeMqNlhxkqNTkW+tWokKeSAWic7o wxs8MG/f45n5cHCCJe5TU1K4uBd3WNzZY3kXq/EJrAwUrSvxAOKHB78cHvyp 7QyM7df7L48OsIQUWfF9T4NOdE6hvGhfRPsxlZdIkl5Eg4kHqjiJCmGz5QJB PGlhONszDmtrNpUJngaJuMElBgef9N/hbFm6BwSDb3JW0jVD6d2yprQi3rvM GuuaRXOtirxEc5dw3bqlYK4eVFvMg4zMoqRFhzGfSjUEsstTYNg0dY4PWGmB UmDr3G4uT4hK2lxtUjrFiJfoFmYTVk46bmCokhfKupJSbng0Jb19f/SyfczI wpk0aO0xRjCVk/54p9F6DCf9SWuzscUKFVIBYiaQ8LTK6Uwmg7O2O6xpg22n xpvzfs/z5OzVWdPT20hM8b8SggBg+ewTN2x4L8pfkWoGPLf0ebOs9DnQj8Go jR+GYqN749cynl+FmVsi15sPE9/cDGZ3MKHc/vlwzdtFYWfF7qbRwMiLnJLO TROWqOYksQ9IIPTq6YDlhXZufaGdk/LCJXWr18t2Vgk4C2/wgl2HCLBw1wEe LNh9Hp4sMIQQXSr3XoxOXu+LIVWUp19IPf2CAoZUFd0cNfJY95NgdfI7vrtw xxYgxWL6PRO1fbT9BFX825sPHwnrSrSWqwbnm26iwABjmDtPk6TACJ97ObXu LwaA8n4B4s5x7ZQZdTZiNiK+QOtXzyaBSlWRM6e990e39NsIYCynaz+SMQ26 bT7DuMt4NOXl5pgCLqSCHVBPF53uJEltKRPtRbURvTDdr8Ake5ScjRfvIZXm htV70pIa3TdavpqhR8DyEudcMDf6dAm4aMn8urpZhznyxVRb7F6qFRO3sKg6 nqHFoK8vAN3TCuWcYy7QHolPSLOmLFaGS2fEm1ptpjyv6ytj/WYNN6Sqt9Jj TAO+kzlMlkBRagleEyda+BZz+1kOnXDq8fY241QLkGvr4S2O5DcZtnmXetqj NFXyBMblcds9/C7il6neT+uJTmeVPSE8b1bj0YFnlWKeFFQEGOTjrFEZbPjY eW6mwGqlwUngjosZQGpisusiiTFKWwmhcpmejEORGn/o8p2Zghl9JpmoKePt j78RZUZfPvJg4IGvV06eJy886GyUTDDygEfHlculDvkPmFRLpz2FrtTg5BXQ mDo+lUZGtmP8MGKRsacDVsD/MdKEntIWBCL2ywORxZ63T95aOUt0rY+xHiOh 95NtkeN/R/SG739PDGfx9EZ4flNEpy5/B0znqfj4jr+qYr56Zx9C80akNqHq qaB2/kRvczKcb3jqKm0XuBOF7jmGAcEQTo744SJy1lcrdNWiZQl5jutMDdAi LukMzhG0jp7yaXny4DGflu3WY4/BKHOtyZ4WsX2E2iPFyNa0VvN/uYn/KdzE 9ubOI6Sy69s7m48aOzsZR/UbO1cVc/KC2jqJ++iUnQfUG1fXV5J5c7CAcsHf 85h89ZVh8Q9h1FLViJyU6QLBjDec5pI542IYpDI+m8rpo1/fuI1/CbqlKLkB PxzDbffzXwm/nrfxBmTVbZSffyFcdiG4dvHs7a15C/O2bnInFKmLa1la73cG XSHNH6CvJaxeMpFugUCfUTYpRetzBtAoFFf8FcbVRYIWt9mWXuhV5TVLy0A2 ZIdqZix4vbnb4XfkXuZtIG2fRnO3h/4aqm/mLd7vs3BqANnVKxmNOyht9CKc d76u96TLhS5cU6kE0PPlyV+bcU+dv+h+ZDgV1BeT0597u1FwIxuczay8UVq/ HpydT6MTW8AVg1tHyahpk/4NKf1o+gfSPTBZfbLVeIJU9eETcU0pcy+9I0VF MHnXizekY6ApYzQdFpgPy4QTaW6WeqH2fa/OPgaNV2tQFHcV+oDmKMalZvfI JtYrM1/Qx2izgAvKFBx15ot04DLrzbM+UORhWmjgEChlZo7Kcyu0c5js6ebS 6lP0Lfu9h3eWJOvhnu6SUouS1a3Lndza2kFr8faDzR1WuS3u9Gu7gQ+20Atk ON6L6G+KQDAJd+TZU/onQ/f4oXUNV7SuWSOZ5nQwveiMI/mH10y/EAjWZLxI I4nZA8YUS5ECTSGWgBnDPjs3wrpJG15EfLy+3jAPn7FHPS/p9jYvaWv75kta C7yCVeIi7PpTQ3kZLGGB6snI5+aXsVJYezltL+lPxQl73MfaK4bjzD+rmR6j YIVv0tiu9LzpRUsfPwnNjiT4yN4NvMoPNnmVtze/O+L+N0RVf0zM1so6PZF1 enIrbKQAGx7KfUR1I7ZU2crIouJ/C8xrlOHd1qPNxmNYz4eAf0+cDIzLqe83 TEUJf32xEgv+I8vq+c0Rllk398BxMspzWavk0lXsjFXkcVkL3S3XFwIRuF6V el7l+1NG8/tjLnqQ6ln7DWWTnmxSHMT2w0ctEwdxk20SzV4tE8vSOVNOkFxQ wYuaQK1F4Bw5U9uc5x9Z7p0YeDfWeATaQ3ux/tYr97eIT10wLLW11n+NvhCD IrAtpmvUA5OjrYmctHeW9tuyUKjKQd/ZIGnXdx4+4l1/vPM4s+spOt3wZncm A6R7IACdJsmQ1GrtcffcEnIvRMlEdHjhd1SuAlhxop/WudZQFosI4hzgHfYv BUfdT5RdHMpS01Emnn9+lV7Wq/RS/Shnx6K2vJRuyNqpgxwFK9qaAyNDCxgH njwg8vz40UOOElsQA7CWxnAA1wXS5T33W5wkkEVwD4P7tmk/Zrb+C/shiuMW vnUJR1bth3Kjca8cWO03XK/5mUrsl3UzlDGzKswKqLutb7RTLw8iWgHRRfH9 Ruv14AlHA20/gQXTSt0Fz8xczIuq4XdkccrdZCVIMOi30Zki7nkHxD4Nogcc xVNfuOj0BfpZ5IjkjMZ3MikeU1TTinD1Lawy5V3kfu9mvA5JI2s/Ij9C/0vl jZn/eeCUSeYXaI01+bSJZOkcTuwSpw8khHq0vUVEeKfV2mIGaZQAOmHs2hfM Tuhdo3jnSvQ4YtVANBYmHjMoQTCldKZpMvzCZgqAKYoNkWqS1CWpSFwmIKbI 0eqmQzf4a/l8A/g9VQJQteDtmdtQ+MKm5DP6cxzhGb04lXrE7BhNTPVgBCPH JBYx17p32atu0o6yAsI3qc52BL/bmIxi02RLanMty9UpjLm1hHknYAMw0YBZ qVIw/KaBhxEWGxpT5bIl8l28SXNcMtUYcWVnc2sbifUO/IExL/CsN7sYy7Kn ZBJGjU08gimoa3XM0ljClhkaiLigJDZi1yQ+Ueq8XRCJcfo2gxafRZVJRREs ixUmJDgxIcGcMIACeb3DvkuHXfdnCy7ldSskQKi/zR6n4eJJzUIlT34HUADQ wrGTP6/Yest1hc/LOuKovGxXHGWX7SwfCAdFq2JU3WQymY0Rghyk5fGunx4r 8SFf66NoNyKyYpgdmwho14JG2zuMRluP+M6vjkWe/Yma4cUKiO43MwKyvMPL 2agq3XqtdeX9biT3+DIeAPSHgz975ABmAK5EK/yK7vgGs3X4k0AT8t0cMHMM efEStsd6w+vOqp/fx93ZJB18wcSQuBypiv9rsIGGUjJ2bJ6upq3XTHvRYv5r 58Fjw4LTqiq9uXcDSBlD39DnbfUh17ZGGzdN1AR0UCQkVnSxoyQFOVbTVJ1B S1OHwuYlW6yRLaN0GnNFjWkiqc1OZ2euyMVgmsbDPq3NOJ6cd8ZUnB5jtieA YzCHSyqMlEq+Q4yc4Ros8cbZBicKTIaU1A1zd0a9QR+WFNXLqM2edNIxWSC4 +i6q6i/ITnDKCmcYV382JB5MSvvAXy8PDmCQsJMJDMj4KmbxnbKuUQioygpG W7m1+aTxpAV7+XBzp7H98KHdzJwmhD//IdUy3/JpN4jR0RUz4di1h4mp/LWe 54cgxMIsLX1uTvNHjKT8JpXYz+Mh+lPY/40SuPLOZhd0EGrszLRyvhJxlftv eP9RFinbJrfBr36D0ySNyxt8UQ1wfeYOqacbIBqpFrkNnqsGvMGuxST++2ww ASHENZNW71SrdNLtDSZVWh2rVpw4xzUsbvWzakVUJ63S15FqBVdKjxKfyGoX t5qoViSrqGbFrS5NKzQVUQ2oDjkdkSKCyvqdJ0PNmX2TllHBbvL/5JvNiKBf 73GhP33M1omUtWeUeV7Oy/q3wNj4Ad/uhqmCDG/q7r1p1DyP/hE1m4j70ZLo 6Jai36Y/UPVzTlOKLzeswTNo/5zaM/nKAcAvJEMVVuqh38upUDgxbOpVKR3t r9SbSd+W0595hYzK5IJoReHQvxhgeCgDYEcj5EFTrppKtl3YyQOm22dUFz5F ugWUHisHpYV99Hh54BwHHeCdQfTTpNfENLRYw7AI0juCJAT5J17RJl6+z6Kf +GkTjuUzygi/5C+prE88QpeSWBH2ws6OqTM+5tFPQPubNrnds3zoVI28f0V3 D94VUhvJ5cQr6upn6srShuinRXoKM+/R3NgUq9JO5fZ7RP0ydYl+on+bKCRV 6NUVO/QqQGHrwu4uqTtFYKKf6B/Zwtw+/0z56DoGTeDDQvATAu+oXgXo7+Hj XODXBTTHnK0iqrOMaQEz6cnGn8+kocjBjcj/nZnP+3icTKaYlzm1NAx+tCf0 vD2bDOuqmPa7DoqzuC3YJ3p6GladY/A0lwBHQ7EJMjds35a2PpsP1LlrSr/D 31/MnPEdu/I1WzR4kRfF7U/1GK0yDGwNUuv5l19773aPd3/ePdq93J3sPtdp 23M5FMnsWJfKM+sqgZQSJsdTT5AELmUXLyah65Jpzrs4ckUv4D2knSGK0jRw cDF+t0HrX1VrQhSvY4s9+V33TGOildKyl7TpJ2nucho9t43oWlGt6HdRs3em mVBTlYoPlhL2yibf0zUhnVWQFAXw2V6Yl92IqiZq3bDPQWHIpfwlODbDErpb OCx5X3kYIS02/TOctl8gkR/mj/BnM0JHrr/bIENSfuNBHplBCm0vHCG9J71Y 5UFyAnhsU7CHE9O5IsWFA8Bv2vTNDXALGyvibcbjpfl3nwgZlf5zh35phq4v KRl7xj+wBGx2nmwCuOlEdX96pnb4kllBtEVBiokINU8gOZPzbIQVpaKV5e5K mENzbEqf5FFJl5Mv/gpsAPEWQ7RoKi3TtfUGzCcaIe3O1PnFeHaRN1hod8UG UlWdQDIrqFKqdsVRIw/XBN44uPKqjoHHpjD76tftVXrroPBuxACjZsQ92O/C gr0ccZNfttdkRfXc1PBO/DiI1gWwVCkKSvTCd0rtdHolmqdQx3dti6L/BzIF /D/0S+T6XN5C0v9+FO7hl056HrHfStJHjdTfZ7oBkevU1y6giaKtnQ3b+GRP AL7AXUCVFuq3O8S+jeJL7Zp4ilUq0vMmaik4u4HAV155+oebtS7ULThF+PTu 5P1alA6Tqcn/73Jy6Drf5K7euWBKumnx9a5CTy8dPDyxnxvC6ySzvikV9+v+ e78Us8lFoDLYrzOg9S1pS/UJrHPSpnooRQvsCPjpRedsgE4eYc4J+gTta2NM T0Gfim+sHSeuC7SkXWNzEz5YDbavge4bR2+OD9+fcDNtIqUWxjnArtsaPs45 1vtDpLtX7K6vcMk7xJxKuO+Onay8ds2sSxd7FscJ/huDTj7UNZko590XcH3F KCtUT2djYrG9uB9dGDzAeGj5pTNsT++s0zLib9YGc1UMxktK8ro2NkiZ75Lr 0vJ5qWKjcWbRXZlrmYvrWiwhq8XlsUMxBlBfxh7/vWjkX42bGv+8Kp/I16KZ fN0rbnRV1Ogqd/pfdaw8t/ewUBbmrjEwF67H13qjuJb4lVut/7hDKxVhsupQ BIqMDCQZmW0B92Zk9MCBXWOc4O3xjZRIQho28Z5sRkLDNAO2yfW40RPGMv2b crzLgLPGjOCq4hM6aEx1WMjP26qCcE743qQyIaT+4lrNhlegIoUiqS1J/hyk BnRJmkTpdkfojmuhF2CztyTpjthhvtchfQVXTY5srt+Ol1SxoFeTjoZHiuYA KUWZeiVvbP5gsbrgbTSaXZzGEzIM0LLCNXUFvcQmRSMFQlgoYrgm0wWzb9Ie JN9odX2dxNUupjQQWssBAqME05xPFmlS+XtMMxlzXgNpCshF+EnmJDNB0nG5 afGn4ez80c42AoBPoxf7r44PM8PM+fDk/YdDM7wDLi6EI6R7nkmuGHvc1Z/L 3wW3Elado6rjSLmkaNHq483NRpRDh+WhJnANRSx8jMCSe6ZMed5A7JktYMDa fAm3ZROv0ml80T4va7HEH2FFYkkSVaB5cRoT/vAHOF6Hb/Z/hu4o8dTRm5fm CjaSfmin9/QG8gwBwoP7ciT1826zae9hVOcCXcPi8kCr+Vdd8dr4JFq9D+/d 3a2lI2vCE2+uaDygiJ/O1MWeMasMBBnfrQJt7iqozhFk/Yd41Bv0szTmYRGN eSc0BjlgpRhzUqtNApLhiX8Ma1Q54mxKnfFPxwDliK/hRhQSXBr0ltsF78Ow 6tbSy4MDFNfyBSsLw2ocCPi2A67vGXq3494VijsPwrGZ98z0Hh5QYhu4Fhsh jPqe56apZKR86ShbswjVmmhDwpJcGIP0X/EkiTy/fq54SVpPluIQILtpS/lB vrZsfqIcuevBJ131Byt4K1afOX34qgX/bzh6NQRdMSgrs/lrRH479flwDCMf wLPcfF7BIIeXSuRVCL9M5nYupy2iL2nuO6ECxRzPKMCZRp6aRvPt5mX+gcgQ ifbB2w/wX/TGQaLo/AS48KeDsdRQXgTz4HgBoXmgMvUjxNlMOcgT4j99Gm3X vdSLaoV9PPXPW6vkvNmDfq3kpJPzGOkThTZ3UOkB1/pszLvzA1/cKEjTOODM Y1gc8i2XmMAa9+kyNiXo8BxccMXN9JxqQQ483ufCnBdkd4Chwda0OHxPkd1G C2fAW0oSAXcP7umX4izTbr86egOXIJ4S+x7uHmEPrFPh0sGH1x9e7Z8c/XrY 3n//8hi24z75rVlgpFEvbv/+cP9V+9f9Vx8Oab8Xbv/i6C+Hz28DoJfM0JEa iMTCTWfQ6OFO+2YNHy/c6j8vk0lv4Vb/z8GL9mxr4WYoKc5r5L5+d/J+yXpT mgjc1YwLqge1bqB79MbhrT6ehao5DGs+m+Zq5JgH42s2V0I07YAO13NUzNSe Ta0Ud8/+eMTfDApkzgzE6wVJJPYJp/jW9NHBCYmjul+Kqk1pq6csgql0xCSM o7yZvpniV07hLNpStTHitqZEHeOnSLrxplcchv07LK/5sdn7BP95JzcxUMuN 80+GPjvTdrSkK/hFSx+x4xYNeov8BvCvN5+WTDrQctNLk1PHzkNHM2ZOlosc jbqdyfcvvIiFhpv7WmUSPB9M25Qa0C9o2RI5fI6QBtsb76nvSgQ/KR7TJKts ezL9ykkKV+t7ttzsra4v3obsDSa6hqIrpnmL66V5i6uleZtrpXmzK6V5k+uk ufBV0lz4GmkufoU0F70+mt/76qhumDKKva+eiSljrmog9spJpTKYk9CdxNRf /0LcGrPeHRQyOnjwR57k4hu40CiRK1w6Dv9NoslGnklLclmVyY2RzXlcflnS afVuSnWFebdFKE3+hLVrMJ2CJx/681DLkN58Jm6fWO5HBY+G7FsfaM5fZdJf cyXTrwuxCb7I9rWMV1CjyrAMX11yngW6kSryUfaWsAXDHX9+K01DjsLH1PL2 4WLKHGiiEg6ZIAXvu6ArXS9chCWXB+4bGX98fKFTiLcPPBihw+OQMCZ7nOTW VphnmQeqm4YnN/ASCWAuuWFVuI3Xc27OvMzwcGu2TYaiIKMKfUIWO82ezSYm K8p5PILhxiOgqWeiCvGYPGYw+lbpy57uTLIMCPKeN9KhSRxoteU2PEqPctUG L/K5k0n9ORZHBadrx5seQBxhgUYkk8A/jqYz0rhLx1SQHBrIcBQPNEgjKY8p zCq5BHikgqjuaQxf8MEyfrQqYEAvjgJO9eaJG2OAKeMAjPXn2VSgTE0FhBEW LWUrRdqFczAZJE5dDViQ59wR3ilzGXu1A/FtlR95sAoYfN43KW1PQSrJaAXL mIzIWfky43+JM6adILxHCpd0u7MJJmRkH0C8lJyjEG8UcP1YiBm+Ob2yPDup mk7jbgeQCg9xMoLu/Y7TzkhvW3o3PNUeobPVh3kKnpOO4BB9i9Q2d8/sqqi3 Bdvr3XmibMcxZOI5zKk3pnEaBiCu8euZxqMQOckNhgjJ4AII6KBDG4NhMrWo Q6bZM3ZkRhiYz0p5122UrlDmKhCnI3m+6ciuyRcGFMwl9JDZ2AVSmQV1SsEc RZtLhdlrk18INUv9dsLESRPPgokJ37zb5Q/B791I5Sfb05r8SidOEtQyMIYU euWr/4XnctEzuVhvmZPrL2iayZFeuBfADksKUidQ+qp9LwX9zYiXDIoHA2BL Zpa3ljehcQt2masIDpbUz71XsqDj7nnbS2PrpXCtBsYpoylObHuTUwjsPHn0 gFMMlXsjBESI1W45dMha0XxWvGkV2gsZa9h/JzR8NHMtHMZykW3Db4xjz3Oi 3Kd8M3dOsZ4CNmkaQufulEYUT7uqXkA5N3Y06sVfd9G75EcbiHh+5+nt/3en 2WwGYGsglGJ+O+AWWg93drYfAeFdX898BNL1Z5xWNxlfcaR/q/EgWm81MCyQ Qkff8aXpuy6iQGliiShMUkX50BofALwJxTKuHtSjrc3NrQb+d5v+u0P/fUT/ fRy9wN04TvrTS+SfXyQzdMmggNSjUXeDjlB1aPjf1iY1mgMX9otiQA2XZ4oH geCxYWqubTa2tqP1rVZjh5PkdyiUgDRL8NmeURgxjIO37/569OblNnKafSpS Ba/vRD8M+ljhFxu0Xx6+eUl5Gn65Y1VT4XOKft1nkGNUeNKQL5IUWXE8GoRb ztGElhs5efQDMHkkiYU/jdGrBeYV2zJIJtvk34H75VAqvKbZlYMCZDvdbkyh 3bLdJhwYufjPMMdGdIDp8fZ7HVRTdkQGmMRjICfQL7NWHUl3JuCNVmQ2Sgdn 6ASizqTx1vxVeHmTeMalorCw+fT5Hnf75MbBznQcdjtKsRH7j44Qb/uk2jTi vOdPusELRxyfqf5BUMRn1PKP4oyHaJL1qLAueuQWpd6D1POt0GtCxC/2pxRf GQIPnFhPPFQwZsTGo+mA5z8bQaV7Hnc/s/QymHL7XhybqOSp0+DSVDHimfVE ANmW9ppybS+M8mGlqF3ltiAhIw20Pk3OZtpHhqZLU9ir1cjj8rJzlWacQ6UF e1HAzIPlsC5OFCU8m/bJIQ3/2EOgB5iasxdh1oE4HScjYusVr9kgLJ8B7rkQ HmP+nJf3085F2/StR+ye2SVUKcPhcIeBj9PU0A+XBBRvRPF9RUMsAuhE/WH8 dYDITZk74M6gHaaDMpqBbE3KbwaB3uvmvORilPtV7JMDnUabX7cftbo729t9 3LgnWzsPnjxpbW7jmvTi7uCiM2S14GUnjSbwR3KBkv55ksBR43Mh1anckZmL qx4umU0XMpcpUucGaI+DKfXX74y6V5E4YII41z2PeoN0PETc6gApnGCIGUwC BDYhgyTdG+GdcX6EbIfI93dJoMYDgWp+GmsnQi9dwPcRVRYkY7QX/RWMP7/U 3uoROrkC1tV+4+a9JPpW4//9ZotSZSo0nqJsSj642H5Pf0z5GOU15VmlP5Xv 9d2s83Udm9ey6TnU3i2PEZRs4TJVgKZ6n0sNamuqKji/27W66buRHYTXaIiS WeCM1rD2krqanSophNSAhL4q6wur+i1oi5QEiUOA+5GNJzgxoQSovFJKAMZ6 zPOLHKJssiRaVVu0FlnVs30tCnlPLy297St/Tgo6RxLBvAGtDGq/EL2tsm+j u+RUQB1aHr5yJKWCFO8mys7WKeBIJyiAJyKo8/1Mkdy4gO5WoGLfnKkYdfN9 GBX8gW2c55/Y90wmh+Hwis88jvmSE2EI2U9Fq2ncOHpR3JkMSSeJ4kDhAnoO GzmvPU9Fs4zv4+lkAOcW7XVd572pLiN9m7MBl+kD042BcAHjzvTc3HgDTgji XfKFFzzjBtbeWietpIoOcYZBHR8SVQoPkfQB4i38wr9gG0ZCoGwh8RCG9SWm KVDibhA9kovo3qpVHDORwI/hU7mYO0gQ+4OvuC0v2NmUFYuXQCRl1Do/C16L fKOwZdl026ZuVwuyeJtteil+vwa1OznRFdbfn+ynakXurOcaFIoSh0ugb1/i CQJ9ZlEBVBezoCQwS8OwR63a94Ntrh0y4lPDzAqiAU7gg+hvreinn6Kf948P ueOfkDl4tkKswqBPd5qi01QGQRSP/OWG6ONYBjF46SzuVimX4EU4u+Aip4Lk EVrICaBGB5AVZkxBqOhCdxgTWwHCyAD1kCC6DK8EWJoBxLqKDqYP+mw0lCDp APHkfOgVAKHMo4GRftakKDQSCQYTwgf62F7MaF0xD1pzmkgI8XiSAAG/IPmP ibqPUYphY4zykipnr9w8bPIrd0ae+nE+ZoVYZQUag0DGPV4Gxd8b5bM3YC2I DOMzoLUgSzMpQ+KMVNjcII6ETeKM08d97SK5lnsSOdY+DRcsXKqGxxGPzMrl xwXNX6tgkYDxGamFWkDazRd1aaXmi7tcEUAkJUvc455NouQFtmQqFlidrqZS Ur1Z/HZhhTGH1Z5JYoXllkQr2CFWuTNBPQSpEAYjzKaACQw6GOs4TRpM1OOv 5J3TY2vSxMnov5I5kFgMOClGGLF2woG1LXt540VJR9uJpJ4CKXOZGvNJKtcV dXrAFieaRIN2RClcTVTHKSzYpaxiIL1golEsbI7pRvcyb0l5xPki9VsvbxR/ o6sdZeGYmIU1mwiOTIKiWEhmqTBUmMjrrDMiPqaTMrHjlIxYNgV4JpwMXJyw m4RTjl2L7rM4yb85KBueapO+rKikVjVmBLfUmbJHmVd+NZkQorV36v15Pki7 EyQXiPCUC9SWKRKvJpesbMOQUipEhB9RAzrZpH7CXH9PNxsky78h+YmoOdbA QM93rJRyEV+QSTo1wvZgREmbrQjMFaYO9l/tv2dAxyrkh7VISt6NbEUq4N75 +xPOTEc8l5PDIl26Sj5ExECM9Iq4NKlOi9eIahjlt+nx8mHWKKc/oACmZgBE krAymHdCWQg34YoWaNnx7r9/v/9XbrNPaTtRw+g+DvpQtbUaNcrve4Ds32ja BIHHqh8s327GKxNHYAbdnaoC713x/aGPzxM4z1cX+BFSH8xIF09iDMvMANOz V4llvXWUSjm6UA7tgM2nQonwKEBqqsKw4LihAhHuSDuwVZP5uYFY15bafPRP C5+a7+jJFj5BCPbTlv3APmpv+Z+kdVx785mQCqV40QfK5BGjE0J2eu9zOkH8 qO0OkUqZudAxyjtHXhJSwSA5F034cmbTb0KL10lqaaAFSL6Q9H0aAsUtBZAM k+hZCNH7nPOI8veSBJAKCeKyrHAy0fZ4OlnxllJu9ssO2oxh09KUG03P4Qo8 OzcyqSjyYkudAor+TesGDZWnBKI0HPJpkcyCibDBKE8gySwszcNN0SlYWio1 LqqQg63F/3ATpBYONaQxvtbhnjgGDoGkaxF5DY/KIP+H36xgwxXJCtw5Tb64 IXBzkXK0NCn5pVnLiU4TqL/yMEVZ3lXpg/wWiAbqe1llt6FULnJNHpAu81K1 Zqyw7a8jyVmvtj9EFpq2Qhgf3/L752XQcwm3FP6GMwbMQVL4CmXoPXXIj1E0 sQW/ERdF3fBF6KdBNcXskNmHhNU3+68PWVxCdQHMGiS9F29hFm8O/3JiFA4a Mwcs3FNpdHsJuwjVjrnvvOVwOW3zs1e799hVIwq1DuXW5yhELcmZHAyMLrjy YdHWfLdByUbnj0YSF5ePR/BngREhwSxC/tKBGAGj0oAQZmZQrkCJXF+1TKkK xF2/cM/UjWifMRIRsaPZD819f+MYX+IhhXIaPouQlD4SFFUc8RzyeXIeW/7f o58+2cFPj0D8z+OQctIvO9gkXhmdqG3iJXoO6Tgqd1Ojw/AmYQ8+JeTU5mrN DBqO7KXxyERlD9IGvEpJOE/6JjFvL2x0YgMQRFmKtehGfPFLsO8AGQHqn/WL xm6FN4LybOR839hGuztaauVz8aYN1xbVXpBSrK4ztUzHtHCIdn1fHgC3jIVG gX/x/ETVbI0yq4G8HZux5K2RUDichG42Oe9cTc99yVH4GhmwZ+jX9foi5OyZ Cp9jOjzxFCQSfRkTf4sK8hSdMIHL6ncm0i9dWJfonUrxPChZ21M7JT/UqSRw pthUup+R0Evzv/0N2OfTuI0yVH9lhZVgLqiT9ceRcnCBrth1kVluNkg5z4kM 5g2m7DmsVHyDqbVdpeRWKmDksOkFe73/158PVSlRf/E4703eEqLqDdGAV4IM BbCN/KX0ZoVN3EvO+q97dn2qw/Vn3gkMLkANTkT6S0QYW04zJY/6ouKavsXt zYfXLHZE6NDB/MRMRC7nHoC1hSaDU8RrdGS2upah7+Xpk0WC8c14+2QZ/oYK VbaCsc8gWun5M+fiUus+TcZNjlEzshSuoQiVDcMEfZ2u2IoQo8/K+fhsmJx2 huw1veJWZwWBrHgagpU9wiFVG76ZNqzbMJIbJezZseDGC4VUZmy6CWg82vqr AdCAKJlCGnUk8YeueS+zYS5cmqvXLOwJa3Spao1YjSan3512BsPUGW/MdCaD 7ueru8EdIxUdTDoSnViFCAyffvEmv2+PLLmoYxZMuJdHU+tivm/6QuyQ2HTW SX6xYPFMdiSvFLl8i54emuPWY6ZigQLrYH03ULd0iTpzyUXWs4iKp8VkOxvF Z2SEMcVGqUfP20LnZXHzPuzAcdb02erW/fPN+nj1HRKI1OEL3aRjrdmgH7Ri CWdHwx30g5+kudnEkAuQr5g3N9cJgp6FF3Fj7nVoyGnJpSiH07sU5Ycf9tBP YCsucWosa91WSEOwSCiIUpBzxAWgTopeH/a+lu8IKbVKaTcjso33cr9n9QvS AafWsr+07sjcibBqlt/unJ1NEME4VNLUEsYVYOq+G8qB33z/BVshj7kuXBwE 2WGQWOZtgJbAK8/1O5fDk9bGwyxk8dg3lrhVHpnrUDF2eL6Caymo0mb4Q4PZ RqTLGWa2UqcbJbv+ZLVwTtFiqCgQRTlddq29XuR6yO4W23JDQopG7lTcCycp 6uesyQNtruFiZEi9vXSERUUAfya7A1N8zqkRI/FQbS3f2+FqyGpcCICHRoqb yQBIG1xU4XwMW+f8eXqDyfQKWxMVb1i3yUr3gFs/ORxqRMaIG6UFB4bU0A6z qRqVH2Oc35DUtsUnwh5TK61wTSakYMkId8hjbXOKD+6Fqm7GStx0TkWZiiek AnIddfRo/+zoiFLOsvf0XFWq9kEnXWoUKFM9LWqUq0b1CyNmFUnhcuFjN28K Hhl0cwVDvcbY40fLC37asyvexRAux0wG+vQy6nNSSn2uPTOMrPh1NNP6I7bW spBGgqGyYvjWIM1xqixuGtD0MgkBEd6KtROlxjAwHrPeptb9FmlUZzyeYIFA jtIp8dHxBuTF3++VfWPPCkrcijIpIZ3JElda9Yisb4H2d2WN/R3b+IrqM2lD HwDTNvu79DMvPapJwD69suW8lJ8IpVW2fPyuDb4Vhzmvf1TbdnokMhs2aRlL v3iucTCOvRA0H7/d8DFd0pmnilzuBl4qujx8sFSN6D5OELBB1ZPSYDUhuAlc rzRgfhdCUnNmz7XSggEJhxM+Z/oajNDuprjlFO2Pc3CU7Yk+935AV0a8YoJ9 MgHNFjGU28FJjD4iBmf5qpJSWCZHBjrzYd74UexXx+JjJ2Y4fB3IrrTr7Xer X+vaFXQVfruSkoqH+8c/lAtozlf6dtXOovfvR/QxYYSSAnP6wHx05bPmGdr7 uGHjVxed9tv3MlazAPOmr6b0j39E2a/E7Fj+kVqjuuSfpviVX60iw2R+xCBa mDElhT6Np5exxD46zwuJYbbeF5F1YJzyVyDPjEnEb/cScvnwCae9cehb8Qph w0NhXEM2elJ5xAsRVE/ECJarn6VP2a/jdNZnPiJ4KBKRyUgHT/Zync/ZHZ+z ueo7y3CdatSBG4SfAdbzlj1xdj+Jq6R7xGjiBqPucNYj/2W0HAJ1mF6xkxgp 2sS3zOrUcrv1wzC5PgkmCmqwB4Ikp28gOpDhJmkmYzwVb3EASIgEKsW52sK7 Zk6+Ov6Y+CO5cqL9EyCFP384AeJHmQnaW1ZXP/LDFtLZgFOSMsNrNZoNXgmT kaYXd+EC7ohxF3q4gKnh3X705t0LNkFZTxZaMVol5y1AwCiLLjZAa7E4TCmy GyS6EDcr7kAqYxGlGJJejyZPzku8F+RVxd6r6CoYUWU9CtoAeMjKmnTiLD2w Gz6r16TmHs6QYjwYsERj+w5v6TSZCNthNQW8ngRE1Ks8XRFTEiRWMfU4G9My 92cTouyD0RfhWgzayt7OCRjJesrVNVYrj9gbbLVaDB7aTbbaGCj0duutLvAG 1nO2Kanz3X+Pw4pShV5n7F1s2r3i0C5MecwJsZTZyPdGc/muMvFhrPZJnP6d gljyE0bkDSknnc1e7od58fa2toC1HBeNAun6JI50EtopRiqhN2ePXLrlKKMX IG3sxZiFez41tOyht5mmSTrdpTZpogM37hQKiH4aDO6Ha3K5pybLsxzNkSdG UU9eFoK8ruSiJfqKmO+5bPoXKAGk9+3OlC7GOy7sJLg818ZJ6hPai/SMSW0u kaXg1dZmYydaf9DaaWw9wIhNMYuJCgwG1UGVF1bVJI8X0ozGXGvE+oFG0Yuj 98Arn7z90+Gb9p+PTn7h1FrR04gZ7KNj8vE0WI2afsRIU6tJOataSyJIZcOU NLBsJyKFKrEkrEEl1QM7phqVs5gNqSHFPA368sUZaWAnYezFNCwPtaeCDlwc 4Xg2gS78eqhSBfBuBqKEc+9lHiK44gg0wxDa/DyrLy6mDdo6jJDyUkYLg8wl Z/KKxiz3dqOlCABg1fulhnxeK4w9MqFHjeiHH9qwdZSLDSORvBgiQsXe6RnX mSHrIEudWOZaoTlmXPbdBozNHnE/nKjKFbD6GtD15CpnxpFl4Iv6N5NxcVSN CMFFAG/vujiKqmC9f1wbJdAVre3aj34oVaUJGAjhYAFYJiwrP8DzTiRJtHOC 4JvAJ28Mf5dAeAZdIRjefJgXEP/QC4hvrjWlLHPca07RbIZPkHD8ntHyD8Io 980nVUPjc5pKmHx0yzB5CpLfwfWB/z66aYT88jeMkmemP1o6hZPWH5xtnC/p pzZyDQmOechpdDCcTf8PK0eYmgzOqVuZgs8lXYNB/Qsyy0Vf+V/3HKgsv5A/ JCfAFsx0fQtWmCZ8dXUaI9vslb/uqxTslAcKL8TVvskRJ0lvvgI1X215KaCd wGjyHvetRJd9lxd7pjpRDSSJZUsKbOedQZJ3N7q/zykU4FXOof20MDXFg++c muIhn48bJaJ46M5Wa/M7pJxoPSFq8+Tmp+m2Z6lW8fy4pu7FkpSbd6aflPha OEpSf76J/hooTbJ6RUzVLkSB2sxO2erGK7KN2WfWW9sPG49xTTgDohypXO5Q CuN86XBQVGdsEkwWMRcEktlS4DQa4UlrhCdJamdVBMesTW7QY9BRPa+nSOZC nhfRamfciGCmfMK/ZMZAi0DJ/HHttndaDUDL9e2d7cYTXLyUfRCJ98U/tHvk GM6mpVnMHT81Jos0/jvn7vFKf0erK/UVj36JnCkuAsbbESE3JFyXAHsBdPne rXltsA+Kq+qcpigm7/IJX1lbWQN4+c9xaECNOgDkDGZEZpKvA/HAwgxvkvkv OogIATuTHklplHAP4E0nne70TqQE82Siw/VQBylx2njm2SqFfnUpRXvheU1S kcwj8cr/zxmiZXRKr42vn/uOTffQ8WCoothQCIQDyvv66Anv6+NN3lfjg8vb FmxqI6MhpG12m7gqmzjFsliyhma7g62utMfGPOJ/6fkJZz63e/vGd61FL9zd CIbo9jRaaaxoxAx/1lfYlvcdgZnaV3Zh74gL8FgdqJzD9I1TaW0hPV/nf+BB 1jXZO3sehVuylS5RpyQRB/EVZkVuMKJQYtOIQ2OYPZ+hfvoz5givuzPb6X3p oJ5u1dXvKNvJpSX8/0wMddlhtU1MxvRrudQePqJbDf95xFSIFpOlKI7l04uB QXwpkDmy1vMyG5ruKZd0UTJWPYgTAwsoFLAAJ/zMlFsXN6txGs96SXOAHPyg P4CL566I/dwxp1tWVZ3tWpp8dDinR63txg4cwUct4H9b5gzOn0aNfK10Vgf2 VhTdQ42SFzPW/uMfkekarRwvT/7KKgmGoqrUDNL2GZ1d/OTnwxdv3x+2j56r ei44EqyHPb266Ew+xxMm/ZIZuLg9vy1sjKPALeZB66EePecxUhUfhXdRjVPo y6uvndRm77ebtyt5SSrdwrQO6zWVQtTPGzqYxMazPZNVd1XUzLrUjJ9YO7cZ 6mpPEZk6X4BAc+IpA4A14WfafZySY1O6EVSg1SX9bV/VfqIYsMhks0suKOov 7JZculAnjqDCJBGu/elsMCRKYZfTYP20cyb6oloY+THBfDhULb0sJ0TIqxj0 CE6dKUluKlMNx3U7PFGSq7Q0xCOq+fJGy1Q7EaemJ2VPNxkmJgWv7RIvYlLg UdIvzvUxmZFXO06a8z2jezWmRCGQ/mD1ipShJOPk7q4YmSXJFE4ug5WNsA+7 UKqycsFSqOoEak2mIFSYNaEJIVc9OhvGVdeEGnnr8j3WJHdJqnG57vuKi3fN XLBdug8o001nI3Z2IbdMRx4lKVoviSkjBRzYMRlc0Ss5jDRylk72MkU/QfRS 0NT4BjR4/8XJ4fubk2DXvCIFbtoiXAQmr5JZOJOVbyt1XYTkm1eRJHDAhHFo 6Jrs5sI12PONaq34oCK/IwfXrK+Zfd3/MMsZ4WZdICt9akOiKRcBZWR11ztX B6+VdUTa5BsDD2aUw2gJcacVYKEKMY5+W9HK+9Rx3dcr2XfEifnOk6tpA3FI 3Ffuu3PVkG6ptHrqw7p2hdyahkKVIgreGrOLuH3aGeIUezC+byuNiAcJi6in Dj/LJwwfBNOkJ7eanEG8ayEb67XiOVEd9LIJ8fEnyHTSLHuI/+JrU9uZilnn jlbk8EcPdhqtFjCLjx42traqM4t3Ius2dfjmw+vdXF4+l/tq5nBfze/MfTV1 zrpwAOu1sHs/17di2/bPyAp6Wca9Bfeh43hCK/S/jrv5Z7IP/w7X8vWdsqsl quWfLTlauUKlK8sDh6ju5Ut+3fkck7PPYPRdNdQKboly2vsqq5d+vP0I5Vv8 h+Tb5/snh8cn+6/ftbvR7lPM3XYeY5pPkPrurdqXdTrggz6Sw8a91Uvg3Luo fbq3+v7w16Nj8tmDT8wPgAXA7qyb37h+8JvxIvgq6NLBuxOxEY4UqztPWqRZ 3XmyxeN+/fb45NVfD14d7r9B8+MxmRjSUZO8jTfO+YdRKdOvOxE/7EynE/MB /j3tnG50+WcyRmcX8wtLQafmBx1TOOwI+zcANb2Q9+f4J72d2HeYgJs4O3hw MRg1CQLKaRZczg9s20SBbDIdwo+zaXON/kFDg/sLddLQDn806ZhskOIYrbQ3 bHrmKnXT6L8CFt1bhVMVf53Wo+54rH50W96PtWZvdnFx5Z7dWz38y8n7/fa7 /ePjw+M6wXPP3p8cq0/ev335fv81PIH+mt1JkqYODrc7fnd4AO9BdBgC3dxy r4fTpHk5wXSpE92GbF5bOw/o/oI/HjKqIHzj+J/s2hiALvRw8Baw52X7FxzW 8V+PTw5f499dRHZ0JfgST9Jd+9cGPm8O+siIOxy+g54MeBIRtvmza/861zjt HSn4gSn5fj18T88Pf333C/yE65BvvrlQq0DiUtA1nOjrd3BM6IP9V6/a5veL V/svj+3Dd+/kN6x/rflcgD614NtpPWo+tx0/VYPAV9zKzPapmzi/JG3w402y UW8/evKY1cHY8csTOsPtX4QegMAE/9indfXj1f4b3B0esPoig+Ly4zzajdIm 6zj2oj9iOT90b/3hB5MtjMMTWPcmhREpDVDzi3KUQW86+NH8Odqgp6ed7ufZ OP20cWfd5kOnpQMyhP4DwRkzQ+BHbhz66W5kKDes4h93YYZUy8iUDcFko2l7 mnAaTrse9cb0Ytw8G2xwrV1ZYlLh0r+tbVJiFvRjRhDvsjbGWjbvrdLvtjvX 0AAV+1hf4OPyp4bbkTrvezhlYN1g/z+8wXzx9bnQJWFoBsj6D9ELDChriKGK qzsZ02nKIamuDgzGjS3Qq791ytXF/1/zWI2weZQhoM1LTUNxzMcxXAg9LgId lqrBgVs1r52PiUGTnPDsHPmDR5spI/pE6lwh5N3fZ7YTbzZIPITKCK4g2pgJ 9GyBc3vVTi+IOp28br/jk3tCNPViNpwOhoNTuuYYTbdI0779eBsINpUs4Bks byRwZqMfol48xpzdo+6A6yF9GYh1N/46Hg66g2k08Whb+8Xb9+2fPxy9eg7b hNSd/s6SOnnsEbtaM4nu/TG695MQBx6KpcG8+BfjwdCF2+Z3jHnKqDAWgUnR 6bUzjA6iiw5ccb47LZnWyMXb9nNnPegYFiKP+ufu3aIXzfp3Wbv1G10U62UX Bb40w3zqRsxA3/3pJXQg7dwP1/LnDy8/vH+FY6E/qJXZXHTtin5hP34PvUzG Jyy2i2GDbPew51TEuS76myMITj/N2QlOJ53JFWrhZ3iON+A976F4KSAyy5+0 rvksh3FpkKPx5AEdjSetFjsSuLPNPB4Cdb/y4N4J6AH5jJlm9kFXe0oUDS4D it1ePGDiCVMEroYMnQdzPYDJbsMeTJO3shjmepS/iMGAPbBlu6B64hHj6iK7 R2z6KJnCBuNP05Eo/eEymNLgAEt/Odn/2V+zix5gGnGe7kfJGIDGx+zXfF4T SvlkZ5Mu9CcPHjM63FsFUIiqu8tPbT/LAcmv79rzevhejaczmyYXnWknvCF2 I/741dHPx9H606g5vCAPHUF2ezIQ61FXLb795PGDR+f1c7qV4snGnWb5XbSb j5v5WBZiyq2AZQlnARoGZFgt33mSfE6zg3BL/f7t++M6r9xLc036bl9IbCyq SQGrJw/xxO/stEz9KkorjHmxR7sUNLGhniDs5/EwNkX+3H3sOT91kR+fXETN vpEF9QP4tU6/vOveAgYoJMKmmGGQfNRS13qtad6RUPT/AZOBUYdexQIA --Multipart=_Tue__21_Sep_2010_21_41_40_+0200_BlL1qEfED_1=j2nD--