From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 10824 invoked by alias); 20 Nov 2006 22:25:10 -0000 Received: (qmail 10788 invoked by uid 22791); 20 Nov 2006 22:25:05 -0000 X-Spam-Check-By: sourceware.org Received: from viper.snap.net.nz (HELO viper.snap.net.nz) (202.37.101.8) by sourceware.org (qpsmtpd/0.31) with ESMTP; Mon, 20 Nov 2006 22:24:54 +0000 Received: from kahikatea.snap.net.nz (p202-124-120-64.snap.net.nz [202.124.120.64]) by viper.snap.net.nz (Postfix) with ESMTP id 2E8C93DA1C9; Tue, 21 Nov 2006 11:25:20 +1300 (NZDT) Received: by kahikatea.snap.net.nz (Postfix, from userid 500) id B0835BE448; Tue, 21 Nov 2006 11:20:43 +1300 (NZDT) From: Nick Roberts MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="2G3QkHmYoN" Content-Transfer-Encoding: 7bit Message-ID: <17762.10809.890673.680525@kahikatea.snap.net.nz> Date: Mon, 20 Nov 2006 22:25:00 -0000 To: Daniel Jacobowitz Cc: gdb-patches@sources.redhat.com Subject: Re: [PATCH] PR mi/2077 "set edit off" breaks MI In-Reply-To: <20061120042044.GA29293@nevyn.them.org> References: <17719.15772.325330.48627@kahikatea.snap.net.nz> <20061117213449.GC13961@nevyn.them.org> <17761.5066.494599.865067@kahikatea.snap.net.nz> <20061120042044.GA29293@nevyn.them.org> X-Mailer: VM 7.19 under Emacs 22.0.91.1 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2006-11/txt/msg00225.txt.bz2 --2G3QkHmYoN Content-Type: text/plain; charset=us-ascii Content-Description: message body and .signature Content-Transfer-Encoding: 7bit Content-length: 10029 > We've branched; you have a patch ready; let's get it going! I'd be > glad to see this merged. I'm afraid I really haven't looked at what > you have so far; could you post a current patch that I can experiment > with? I'm attaching it below. To run testsuite with asynchronous event loop put the line: set GDBFLAGS "--async" at the bottom of site.exp. I've taken nearly all the MI changes out but running MI is still one good way of checking asynchronous behaviour: synchronous: n &"n\n" ~"70\t int n1 = 7, n2 = 8, n3 = 9;\n" ^done (gdb) asynchronous: n &"n\n" ^running ^done (gdb) *stopped,reason="end-stepping-range",thread-id="0",frame={addr="0x080485bb",func="main",args=[],file="myprog.c",fullname="/home/nickrob/myprog.c",line="70"} (gdb) I've created a new testfile (below) for this kind of thing. > I'll try to look at it during this week. Thanks. It's probably still a bit rough but if you can tell me what to do I'll clean it up/make it more general. > > I'll ask RMS, I've always been told that the committer's name should not be > > the one to go in the changelog. > > True, but you've updated the patch and in general done more work on it; That's true. I've tried to put my changes at the top of the changelog and pure Apple at the bottom prefixed with "copied verbatim" i.e idiot fashion where I probably don't really know what is going on. -- Nick http://www.inet.net.nz/~nickrob 2006-11-21 Nick Roberts * defs.h (async_signal_hook): Declare. (event_loop_p): New extern. (deprecated_command_loop_hook): Make argument type void*. * main.c (captured_main, print_gdb_help): Add and describe --async option conditional on macro ASYNC. (event_loop_p): New global variable. * event-loop.c (async_signal_hook): New function pointer. (gdb_wait_for_event): Use it. * linux-nat.c: Include inf-loop.h. Include poll.h conditionally. (gdb_post_startup): New extern. (gdb_status, gdb_file_event): New variables. (async_mask, old_mask, async_action, old_action): New variables. (linux_nat_attach, linux_nat_detach): Condition on target_can_async_p. (linux_nat_resume): Add async file handler if necessary. (linux_nat_fetch_event): New function. (linux_nat_wait): Use it when asynchronous. (async_sigchld_handler, linux_nat_signal_hook): New functions. (_initialize_linux_nat): Set up signal handling and pipe for asynchronous behaviour. * infrun.c: Include event-top.h. (sync_execution): Set sync_execution to 1 initially. (proceed): Set target_executing to 0 if synchronous. (handle_inferior_event): Print process switching for MI(?). Don't call context_switch (ecs) or flush_cached_frames (). Use local variable was_sync_execution. * inf-ptrace.c: Include inf-loop.h, event-loop.h and event-top.h. (standard_is_async_p, standard_can_async_p) (initialize_sigint_signal_handler): New externs. (async_client_context, async_terminal_ours_p): New variables. (async_file_handler, inf_ptrace_async): New functions. (inf_ptrace_him): Use gdb_post_startup as a flag. (inf_ptrace_mourn_inferior): Don't call waitpid if asynchronous. (inf_ptrace_attach): Set gdb_post_startup. Call wait_for_inferior if asynchronous. (async_terminal_inferior): New function. (inf_ptrace_target): Add methods if asynchronous. * exec.c (standard_async, standard_is_async_p, standard_can_async_p): New functions. (init_exec_ops): Initialise above methods if GDB is invoked with --async. * infcmd.c (jump_command): Call async_disable_stdin if necessary before decode_line_spec_1. (attach_command): Make attach work asynchronously. (copied verbatim) * event-top.h (cli_command_loop): Make argument type void*. (copied verbatim) * event-top.c (cli_command_loop): Make argument void*. (display_gdb_prompt, async_enable_stdin) (async_disable_stdin, handle_sigint, async_request_quit) (gdb_setup_readline, _initialize_event_loop): Changes for asynchronous operation. (copied verbatim) * interps.c (interp_set): Make type struct interp *. Don't do_all_continuations or call clear_interpreter_hooks. (current_interp_command_loop): Call command_loop with NULL argument. (interp_set_quiet): Don't make static. (copied verbatim) * interps.h (interp_set, interp_set_quiet): New externs. (copied verbatim) * inf-loop.c (inferior_event_handler, complete_execution): Changes for asynchronous operation. (copied verbatim) * cli/cli-interp.c (cli_interpreter_resume): Set sync_execution. (safe_execute_command): Don't make it static. (_initialize_cli_interp): Add cli_command_loop to interp_procs structure. (copied verbatim) * wrapper.h (safe_execute_command): Declare here. (copied verbatim) * remote.c (cleanup_sigint_signal_handler) (initialize_sigint_signal_handler): Don't make static. (copied verbatim) * top.c (deprecated_command_loop_hook): Make argument type void*. (copied verbatim) * mi/mi-interp.c (mi1_command_loop, mi2_command_loop) (mi3_command_loop): Make argument type void*. * config/i386/nm-linux.h: Add ASYNC macro definition. * Makefile.in (inf-ptrace.o, infrun.o, linux-nat.o) (cli-interp.o): Add new header dependencies. ChangeLog | 102 +++++++++++++++++++++++++++ Makefile.in | 9 !! cli/cli-interp.c | 11 -! config/i386/nm-linux.h | 3 defs.h | 6 + event-loop.c | 15 ++++ event-top.c | 93 ++++++++++++++!!!!!!!!!!! event-top.h | 2 exec.c | 26 ++++++- inf-loop.c | 46 ++++++!!!!!! inf-ptrace.c | 101 ++++++++++++++++++++++++++! infcmd.c | 25 ++--!! infrun.c | 34 ++++---! interps.c | 40 +++!!!!!!! interps.h | 3 linux-nat.c | 181 +++++++++++++++++++++++++++++!!!!!!!!!!!!!!!!!!! main.c | 15 ++++ mi/mi-interp.c | 12 !!! remote.c | 8 !! top.c | 2 wrapper.h | 2 21 files changed, 490 insertions(+), 25 deletions(-), 221 modifications(!) # Copyright 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # Test asynchronous Machine Interface (MI) operations # load_lib mi-support.exp set saved_gdbflags $GDBFLAGS set GDBFLAGS "-nw --async" set MIFLAGS "-i=mi" #set verbose 3 gdb_exit if [mi_gdb_start] { continue } set testfile "basics" set srcfile ${testfile}.c set binfile ${objdir}/${subdir}/${testfile} if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DFAKEARGV}] != "" } { untested mi-async.exp return -1 } mi_delete_breakpoints mi_gdb_reinitialize_dir $srcdir/$subdir mi_gdb_load ${binfile} # mi_gdb_test cannot be used for asynchronous commands because there are # two prompts involved and this can lead to a race condition. proc linux_async_tests {} { global mi_gdb_prompt global hex set line_main_head [gdb_get_line_number "main ("] set line_main_body [expr $line_main_head + 2] set line_main_next [expr $line_main_head + 3] send_gdb "start\n" gdb_expect { -re ".*\\^running\r\n\\^done\r\n$mi_gdb_prompt" { gdb_expect { -re "\\*stopped,thread-id=\"0\",frame=\{addr=\"$hex\",func=\"main\",args=\\\[\\\],file=\".*basics.c\",line=\"$line_main_body\"\}\r\n$mi_gdb_prompt$" { pass "Asynchronous response after start command" } -re ".*$mi_gdb_prompt$" { fail "Asynchronous response after start command (2)" } timeout { fail "Asynchronous response after start command (timeout 2)" } } } -re ".*$mi_gdb_prompt$" { fail "Asynchronous response after start command (1)" } timeout {fail "Asynchronous response after start command (timeout 1)"} } send_gdb "next\n" gdb_expect { -re "\\^running\r\n\\^done\r\n$mi_gdb_prompt" { gdb_expect { -re "\\*stopped,reason=\"end-stepping-range\",thread-id=\"0\",frame=\{addr=\"$hex\",func=\"main\",args=\\\[\\\],file=\".*basics.c\",line=\"$line_main_next\"\}\r\n$mi_gdb_prompt$" { pass "Asynchronous response after next command" } -re ".*$mi_gdb_prompt$" { fail "Asynchronous response after next command (2)" } timeout { fail "Asynchronous response after next command (timeout 2)" } } } -re ".*$mi_gdb_prompt$" { fail "Asynchronous response after next command (1)" } timeout {fail "Asynchronous response after next command (timeout 1)"} } send_gdb "start\n" gdb_expect { -re ".*\\^running\r\n\\^done\r\n$mi_gdb_prompt" { gdb_expect { -re "\\*stopped,thread-id=\"0\",frame=\{addr=\"$hex\",func=\"main\",args=\\\[\\\],file=\".*basics.c\",line=\"$line_main_body\"\}\r\n$mi_gdb_prompt$" { pass "Asynchronous response after (re) start" } -re ".*$mi_gdb_prompt$" { fail "Asynchronous response after (re) start (2)" } timeout { fail "Asynchronous response after (re) start (timeout 2)" } } } -re ".*$mi_gdb_prompt$" { fail "Asynchronous response after (re) start (1)" } timeout {fail "Asynchronous response after (re) start (timeout 1)"} } } #if [istarget "i386-*-linux-gnu"] then { linux_async_tests #} mi_gdb_exit set GDBFLAGS $saved_gdbflags return 0 --2G3QkHmYoN Content-Type: application/octet-stream Content-Description: async without threads, handle SIGCHLD in gdb_wait_for_event. Content-Disposition: attachment; filename="async5.diff.gz" Content-Transfer-Encoding: base64 Content-length: 19419 H4sICDomYkUAA2FzeW5jNS5kaWZmAOw8a3PbRpKf5bofMXJSWUmGZIKkHpRO m9IpcqKsIvssZbNVlxwKJIYkIhDgYgDRTMr//foxMxiAoCxfbJcvt6xEJoCZ np5+d0+Dl2kk3xyLSTR8/kN4J8dxIvfi9MnpH/88eX1+IxDesXg+ulfPVT6i /xtLefdPclnksbyP04nI4R8VZ6nw9476R0+ieDwWuyOxOxe7Od0SLpY7OztN zDf8vrjO7kW30zkQXf94v3e8PxC7HfhsMMzd3d2VSd2OM6l73Nk/7h7yJFzD /Yg4HSfZYi87Nt9G4sutSI5VMN2Gb+M8nEn8Ssh1/aOuB3+OBM59IsTGl1s8 jUcDHoGSiRwVcA2P4dnuvMjDkdQLmKv6IqNsNgvTiC9glMzjLLdXGvrPvBws McpyyU9zORmFo6msVg+VknnB4zf1+EABP9JJNYiRqK4XYVzY5YLRNE4ii38N /Xdjb+lVw/RnSypna3XkizCfyKJ9I2bjDqJt24riXKZFyzZJRgzvQHrg8yfn nYGA95Ism/MIeY/0aV4XdPkn4naLiudlqjeF3+o7ssC1ig98EJPBoaPiNb7h xUzvf5TEgRrl8bxo3VYxzWUYObsK0zQrwkJDUssZGiw91TClzjKXbBrIfZiU elI2BLLdS03iJEwnZTgx0LMkHj4gXLM4QF5mKY+ZhXFqxQD3oelFX9fYxCaP q+23CXxNcpjoocM/w+2fG6qplXeAyjs4cpT3/xFXWnX1s2JSU+eSOC3f7KZh gRhWF3UcYTrrXLd35HW7/X5d5xoGoKIVEBUhBmn4AFddiagbH7hS0jGarkkN yzf3DhCZjIPh2JDDndiUvmr9Ot00XxnhcZbfMf+YJDxpNxpWVKpurVqpVis5 z7NRgAIXu25BoxNpWbN7kG9Gcl5ARKbqYFz06/JS04ds+CteqFVRIi3t9gbI x/26lv5p+Vi3C39GrjbVGkzrblTO5rgzAJKPwAtvP4e7z+0T2iCr9aDT8eDP gaPW5+fbmAB8uXV5fXvx+vrsKjh/cXX27c32WnAwDy/itJD5mnX1s6ZxwZv6 YpGH8zlbZCMRjj2FAWUcZGVR+Q97YUfUYxAtDjXCv/8ODeJ6j0k2mQD89k2a hysCZLWj2oMjSBZl1tBBx0eWHDoa+mdmSV3uP3MGXVa5O87fm37stJ1XWZux Q7jVzNgxAtO4mWSdLze6vriRc065fUjSO8f7vs3TEZLJ0834lRS911mToss3 wIRUAKHKUSFMhAKGVYodsm/6FqF02Dn0Dv0umxxck2/0jcDDfxrefRZHYpxL GbggldhqXWhn+wRnP+NpWzuhWqZgoeNJGibBNMvutgXKN4x6hms83xG3GYBI C7D/UhRTCcvKUYmCaSArsZjKVEBGkiLlgTiCoE7zLM1KlSz3EBJ8zgygkKYz fmUu6TZEiEqEYp6RrIoig4txmY5oKFwNYViYJDLSwODWOE5jNSWkNCqeyNIR o8nmX0xDBQtloKLRnrgpR1Mxk6NpCBNnIlbreAQjcrHDWgNCBeo9PyG2+L7f 8XwfpET7Ak1k7WwwQkBPW6qT6hnqTRKrIoCsfAam4WSVfVs7kYSFRhC9R+Az ZRBGUQC+bZhZpgCNVKERIx6un5/BWqsAcGDLRK4VwDSOtBOwXkmAFJrAvZpA 2JlwWV8RDAIHD3a4QInKHsYTuFfgVLNB2hrQ8b4D8zbXz7MC7Sy5ZnPOLDWF CD/JQqRvBqGTUg2iKkmy5qFJww9JmShT3AlIXZKBbOsxENGkhSceNTL+TcJI 1GCQnS7Kjg0r/7ey88xlhFMMmWul/ZdkfWDJ2hFRWISfs3w5PpcEYhe3AP7+ I3ted621/rc7aLrf7kDUsDQ+2L254XfECzmsPKt/3O9ZTwwwjSOuTWpxx901 7hh1LR5pReNAvwNpn9+vfC7fODD6KsRb1Mx4AjIcJeAUUDMf507Fqbj+8eqq 8qpn4PbCdCmyMXkrDVEJDASWXwtxPpWjO3gUK3Ef5nE4TKQoFVCWvd8IHwe8 Gk3ZE7c4Fv4rFcjIcCkw9QIpDIg+HvrLCD3ZDMIAhgFeG5bORZaLNCtwQJze Z3fsPvlrUN8PI7lCSZsbQz7Jy2mbwJHM/pF3eHDkRDIHHe/w0KFqPBZbgDWY lyTZZtzE7/DvF/EYoizx3dnfL4JXL6+ugHj8wQmu3RNffSVWKQ/DN9o54pvw hj9pOQPUyzQSp6hyiIagmBbIEo9jme/hrWAcKVJenrRV08dtURtPEGvDa4+L eCYxgr4PE5Car8XqWnqEOBa7vonYPszeO/W9gyh+k6V/KUBc0LiCSILMgf7C MgspMIJCNEBKiSpDMHbAKbwOLQhBOgFL7Imd5/Yu4ukQ9hQ2gqjKPE8zsXkq LiBteb1acHuHLB1CEHzkRsVH+97hoF/J0gqtSTuCWaju1H91fgE9rD1lPTJP T94Nwn8QhP8YEN0HQXR/If58fFEX1UlRQ9pd6TXe56sHiPrIgT4MfE92H/WB 3QOH3YMD76hj2W0XXa9d7qivG8jpY7JK19BEfwxt44+rc+eJhJgADS3RRoRj THrCFPUD7PE4z2aC0XuXUlE14PfVAKD4dP6/eND99w+a7r9/IFwc696/YD/u i+/LRKfh/eP+wfF+5fwBYt35F+t8//4a359DIArJ5DAEtePUG0K0QJdyWBtG SSz5KM0HKfQHHZPxAfcuIb6MQbp+Ax8OVhHZmEp0tmG+tO5aeRhi5AUnzSTa KEMeMzOXEwgeYDFcHlNzD7gfwYwoTt2JFNewCKBeQPSKNSQ3UDUKwz5TUAyd yHRSTNkW6egXw9LZHMIVSkX0lrQefZ5bEjsYdSNyZUpBzc7zx++yyfEoVvMk XAa6KA1jTF6QyoW+w0anC+FJ92DfiQLpho1XqvV5VsBogEHtuKg4C52iH7Wr aougw0/KaJBCJroCeZxl9zIy8J5oi/FaKllovqgCdQySD1iWKEMFGDo22LVF GQgFYcaeMPYjRwCWzAgkYAiI0R8g19GB1x34DrmODuFGwyXDZyiLhUQ0p1zJ URhx4kU4hP2KYpHZeo/acyeew2CyKY7S1om1te2JKJOKwP2aDbV0WcsbgSUt ZMAnBTwTw/I5OIlx5FjodYzwK6++Hgmiox0mizJPzfXbP0DfHuQgPTcp6fld r9fznUIg+wV2P4a/MopRSIJ5FVCbXZL7CeMZl8koIwgxtAMXLDHoI0ERMYrO ZYFi9M8yhlwkpkwFXV01CR6GCfl4CBNzxQoPA8HFeggqBIiTDJkHvE4yxdNJ WuFpAaaFsg7QBW1zDG1NQiQyTFEWsZKAzU88fQRukkp7EvGNi2l9I6AcFKli WK5XNnibGjqiGBfABBAZAFam8s2cShUgKWEx1XYrm8lhBjsDusByineegbGS OGeO6g/eAsub4j9kgYZPhWPMnuCxyvJ8ubdHguhEc7rUY3ANkGjWIhhGtkoh xRi/Ew4CKzDtsuxpEeaQRT/2BEchG+sFvEPP37qR4mMFvWWYYehWJcueYBT1 kO31mtGyAa77UGTkCeObSTn6vb7X37fF2CfaUu7KlBJmgqVjK3JZwFZMXdLV Ijbgxyg5lWsxyyJwYiAvbeFZVWRmeVmQJctBisCjIa91rVyglFDF25gl7feE jiQZ2YCRNZ6vnM2WlbeDXd1IKa5f3l4I3BHNAxtSTdzaNnYexr64/McPF8eg KJCfLp/7g8FgtzPY7R4eky3lqoLWd5Tm3JYVePuBpQ6I9nmZY4NSq+jCovFs zpVJ2qEyYCijQc1pADTLKtDbESWaru7aWHetnuDDOQbilTPdXMHauM63ViS+ YVJRZKJ0dM3k5sODVGWJ3IZYPL8zOBm5CBVZXZAyr3906Fjdz1vS+MnLFK0s WO8lH6yQzSRLKhZhWthzlVyOIdrWVSBQXuBdOWcQvEElvhJa3hTMN7UmUw9Y SLLKeZnq4pG2s7DfpcYRkiyFspulLUdIYgtFhewGnt+AFQzFEJh1x1ibg7FN HcdgKKlqK20DUmdIW3JYuJF5plSMrAl35zgixq3dpdmC3A+DArTHMcwCk13U EcdjoyFGK3o1jrGoXMZTW1SwmqQPqrZCgl0qOxcWVNOsTCKAq0WHwcUF7uCS ii6/lqoAyt3BWDwcI+TgdpYmS4hyBNVnFNGRSurgs+ScGOsZWIINNZNoCJno HQxBwSZxIuzQWS+m8WiK9JrhudiQfNgewAAl3MRtVrEpo2pDofe0YM9qjk3D 2tY+z0RK2kuurieMV/qXEXzYCOJZrdHLbFIqDD9Q01nisMY3DTHQhkgsJgtS stAXyzlW9Fh4hKOcqK15xIexdos1XAknWMfMbbPD+Ih29KHMcTNieKcMUqSw D5HCgU3ia+Jb12InnW51LToZmJdqajnw9Kkn+H/Nngfl7wxTR6mYmMAtVEjk WiFH0zTGq6URoVxGZRqFdOxFljEdj2bR3ogDbdMGPIQo2QbiOJ9d1qDj7VfF ssdumXaN6rrZ0NfNmr7qgU197dgnQILv0ZJFVF5mw/WgrICqs+X5/MnbFEEO VLH2RyeY+piSJW+wf+QNDnpVAud3Ol3P7/iH9YoCFw7BSsYTrw6wKknCvn+S nPKjo9YFAcjPCjFOwkllFnP5zxIzfHzkGHoZoxsy2YZ2U5SOxbMZpIzYPUzQ YKxP8YjJ1TDhosRMJ+0UoBtAXNGx1mcBQQ3swQQHy6wE9UWnB7GG6RJBTGke GQG0vRoWPNBNfQrXxyyMPJ7OLYsKFCIKdgx3B7ZE21RczIBCnF10DZ6XEGfA oh4REKEERDwY6rMfxSkpmR8DCmFo7pqkJNSHdbRxpOC4Shm5vvGfP17eOng9 iBatuYR0FmS1TBcxmTph8lKu4mgXWWFMxqjyjhA+rLJRSU7FJ5kIp4AvkVGf DRION5ffXl7fijyeTAujF+EiXHqEnT4IKlWJeiMWRPxIjinOjVUbfYEaFo5S 5Yy62DhbxwkYzmjUKF3OLDb/fV7hD2vF4wf0DD1QU9GODrzBoNtq4l19cOq7 RUAlRnC0lcFvkFfoW9rzkhNjLe53QIuxLN1iX99jPWac0WNeGSPJSQbxWKqr MUb1OniySx4Y4mmtl8agct1Eyy8QeSbDVNOb8hDdTwiRP97NswX1VbGwGRjk anWwY1xuVRkClFaNgNGqm8wBwrxOM1QRxQ1cZIaJHuEkjFOdiphYk12OQ3tw JS0up40bTSHhc62inAemEO2eKfl+z/fgj3Mg7eNbGX63c1SrWdqkABkqCCDu 6ezqCl0a+gpaCXtNbFrG6oGRuoEyQ8EGfMu5yb1uLciiHI+rfID0C7UUdE9A 9J5bRIDVNQMAEnOdoelLVKb1aUzJEwCZIeXwHEsbMUCKHbDJ92gjxhRZApGq X76odRORtual9Nw0j4FRIBmmlc2eQyypIBgEH4rxLoFRYkn1Z3ILxoBQFjPF cxaQTczzrDMy2bGiNDLmTHIPSIwUpgMoU03jKNU2DA1DiKLBJiRVfxRLU5Mk LSmHMLGOC8SUTLmtNcI4+ZQCnYzKbpBlp5TMwAMdj+iRkLO3j4QHLUV2fv2L A7FWUe12fJRLN3boHuKtI6d74hGFunfVv1GRSLZsNwDanHJeyQfkzR4bfMqa qNpptIATZ9sq+RfFZAbDVYKNQvedoa+lAAt1BF2cyUR0WIjcx6iAjMtXKELF lKGEs4yiBQseK7ZLUBG3uEqm95kgXeRDrKASZEPRZzoTxTRJAgrYp4r2T3HD y8oZVKj0+Sxs0R5ZPauk66G+sabEPTx2ZW0UzbftR7ofvZnaWWrtke5KQ9dA uBjurBzoTjcg2v1GjvBwdh8PZ3u195+bzVw85T3Oc+tdefVSszlY2T4xSuVh D6aOEhw7YhRitc2PinJ8RqxjFWp1b3Q/NjoL15zT6vrJFzIFGmqdZoy0Rn9q jPiYtYGXK3uQon2CTgJaZa3EHfSaIgcZlcbMihtdYt+gFRt/cNztWLHZIDhW 1Hh4i5QdtUuZriNATl3ZY7g8cIvCX4CVS8pIiqdvRtl4TK9J7k2fslfSR77a WmGtMwrziHvsNC+2dowtBz7KtJzZkqS2aFSsqb56CJd7RJmX2EoPPN/2GtfW /FXOT9t8rvJpXGKlW/5WzCbPA2Xi6DDg6tRekekJ2McS0Nuj2+uAj8L0Q0K3 TdL3s3AuduBPQN/wfTKxA1EL/rPt1CvrDbvkDRvtyK6lqBkY6u5d5LH2otXb FWVMN8QO/vX45xWOup7z0wrUfGRQNwnECvb4V6PqignK2GAAeYYu4zTxuoH8 MB5zSoAYpOFMmp5Srq1QoY3fTz3s7XuHfUd6D/d97/DAOarHKUE2V0h4yEGC GcQR+bJKhNznWKEO8J1DImQKAamCgTSCHuGdQLcpt82ewB5PxctXN8EPZ99e np+4vtUNQ40PrQ6wXTiuTJ22itpJ6zxH0E/bxL99FqvqaUN3HxjrCK7J1vHz tiqHEpsdc4u/0PBpmrerldb3bq20bgkHP2N4q1srbr5/3Klen+pb2+vMeLz9 bZpCG8k27SQhtt/19q0S6kSKC+ra3nKS1HHOsrGmrl8bco+4IUQfEa8TiLSd F5iUrbzTqIyKmQGd2wXUJFDOYQjki8H51cXZ9Y+vbhygdLpl+3uwFgdx6OX1 i+D1xbfBxd8vrm+PiVq8jVovzUfaxnuh9odYc9D3jrqVfdwQTm2EC72vL25/ fH0NhuHmbwEQcFs3OVI39brtb+LDlb1vvGvjPOSxzGNwK607TP6Nt++m4cU/ Ls6D85c/vLq6uL04tuOxCKR04cT2YCdyXOgkCZNq9xgkVqqkIrCVP0Ep9BwT va+5qmLl8mHBdXrL6GBRH2KvvD5ncWDKmz6zWn+qwcCp6289Rug1Va5vL69/ vGDBByHxfd/t9P1wUgJbrgsK7+GDyopxCZrE+rjiJ1NB0fUeyoNlmpWTKapJ ls9C88IjnlXXoAh8ZSMsdPWEjwDqh9ZcYPouW4AW5qYBqwkDSyLUPxgXIonv am9L6rNzXaSHpD1DIJzvN+GQyDCVNbe52apDxwY6zyegKTV/FQoPGVeQyUoM UJIQhS5L6czyh0wVJojB4ldVeYBUfByOihUo1DlGPWIvnD4CogAW4IBWWLzD pIp+o6BqLVBNUKhcxFmYQwekmSFrvZOLlm3uHo+/Nki6/4/YCVKHZpOIrlHW xX8WLp0WXiNyNJ8b/KioS2VgLhO22QJdSdbiRZMB2ozLp1Su5LdQcAlNMrJG C1BJpU8iUGNAgfTKVCI3HRqMgt2pYwRbOfUuq2X79m0b6TpT6nRW/jFTWokX SRt/qD7Z3IHbD0i9FbXT1G3BTzhq1q8/rBNIPeAtf5GJ7tKsT6aoHM0eVv0C A4qC840N4to4KFOINGHH2Pry1BA12vs5fdpY5fHybzxCM95oY5lbOO15fq9X RX8tFNIL/l7FR4+z69avrqEmP39L/xItN/U6ZuJaSoJEtxAyaJLS6Z3E/6mC BFGiv39Yf6PuA++XZJuqypAkF8USWBDJqrvcoNPIZMxvr32KXMastTab6XWb 6UyvW/tFvFpGY25udPvi+zC1GQrkNL2+zWkAppvUVJNW0pq+/0BZqXvo9ZzX 2vDSHixWNSX9045UT6ru6p/+ad42PzKE95/VgXDuxWWpBiT9Mz4ta+hf+MAn bTvo7Xt956WJ3oE36K7s4N/1i4LTvzaXRqzoV/+a6Dqv97Y+KcyD+mvx6yta J2sGrlannJFUPnKOF7gXoPFi7JppWrUemmNalU5W9mF+u6k0bwaam/QuPnm+ 0hSOQEW/Ozv/27G4odMVdKIkjiKbK11h41eDnV+Z0oU2rce1d6KN18TZO3p4 hj97E47IZP/bSlVT6HfgdKSua48n1SB6xZSG1DrIqAjjn1SHOfZNagPp/Yqi zaBu7adeI9UI1Mu0jEfz6GylHd0c7Tvfq+pm617EVi2n9kQb7dxaah0vh4ef toCMvuXdZVp9gM+MoOM7ZDY3NW8FwYvLq4sg8EQQXF1e47c1LHtqXv6p5XPU lMRfsXsVFpXR0+1aBdFSebN+EldVEduZcmpfQTlZM5LpgQMr8a48u6OvnV/E XysaEKCVFzdqwx+W21VB9MwLq6aoiP/q+K2+13di1npCXJvRWKZxjGBf1n91 G3x7cRu8ev3y/OLmJri5Pbu9qJW1QRbaqkf2V+9i3dYzt8FcZ+D57gtQ/v6B 5x/06t1z1C9oEvqGsar655qG07z6YjqoXqbUw6WlTXk605phH+NQ8jP5Zp7E I0ieTf9+/BulAiawct9zm4fUSYPpDTm3/+nu2rvaOJb83/jkQwzc4wTwyNHo Db7OHmKwzYYYL+D1ZpOcWYEGPNd6XY1kh5P4u2+9urt6HkI4JnFCHBuN+jXV 3dVV1VW/Mq5OSaZiBQbJ+eLqyvl7ICqfhFKJwkQaHdVHiS3TtUhRupr1R+Jo cUvaNlph1FAB1lEXJOde3UmStyVKnwP4oPDbRAIinENNmYO9Ud4WUydMymbX MxXbmpsw+hg4znSO7A5fxe38kvmN/EiQU9Jh+8E4ee8G82qc/uJPEIyFNBDk U+y1xvcrqEkvofAITrOxGqpSSTrdEIjrGaT3J2RtYTdxEyJApo5scXGRJAPs F01DynsC9fBz6183SPrEHSkKrq/c+jhkAOR0lABR/0fNHL38XSG0z5h2yCtn lkwnM/TNQ7/DlCQj2Prk/I22mxmKL/2hrOmHVr/G8P0pTQVMSEzzhp/ssYOP 4TT5kpszpmrqeTG+cduiu+QYGroo0HbrkcHDDhvu9vxvRFit93vC6ZZxjPsT Sb9kEzBxFOxSFpLgh37+MWs7EeKrdrS+E4WNnppEIyhsbpD3WHadzZMRx/ji zGaLKZGUuxLDo50B0ZHFlaGa9culpkcueFzgL49WOWGU7FExZ/lDGY1BcTYh 3/fTs+OX8X+9Ojw4O/rBCRQWGcMjfeEKcdnRu2SeGCsVrc72NttJ/DRP7W43 bGu4lQ6odZ1upHADnqA1OWHazyckXIrSYTWLM/auIpdS0KPRtXGWggIHOwG3 F2+V4QTkLnEWy8xJ4Fy7ckpDnsMa2bSkgD8163mrSN4jUMdS53SUioilVYLL q3SeunR5o2Kp9YByknB0UAU5VJzxXZLiBk1XSasfGcJcTcmo6Bai1dd7QVHp 1WEvS7aJXxi/7NTrYaeujB2d3k7YrSs/inntG+AguMFhaKotfPJIlfjlEqEl gR/B7Psl9TeeU+ty1whu9jZOEVxjdXcILm8cIfJaaGm5CicIU6a4aR9X7ffK qrTAC9XwqVZbmI/7rBtqzXlKxAdp/qjEkElRQX+AEZP6qUayLWLpwCMbtUSL Uze01ugGx7ATjBWy0dxt1B2arcLRcTWKdstWhTvGvxajaWwDeO1prw77+Vyi 73bqrXAn6voG+b5lQIiqVCXp8HQ7eWBPh00767+SCvDmbizRKXwGiUBwrxaY cAvBpsBaZD1A+UG5nZ9fheY+KkGxzP+a2glIUUuuZgjFFOpgbkSEgOOrZvis /54Vr1mTjSxNk6qSjhZ4LxqUv7F0EQQVMX0oH8vKrylHd4k9sUSNx7BLZ1dE WxKN6DJvMJg5QYq90HAK6zvlbmi3WQqddrjTVU5oO+0uPfB8XOQiRN0nyTVS YIWfew8+0Ww+WGU27am50mzm2fJKs+mbm4qzmeNjFLTM3r8IP8o6hQ0P5sew yWAmw+Bs7wRFw9PDZ4gTXjeaQBF9gwXqkqnM/Llknba300YYKV+rZf8GBGmd UXAZirYYru5QpCU4ijz5RxMDSDDG8VpUQQyCuSQ7AUV8+UZMmkCLh8RyNEdP GqQq04yFU+AXMzfNEqeI2pyWvOMXx7GMGL+H/p02ViWtqzqPrD5cFNrzTWAt T+bX+govGUHqYhp3vP3xN6XxzRqvu0ZdeT6CpXOSb6owL+Y+t2R+fBGBYoX/ ABGB+qkG240KIgIi2NrxKRGBHqxFPSciRJ3ddmc3UjC7kScicI2iiGCw+fLs hHprNcJWV3nMw8de8Wpzbi4ky+8Ky68vK28Dq+5B9XOSR/MPTc6jkltO9gHP 5smUxPg4vcSjk8ywvjc480YM3ap3fWSiw7GHjC+oL+cYO8enA05m6flgoIME lKMU7ob7KC513I5j9CwbskbCEU8cu0tYmOw+Do/FVMtoctpaa/xWKGobl1fC cBiUl4URr1L0cBmQTVfiYzHIvecD5twZAaLPiwD5pWOP4yfHJwfx3v7+ScAH M93QCceD9U5Lp9fohL2mQtTrNbrwwEPUc24c5azNfKtfO+ep9PrNNRnU8CTR xSr9+v7D80pa5lJlbFNfFAhRftSY7WNnlM2EUSvqhVHL3E+Yd5oiHx5fwUsP 0RuCkhhROw/ZgkpG0MfBy8N9kHlAYb7Iat+QJfTRCk1w5kFugWq+zx4yp5gl QwbBTwdWmQjMoUUGWDhyEcDBdhj6pkWS8tdQxF8LzOVhzBgwVIkEdvjqcoiW RuJZgp2fiTS/ZkV5e2xNUQsnCFP4bdPZd22B8ymKhlCIf2HeZaRFaSIM1Jjr YlgHwkdI/U65yH/LmewBN2jt+JIi9zqDhkCoFOHicbAuA8UrJUwKEltgDPc6 airz1ltqM+u/ozQA6qvPY85YXxljNDw0wehWcIzj9Z91C0wzUVcQtYm9K7Wf lZiBCqQT72eeuu4OkLtXETR0u6nDxDORl4om6uz08FFOZysExTK1GCEZxlbx nb3QkyxfaHV3e7YIxyzZh9IsHqUxOjCjgLhIMRhbO0WWoScRn4SCGK2+aXwS i6rmj6cOmGkS3M9+BtUzZDcJx/hw0NDanMcOtMvfu2wVMRWrVonjmuUnh0Hx 5807B7mePCIDEM+amKAgxyDJifLbl3gBEL9+Dn89eX7w5Lv49PnR4benu6sV i08OTl99fxA/PTn+Pn5+fPzdLi8v5UYsEw7yT8yyIc0yvWeJH6OEyA8noIxv cPndyt6Nrr+m/Q6V1zZ5dhNJBJbEgBuAdEYXDKTYG/D97M0wPRewCtcI6ymn x9AfnsjBCAFQ4FhG+DW5WexETF1vmd8tddcYWvh9H/heKZiWlPn7kv6WO6Db wWzIGn9YHrnsjTwSNA4KcNJ5guKXQIuNgv5iPsG4C4KGwvtc2v62pkWWvSRZ 8ppCCvpXsHdhaIPFBfnU2dLuLeMZxj/OTegAEzTYG2aTkOMzyaZpM39g64XK dC2NLu/OExstV0XIMwXyRGawKaLTzhBJh81caeZakFCJkwUJrYzGQqCD6Zi/ e6jGXLoS/QeyXFbhuGZdIYifBe8CTbJZi6Jao71LedSDi2SG+cAcBAs37eYS ESq/ykwSnICDXOHV3yZTxK0ANbA2gFdHUMgZMPJ5QnnGsmL+gRsW1043bDTq 2jEXITkaCirmH+RvRQPjnLiwsGy8URh86XvKhbTWYltS31NbV/4SiqN9vHhd R8QohUGsmJGcimBn44yBmGeJQTN900fGAYOcIfy7t/tx4+AA+kPf/kEpEf8I A4h0VH1JUsz21wvc+LatAUSerEUdl/Kv3tqN6tZVe41acwYQU6PEAlJ1ScKV eFWIgMWPTHq50oiFew7NEZhA5sEyKSwU4WWUAPIl44fy7+ReBXyATyPys3J3 zAMRL0kFpigtAhJy4K0pQdtfcIPIzRlW1DwPjB9Nll0uhqG5N4tCgdW+7KfD LLTodJPhwDTgBk6+lrDDQcS/SOg0kFbqFgb1os9xcrAp2QWOW4HmdEvyLrN+ mmE71tXU+Oda/x60+6eC+4pV57CuQV2HpT5Ffx6mhsQ/kTkSHRXNoIkVV82f BfDzv4aBxvL7YzN5sRq5aFky8Z6Z5K818V7SRplxGayZTG6oMKO3nExuJTej q00m/MlNzx3PbQUfWNYX8YEmWjy0sys92FHrw/fA1ovCujrzMe9dP+1rFM6Q MRlpOs4tzDDFFNI1Gp0tfpibBaJOxhfDSZb6oEwifDCWGdWW+FZGfDQGtb6/ iCWgczK7MNBe/4BXq1sRekm8nbXF84/ohKRfGWVQmQjK6QUaJixqtBYsMjQI 0V0an4l43q5ao6Ltj14BHVDdu3oFdFth1Gt4KwAl8/Jd6/jv3BzqZdtNZ8hw 0cnfIT4orGezSQ34rqvHxtpBinDCZnkxhooNO7V3R5eUWopQXwOF3Ea2F26t 9g2OPhkUg9MYvo3LCM0pqSMR3K7zjyVxF/ZUT/nvRL1OGO3k9Dx/iDoLiHf7 LHdxGPH5lsKeRR+6sBmexAm8BCKNfeOK35PUrwDaSShDHWuMqE2TsXMIN+14 Z8ObGcWTo26j4pbd3rL5pzDAGRUaSdiQeMw4QONMxohcVktxhii+ftYpcql8 fn/eq5hNRofz5tNSHnafWyEl5W1bFGWz9fHroAfrYKdlkShWCVMhKIJ4c+Mp bDJWJt35Kk7l1NFPG/eznzaC+9nGllQyg0aIHtDDKSaAoB8p4l52qdtp66yI G3uLEY+8NSiT+RSF++F1GKCWtZjS6sChSFgqLpw3k/fOeZnOzQHeR3Bou+S6 bIRKr/krEIMzat4BPT5yPTXqaHho+Ma4sjhhm2fOjnzdvVUuYEH6HsLmglep BUe0y+St9HZF+8GLve8P+BwYT1BUe2OU1rDRbPjsbfVxWYBaBIHt030RMw2i AIeoWGGwKLA+lGaI2yHF+9ceVjJIAVez/vm5OWykIXYXxIXBaU+lCQRbJcdh lF4vjA1qMnsLCuMsmzMurnBA37FAy2zmANH4suVyXC6MW4q6tj7pZOXXnT+i 0qxvtO66sHV7/t0KJw/Mo+cLVO//LcOj/Mo28cYgbbvijv/fCIG57hN5aVlj BEdK3yTeihUIDollEprXhy81iNRyq8rlMp4FTvTWSBFmcUutElQraVPuNMJm veltyr/YpCl28TedOPuGavIqDod/L1K8FVp+QPR2wsZOW2/Uat5T+0aatP2v 6xhKrb5y5xVds+MelfDTJyITeyd+53wa2w4pgp8Sz3mBVbcb7J2PssT+eOfw uLajavtjvWB/rAdufNs5+2MRGtfDzIPW8vbHMmTcSvujQAmU0jxGoUhy1NO4 2jthp62A2das4YMV7GCbVOvQfst1vcZp2yFgAP6zlUeuvdkc+siB1qZWhlgm eqkuyt9STmN5UcmyCHJnSU3zmlJTPi7pmDH6gGwdhVT2J5MtV2AlElbQfOUt ++dOgmIEw3S8+KU27s/v/ipCdVXJDNoFZtCuB3qMhh2oZ/6FxM5uq7cLSoVh CG3HEHSdPEvo7Nbry5wye2FbwcrDx04RrQVRX9gp4+GbjbU1kG8pl5VEV4m3 BoYPJvMLMSjlEWP685Kq5JDkF//n5cV4jr6etuxxfLJ//OLoB2MYLPf/ZLsG Rj8+3/vvg/jlMYgZbOqAZynCnWzaL+LnW7qlf2JGe/QuRWvFsFDj9IfT0lrZ dfa1ril3d9rgAd2PcUjH8RH63aPejE+5ff00KJ8czGMS6QCJMKq72ZFm4vg1 pqKwP/VfWnX+Iee+PhoC5b6acXVECNRRsTmcGR9S5oG9jMDUN+OrYVLjOQcS wZpL3yXBsxevvj7CRahi7STnGCWIsBcDMBIWIcTP0qD7jRbDeeqaXRWMhhY+ /loC1OyAZriUBAVlMYV9kacfJhghQkeNbhhp3CW2tneUrfWG9t5hgwTkJRlj apE4LBmieuA9qjX8jiIgycAm5P5CSD5L32FE4DClTIDjdEq+scBRbIZkQohE /zAcxlvKNcnFJ2IVx7PdeK1a1AkmbQXNsvQKWT7GUbF1G8P2GDS/043CTrej Ix7bYccleb4nIS7oh0ZDOx9OOE0M5TEkSws2zw2Tvp6fZdM51UxM5yYrBTdN UC9kEzBho7TEBURvYFEa8226KMSQ5EnTtr/CoDijV0h5/sA1+hbG+gv7ui9N xDP7bnAEs0thXUpqXkOwfZZHyc95eYJECFu/6bt3SUXMpsO7aOT0O7sxOPhS uuDGbRjWI2XY2RsM7C0CrjiDYdA3kBdoUzl6/dJc7eESU2aVnO/lt68Oj/Zj LL5JkeiH+0UwgoovxLo3xAs1DA4evp/mi+jMct+r9JjF0acWaVHCz9G1u8bZ MpnZZMaeNOxfo72dHJCMxX06eYtWQQwFC1LfEdwEt6Ada8IwlPRDFijKkE3A jwJSiQvsPKWrV8mFI4Rj/+LRdWwRHCrp5YE3GFsW1Udmg9p0MpuNJ/jx4Mlz oL+7THHRLzPKuYYhfveJOohTNRk7zrABHSm/xkqHRmfKM24j7D1EMBlwIj05 On5xQLcfBL3hd2LYj2nhY4hg+lDG4CGohNIR3dG4gB361WHaWbJVdMOedQGb KF4fPsU4oJcH+yh5Yudb9Bgfnh4+cw+hPQk3cvTBIRnea2ITZOE+7QviromB orWE+H3Bs/1vJeGbIhQ3Rd7aj4PXFJv05Hj/INh0nZpifEWiqOCcBC3bKcZR 3eAwiERBlWXj6Ghv1wKO3B8OgKH0KTunDAR9ZINNTLq+FUyVs73FqZCgkCZw tI5vi/50HG1ZAFl+V/xu7hd8HAdkiq7dwAiDG5mhvxc/F4ZoOKHLBbcSQ/xY flBX5LqZMa5bH9uVWCLNVBCszhnXfh9bXPsEPHGtjCGufdCr5XYcce33s0PD pT2WuO4t39uyRdfkjazRFC2wR7NmSlikWSYrMkf8+QgGue6QkC2XzAuMg4QD si1opAirwBJY994eThGqUQRGzBWDUXciMGrIyEAJn9xqdXi3y06ZzjGlfBKj ZzfyoQzp5Q3JohC6Q+4YUa/K+JC7nSDMcso5irnl3MTqxTlejLhLWFSRC20C jWdq+O14MRyq8B5K5thoYH5Hq5t8AhrcIiz59vQKfjfN8ps6TzclES2nX7W2 Isn8GGhsHphIqTm5/YeiTLfamMdMQTuYbIXeLVcJhcS5o4xCRRlADyXk/il3 8uQWIFz5/BDl6UsM6lC+TQ0pbJssiYd0yXlL2QwP5CYWQzZjYC4nuwEcVPdh kd63FJPACj7BtyhKqajbT6YxXmjlaJxnJDyFvWYnjHqtyHON2kH8AXUPpF1R xBVK3Us9UKvmMsGkmhJeBl9uI/iOWEQUoCx8O8qufmz8TF4EluL4rP6zhegs tfRZSzua5C4H9E98OchsI+bBw0tc7h6i6SO/gOQspTzklCBkyBEfkp/axL7a 8jNbQVC8YOyIHof1Nr80xUL0i65F4hRlsFkvB2SO1wN9uh//78HJMVSFpxKp C89OMYTVR4kNVAnuk++Ng80GfxdKAlj3t/LJYpRooWAupeUsmRexSyjCOT8E mJswaGxnIMlN2LlrS0cXf82LOtjcoNr38Q+dfzyn/G/0s6qy7VYGCkD0dRni rLTgoX3R2mPO5HF4PIxzLMs3JmIB6XMbo1VkYZYBgqF5/5rDQqIdBKDd6XiO Ps51kcRE3FbCVK0M8r4o3E1xTFaQm1B+5iznucr1CK/XpbcpkeFA5v3tN9PL YxExxLOrHjbqVQHkVeOtZKIo+BXQFOWZs2hqMcq8egVnEAIY+dVvx8S9rX2w I5Mr+3zrqxB2XSef+N3UXWLdA63NAMcVDdi0jJqNqBnCXyoRdbPRa4dN+Fsh yfE1iySahhnZKrJdDxAQjsKLN8OBD1bO52MJx31kP+doZfmS2suHX404jXvT pPRwyNJ64nnXSkMwMVYD+i14/eL4+d6LZ1xXQVV7hfFewyvqHwd2kmtR6Rwr hiZ1FNi142vMYxjuDlpQqJuY5tHjeNGNHK+wZiPNvEoB3N1iMTiJ5FSDc0EY XQpvnQweJQCi1mCNKs+T50f7QA/fdv2lM16r0UJFlC7Jmo5V8ZTBLFq2OpvK vzS28mqIcc544xzMDZZtlrPX8xAeKgSJX1cZjRlADum84tXdu5Ygo8tpIWqA ThVtJ2IZIOQBRcZlEi0u6NsoFnBw40M0F/CubvVgV+vL1WazDY+a3a5yEcBR 0fHsPhK8TE5IVF9/CQIDfYtGKFz3UNx+dqse70o4d7dMAfEBwnSDaZim08Td mRiQlfPkTf9dCgegmR3PnmSTvvOdjpA7GCwoPKAvwocFSaueTRZH1AqT+YEa A1xSeBLo5Sc9uXfTS/th1rcs7nE567OtJ6Pp/Fq375pQw8h/hRd6yJBO9zBa +2zv5Mw2CNy9urnKgett/rh8+zuxFSdKsSDL9b+o0NMMegLFe/KvmVzHbdp7 MF6hcObgIdNy4gvMN8b8Jr9cYPysm1l7Y+fssXqy9D1hiOFEF8lQBlpjZbzZ Ap0Q/pKlr/w0MK363btocC/VWaUL3hmdeiAj2xbHDP6ISJr/uRiKf0W024x2 Ww5Js+N8MkzxojtGozpC1Dpjo/cy37i262FbRajAx06kblt1pWzav0jk1plw fRTeuUDXs5oLCje9OOz/8cQgM/tfpRKZko7fTd4aIE3lioqeB2TVxKe18XsY Ejcgxy/6M9twc/iRdkO5+EesFc/DkiIKz7N5Ol/MOTcNJeCjQ5QKUGAZt+Vy J7w6DET50nzMIjUicTRMrsryYPwZiGf58S6SQIFdy8/JRD7Am4A+RbLKqFl2 NAh4lCARAd3ZRNMfvu9fIzuFNTQEZvkVNFDjeEWuN5ig2keM3lCUerucJQiH /bDsxviiP8XYddxl6djL2E7rpNHuho2OjlBHSJCud8HywSgU/n03T1mAFslY pu9HkIesgmAV7r3TH148sUfvrxtEdFDmGDl0gRFfwNc1xUHr/RCqGuPJKnXq VMc6qCgvns2zV4dbVm7/dWO+SPNt1cPg+OVZDAU/hM7NJU/NY37P3Z/G8B8R sNduh72OMlr1OvCgq+wdl3C+Z/mcbD/RV7D6Z3BI6J89GZHJ8OGycNcogQRG m0z7WWbiZdjwhKMJAryGzTA/54gV9jz5K0bygEby43jyM+9F+WGRJdgUbIAt /9C3zOAyeHJ0iP0/KPTvgiyX0eA8+Hbv1f7J3tmB6RklENCeyIqJMP3n/cUg QKMfbyq2qowm88TJUQ+ZAvgi5wiNpEl6gEkTmJrCA0jwEo6DFdXBwg3f/dFi +qlGYmwWgAjgUWDHZw4Y8wDd/uyZEbV3673dhvMDxtbMGWNrFE+ZqMIPmHrr tlXeZUKe+zU4Ofj++Owg3js6fPYifn1yeHZwitpLh5nG6o4u61q7uV3KM7/q yknWPN8sEHumb6FoH84nsehvny8uQ+JugWhtMT0hG/8ErXczY2LW/Qs4FtNY hsDqHltTmIjCHD45ET+Gep892fJMWAqxVLzkZoEPuB4oVI1eu+VjY4iSQ9i0 StERlzCQwA8xpRpID8NcgmM+RayZPkTMItT4TdTNV7PkajHsz76SRnLNl6z2 e6skcHCapUjRKWH8ECHmE8yV9JiPb/u6vmvdn/y6n/Q98+vBLAQqRBLZbDEF feV9eiFKEKcP4fWwUweJZyfKYaWcJBLErCRNeSMTuxyqnFsuJ+89kYyMd0TJ 7N5iP+o3J9BCMzWyP7gJY5i1r+LN9ad9lTt8B3XqIu7unR+51El13E3ULgTe RO2AR2YOW/q0BueqVeai1m6rYxGM17gdc9JK8eIx212izG1uq7C5Reoi5rYU Q4SGEEjKAgRjTL4Jwc/meGkCgpmnKiGsCfxDTjswuU/6mE/bKmrvUoH1xtjX 9zGr8kCYzS2bTGfdpNZcFtW3pQ4KuyJlZIQBQgYwBi9kBwRM7o6Ox+wgNSaD kYPL5d45CplfWNb6Z/bC24GNCfx0r602yPtZH76a3X2Amu2oeqMU90k7cOMz W8U+KQtQU9vF7RZX4xY7JheDQGHfQGEX6MSB4CzBolWk6VlF2m3FPPPxDP1Z ltDldwKNcOZTkXJIxHDXgfjN9rbBGpWn2IRdVkHWvzTZxhOXH6E0zkvCm6SQ IIeSFdfzL3HYbwRbbYiXWzhw9OH/NbZU3D2Tzfe3hN8W2W3gjdSspHyT+QXV qtvlQfzXLqhCxZJ11VuWVbsTahxt/FgS5bRIazBreSR47LfkMQPM2yiljdyK 2CgJVyIFHyopjdbU9jH9NspjqEzWbf2NXZeZpPHOb6vcwsTQZlqcfPg0m6Fx 8nCYY0nG1gmSOrge+3YWoQvYJjjOJsMkZ0JjzlvDFo9Ah/jXaFrDnWOWdznR 5JDI2ac+ev8h6rLsOH8nFvef1LdGtlwHaF/KrDzkNSZB0q2wWZETB0muaGMV nbwFr91G067MhYc2RtkEgMLbbJNRHnYl+PdCeVldtHISzJuKVwFitgWJUrCa xMEI17fBekMrEMJ7IJ4aXgZlw2tjcLP6wkRVFKw2tI2mc+MgjUFHrggLqe/7 M5PRj3h2M2xbpKWVXrcS7P8zftP8YhhgUrbyNeYtYloR5MHY6Ln7mUINXJYW 7SAM+KO3sH3AgLIdhav/o8+0Ek9JNZP+zk0M0mEd3krlsfk9b/Xnvk5+dvVt stv2Xvrf1k4YtT3kh3L+EOLJosGuLO57vrzcvlEFD4+usgaShorjL7bsemlZ c7nE0EDxFKuZ36FiPDXdyOVCLjrbNeccc1tdIIHnhPTXIkFYSoNy6JBwddpo WW8yvkyvvk6bvc7X41GNrojvXmMo77Xart0omLUbgRqtlfpKm12L6ia4vR1E vd0o2o3cRSq0bWW/8uqrS4BaG7joj8cTwneeoY3yChQ34xo1S2jEvXrYU5oF fuzkQ66fHh4dxU9f/s/JwbPTg7N7fiw1H0X2PhTDYDKb0IHR4Fk0lMbMrY6n BLgXzWkBoxT+/GE6gN9btQbQLWgA3WBUogD47a01mk78hyXQ7u5iyLUR/7vu Lj1XrTD1jQqIA88yPcqD+pD3WxrjBRgLYD2E7xDOrIzjI7NN438vktm1+Gdp AIuL+RD2dggqaky2gP7UXlLunZ2dxE+PT77fOws22WmIXIHrxvHfH2KzDNwr fzUyShurFYvKixWM9vSG6OYYcxokA+GYvyowhWeUDaC8MMl2PQWE8hlR0hp3 VqFnZeEyqvpmo7uibX55Q/G8omL0K7FvXIxE8GjWycnULO8PhYHCa1YsGCsG FXZQpDGx8m2VrtHqthrL2irdFtVtNY33EcFX8YvLarzFi8ucfsLXv7HFWxPh xhYNKf4f9/wepEnfAAA= --2G3QkHmYoN--