From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2075.outbound.protection.outlook.com [40.107.20.75]) by sourceware.org (Postfix) with ESMTPS id 2D0603852A62 for ; Fri, 9 Dec 2022 10:52:12 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 2D0603852A62 Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=suse.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=suse.com ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=R16cxkbpOktZdT2x0aocRTrRWY77A3PtBuHUU3prBuciGDzDwGpCKvYOy47px0HE+MK1c2v5m6RZ6M3hgyZrbMtPv35izjICJYzwEnqmuwjkWB9fuKEXvyz4cAJbBGe4BH80/yytl+HASkk4wjMNWTPxi4zRGV4cN/ASeW5WdkYQtLn1vmVwzGhUFvdtNOeWgi5kgXi2E/ajKnSXWtyELc76dQJ4pTdpQCTY0Dzcml7Hjr5jeAP0vpmpBWJL/BYEsmbTJms+qHkvzh9YkgfDnEWLrF0NRMuZaQQGnSOxQVMF88DwQfnsMSxqQhmmm3vFGgYNUW1/H2aGmr+3yVP/Rw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=lkvt3sRjq/RDRz5TmhnkFvXscffr0N8f8+uMjN6VMiU=; b=TxOkb1qZY+u0Af8HLTfohEXO3QUxsTlYl881Y+P9cER7DQtkgmyoio32HFvabX0yfJ2wziX+ia4tiONYZXmv1/PunOrrG37ZGTv+WSe+PsPmQZC/l3H/0Y/2h4oRcXkdFPyv93qfdT/vLZxDuxElL7/UeoWn/RANSybHGXPksdPGe9uVl2J2r+0vYkjxlRCjyKI6m3FXg+Avt3MF6CtwFXas1Dc0fKoIqCgMBjv6tBYgNO+Uxj0NBfSgjyYo32pxJHmuG1Ysfo7aT5JKXg6le22pyuaJf9rnApbZq9XgR8F191+bp/yMzSsVGROE4EsL64L+e1QTsbJaRMmGa1LjFQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=suse.com; dmarc=pass action=none header.from=suse.com; dkim=pass header.d=suse.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=lkvt3sRjq/RDRz5TmhnkFvXscffr0N8f8+uMjN6VMiU=; b=C6HZAY2w8qL3exkSVp0QeDfwmwNwwfgcIfo3CZh0l1FOxHenxyQB+BHYboTO46CReqjJwaiIFSvrrDJaHWlm6TR5LtBUu+dWbPt8V2mVF6GYYaApZk5PERrEiluTRX8Bf42RAXstRidjtrcHnn1gPl+TwS9NPgypVd51aAWV/FcpMomN+tlmnPrFuw/Lyu9sDh0nEW18MMRuDGKlatbJmed9du+Sl3cLyzJCDJzf+tiiHurHQeNBFRr915ZahNwH5P5j2wmO8furPH3MxzDRQiCtcld4ZMia7sPuBJi2rxN9nexhmxN/8RO6tQxVjqkjRu7SGEQXdH5w2Ac2YCpf6w== Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=suse.com; Received: from VE1PR04MB6560.eurprd04.prod.outlook.com (2603:10a6:803:122::25) by AM9PR04MB8162.eurprd04.prod.outlook.com (2603:10a6:20b:3e3::20) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5880.10; Fri, 9 Dec 2022 10:52:08 +0000 Received: from VE1PR04MB6560.eurprd04.prod.outlook.com ([fe80::4da2:ea8b:e71e:b8d8]) by VE1PR04MB6560.eurprd04.prod.outlook.com ([fe80::4da2:ea8b:e71e:b8d8%4]) with mapi id 15.20.5880.014; Fri, 9 Dec 2022 10:52:08 +0000 Content-Type: multipart/mixed; boundary="------------zRQwP43YAW3ga6zyFFhImPGh" Message-ID: <8eff1de6-871d-24cc-8804-9af7da0a86cf@suse.com> Date: Fri, 9 Dec 2022 11:52:06 +0100 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101 Thunderbird/102.5.1 Subject: [PATCH v2 2/2] gas: re-work line number tracking for macros and their expansions Content-Language: en-US To: Binutils References: <1d528267-9450-12c7-4c4c-fe4deb3b0617@suse.com> Cc: Nick Clifton , "ramana.radhakrishnan@arm.com" , Richard Earnshaw , Marcus Shawcroft , Alan Modra , Peter Bergner , Geoff Keating , Palmer Dabbelt , Andrew Waterman , Jim Wilson , Nelson Chu , "H.J. Lu" From: Jan Beulich In-Reply-To: <1d528267-9450-12c7-4c4c-fe4deb3b0617@suse.com> X-ClientProxiedBy: FR0P281CA0059.DEUP281.PROD.OUTLOOK.COM (2603:10a6:d10:49::7) To VE1PR04MB6560.eurprd04.prod.outlook.com (2603:10a6:803:122::25) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: VE1PR04MB6560:EE_|AM9PR04MB8162:EE_ X-MS-Office365-Filtering-Correlation-Id: cdfaa203-e581-469d-af2c-08dad9d36acb X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 4FUUUYjl/sgk0yQDC40DFuYXj/BhL/VHIW4oIu29c8/grcZm6Ubqy/74SkC+NW1iTkah/N2/sj7O5rlJ/6gsARO1a1ZBSpGx/N5zc3PpS4gZgTHPVayGVkSF2hE5kfh4MvBg2w795Nof7+/4lEquYZ99oT9BoM3VAUSZCZESnoPinko6tNgX7HshvkLoxGJJsUFmlNT3fN8XZ8tMqcYIVH8jBnIyI4zkw+qbZJJy8ar1EWpG1O+6yBRXZeG7OefZFcjyY2iDqCGTc/zv8ZfT5aPrYk8xd6PKg5mZEYU6SVR0USr7fzLeynBUasb2RFqMwM6v3uv0aH4M46nuiFau4mNL5ToqmJCb26quHX0ZlQq/mk5jwJus3wZcJLfI55f/Z+SHaLjgar5dju97UlcLY7rs+FkidodE5HZmGBYJ8BH381zeQP37U23F1CLc5xulhPdKDYWq4eUIYtlht1AZrSELfD0Y0cXkZpqI0vqka/AVv3hAtpvWavGgezdAmPN05XijtowBHW24edtPJ7rqIndvWtLoa9U7lduH50tPAsakB0uG30SqIVzwm6IXhm5WkLu/NZBRUOyvDG2xH9QyDHB0oKGvz/+CbwzBam2b3jewHdYItV/EZ81KLzO9+MbUS1ac6ouwDF4jPaO3KZpGZ6b8BrwGgycOIu8dWWxKbiYQW27GZT5J4NQmYUAEUYLMvOBgu/26sK3g7KiSfgDQFzWucKII/6vt9TkzURj7pOY2PxXPxWc1b07qPhRMx4t9Tk8MiREI6/fvmrt/sEU76H60lzMajbcleS/dp1E+gv4= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:VE1PR04MB6560.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230022)(366004)(136003)(346002)(396003)(39860400002)(376002)(451199015)(38100700002)(36756003)(6916009)(86362001)(235185007)(30864003)(2906002)(478600001)(31696002)(5660300002)(6486002)(4326008)(31686004)(83380400001)(316002)(66946007)(2616005)(7416002)(186003)(66476007)(66556008)(8936002)(41300700001)(8676002)(54906003)(26005)(6512007)(33964004)(6506007)(45980500001)(43740500002);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?B?RzQ0T0NQYzV3dUkrb0U4S2ZSVU9yZytLdmpKS3duNEtUSnBMUHprNi9RczJk?= =?utf-8?B?Smp0MTEyWnBUUGdBelZpaHlDWUExK2ZmRGUycTVZeitIelZ1VUxCd3QvR1hB?= =?utf-8?B?b3EzN0tIYXZZazM2YVZlQ0pmanlDbWZhUnpwSkg1ajNlWWtKcHQ3Q0EwMUVx?= =?utf-8?B?TlZJdEpPb0pGZ2JTcTJROTQzcTVFTnlzd01wQXhWN0VORjdwZDdaNU8zaHMw?= =?utf-8?B?TGFlbEQ3M0R4UUJ1eER5cG5lcXlTdDFSU1g3OUhFN2NxL1hjZnB2b0hISzVG?= =?utf-8?B?Y290TGdZUWZZMWtrZXR0am1QdG5ISnpBREVsREluQkNRSXFxUXRld205N2Rk?= =?utf-8?B?d3VObm4vOUNJa2hacVRUN05kQzkzM3lXYjh0U1F5cmZKUklSRG4yc3c3OWZE?= =?utf-8?B?YjRiZkw5cHkvR0luM3NDTENONExiUlp1aSthWDhCN2xZYm02SDBya3pXSENy?= =?utf-8?B?WVNPSFA4Nzg3UmVXVGFlZVhZdzlzcFZYU0p1WS9ydjUvU3VuaWVEcHJmeWtL?= =?utf-8?B?c29rV0ZzMERzRG83RzFGQ3BwTi9MMlFuNUJoaGN0M1I4SFI1bS9ESWVrUmFm?= =?utf-8?B?YnZiRVNPVER1dUdTaGtaWTIyRE15RDk1Mzlnb2RxS2VWTGc3ZGFRYVZhMDgx?= =?utf-8?B?Qnh6R2hYcjl5cHZVM2NWMWN6MVVtbzJoTW9FZTgvWGF0YkJvZTJxbmwrNVFa?= =?utf-8?B?clpoQU1zKzQ4SHFodVMxZGRsejh4WXR1a0JoSGg5RHd4cjNWSlluTzBoQnpi?= =?utf-8?B?S0k4bmlGc3k2ZVlqeEltajExV08zL3BVaEI3MlRYOEt2dTFNZlRidEJqZUp6?= =?utf-8?B?dGFHU3lETnhzMUtsb2NOVWxtcDYzRUhMU0JRdWtlV2wyY3hOanhocnNVdDJL?= =?utf-8?B?b3g2empPZ25aaDA2aGNBTmZNUlM4ZnR0SXQ0RHFQMkRkYzIydmFwU0RlaElt?= =?utf-8?B?MkFlTDZTOWYyR1NxbnkvYkd0VE5adGhjalAzMU1FOWxtS0c2VTNUeWZ5dENK?= =?utf-8?B?S29WNFdLRzI1Q1M3QVJpSC90V29qdnlJY3dYTndpOVNMcTdmcmNFUHhROEFV?= =?utf-8?B?SkNhMTFnSXpORWlFS0ZUYUVrdVFqRkVpcmtnUDB1SjhLRE04U3VkOFgyUDdK?= =?utf-8?B?dTRkTE1rN2dqTTNhQ0xQeXBrN3ZuSWNzais4MkxmaytWd3piYWRDdWhhSmdN?= =?utf-8?B?V0JlVGZwZ1Q2NlI5OUcwaUlWSUtpVUF3VnZxWlN5T0F4Y0xaQkFaZUF0eDFk?= =?utf-8?B?QUhJUGVJUWdrYzhmcGtjbE13NytoODFpNkFmNUNFUDQwV2orOG82clVCNm9a?= =?utf-8?B?eWl5azdRN2JNYmhLbGtxWSsyRldGV3RwTzA2TlBwQjBpYkhzWUxiako2a1Ev?= =?utf-8?B?STV2TGM0R0JwR1FXRzBFMTZLSU9nNElKZytwOTk2eFNtYXN3aUpaQkZrR0s5?= =?utf-8?B?WVQyVm5CRFpMUE9VelJXU0ZpeW5tc04xcjA4TzgwbUt6Mkg1a0NoWWdpS0xu?= =?utf-8?B?UlEyS0xjcXNxSVJMcktVQnloS2xKY1QwVmRSdk1uWWxRR1kwTmtEKy8wZkU4?= =?utf-8?B?Tm9oeUtNVncyT3NHMnFvQk1BWm9tUW9nOFozelhka0l6Qlk4REZOZnl3NmNk?= =?utf-8?B?dVp1cUJ1TURRZUtQVU5pYlB6TlltN1JMQW0yK0tQcnJVVFlCSndCQzZwN1RB?= =?utf-8?B?ZThCMWtjUVNKMmRzb0g1NWJNOUI4WHROYlRwT3haSEw1UU0rTlV6bkFmcFVB?= =?utf-8?B?eFo1dm1kQWFsblJOOWFVa0x3RE1qNHNSeDd0RGhlZTN2OWZFZFBzTURmYjZJ?= =?utf-8?B?bWFzV3pzbitMT2g1cnhnR1p5Ymw5TWZCcE50UHVrYVkreUJ3SFVKa0xIVUZv?= =?utf-8?B?NmxNRHdUMHlUdm9HdmZrcWpxa20ranVoU2NGZDNXZjJuSlZwd3RldzQrOFE2?= =?utf-8?B?OHZNVXY4aDVYYVVNTnFaL21MTjIzTmZWeDVJdlNOY1lnRnJMUkZnMURwTEJv?= =?utf-8?B?YTlwa0pVZVY0Y0dkNHV5cEx4elFhRVdFc0ZUM3JUR09xaTY4ZysxNHB2cFJt?= =?utf-8?B?L1B6Tkw1Z1loZHByTjB0T1UxVHEweUhWMUM4V3gvazFqU1ZqcExUN2d5cmFs?= =?utf-8?Q?amKaQTYL5RIA2MKxIzNDWXaxc?= X-OriginatorOrg: suse.com X-MS-Exchange-CrossTenant-Network-Message-Id: cdfaa203-e581-469d-af2c-08dad9d36acb X-MS-Exchange-CrossTenant-AuthSource: VE1PR04MB6560.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 09 Dec 2022 10:52:08.1594 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: f7a17af6-1c5c-4a36-aa8b-f5be247aa4ba X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: euzfVfbcHYYRIHpIOVH1ceSM4KF/3VZmGVjZDINobkX+rns6GVf4Uk2ra7RLY8z5iIGQvVCz5sGUI++d6wyY3A== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM9PR04MB8162 X-Spam-Status: No, score=-3029.0 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_PASS,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: --------------zRQwP43YAW3ga6zyFFhImPGh Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit The PR gas/16908 workaround aimed at uniformly reporting line numbers to reference macro invocation sites. As mentioned in a comment this may be desirable for small macros, but often isn't for larger ones. As a first step improve diagnostics to report both locations, while aiming at leaving generated debug info unaltered. Note that macro invocation context is lost for any diagnostics issued only after all input was processed (or more generally for any use of as_*_where(), as the functions can't know whether the passed in location is related to [part of] the present stack of locations). To maintain the intended workaround behavior for PR gas/16908, a new as_where() is introduced to "look through" macro invocations, while the existing as_where() is renamed (and used in only very few places for now). Down the road as_where() will likely want to return a list of (file,line) pairs. --- v2: Fully cover Arm testsuite. --- Omitting testsuite adjustments from the inline patch, for its sheer size; please see the attachment for the full (compressed) patch. --- Adding if (subseg_text_p (now_seg)) dwarf2_emit_insn (0); to try_macro() (alongside using as_where_top() in dwarf2_where()) would get .debug_line contents into reasonable shape (expressing both macro invocation site and macro definition location). But that's likely insufficient: We may want / need to represent macros as inline subprograms and their expansions as inlined subroutines. Which in turn looks cumbersome especially with the relatively recently added recording of functions (with which macro expansions then would better be associated, when marked as such). --- a/gas/as.h +++ b/gas/as.h @@ -437,6 +437,10 @@ typedef struct _pseudo_type pseudo_typeS #define PRINTF_WHERE_LIKE(FCN) \ void FCN (const char *file, unsigned int line, const char *format, ...) \ __attribute__ ((__format__ (__printf__, 3, 4))) +#define PRINTF_INDENT_LIKE(FCN) \ + void FCN (const char *file, unsigned int line, unsigned int indent, \ + const char *format, ...) \ + __attribute__ ((__format__ (__printf__, 4, 5))) #else /* __GNUC__ < 2 || defined(VMS) */ @@ -444,6 +448,10 @@ typedef struct _pseudo_type pseudo_typeS #define PRINTF_WHERE_LIKE(FCN) void FCN (const char *file, \ unsigned int line, \ const char *format, ...) +#define PRINTF_INDENT_LIKE(FCN) void FCN (const char *file, \ + unsigned int line, \ + unsigned int indent, \ + const char *format, ...) #endif /* __GNUC__ < 2 || defined(VMS) */ @@ -453,6 +461,7 @@ PRINTF_LIKE (as_tsktsk); PRINTF_LIKE (as_warn); PRINTF_WHERE_LIKE (as_bad_where); PRINTF_WHERE_LIKE (as_warn_where); +PRINTF_INDENT_LIKE (as_info_where); void as_abort (const char *, int, const char *) ATTRIBUTE_NORETURN; void signal_init (void); @@ -487,7 +496,9 @@ void cond_finish_check (int); void cond_exit_macro (int); int seen_at_least_1_file (void); void app_pop (char *); +void as_report_context (void); const char * as_where (unsigned int *); +const char * as_where_top (unsigned int *); const char * as_where_physical (unsigned int *); void bump_line_counters (void); void do_scrub_begin (int); --- a/gas/input-scrub.c +++ b/gas/input-scrub.c @@ -104,6 +104,9 @@ static const char *logical_input_file; static unsigned int physical_input_line; static unsigned int logical_input_line; +/* Indicator whether the origin of an update was a .linefile directive. */ +static bool is_linefile; + /* Struct used to save the state of the input handler during include files */ struct input_save { char * buffer_start; @@ -115,6 +118,7 @@ struct input_save { const char * logical_input_file; unsigned int physical_input_line; unsigned int logical_input_line; + bool is_linefile; size_t sb_index; sb from_sb; enum expansion from_sb_expansion; /* Should we do a conditional check? */ @@ -166,6 +170,7 @@ input_scrub_push (char *saved_position) saved->logical_input_file = logical_input_file; saved->physical_input_line = physical_input_line; saved->logical_input_line = logical_input_line; + saved->is_linefile = is_linefile; saved->sb_index = sb_index; saved->from_sb = from_sb; saved->from_sb_expansion = from_sb_expansion; @@ -193,6 +198,7 @@ input_scrub_pop (struct input_save *save logical_input_file = saved->logical_input_file; physical_input_line = saved->physical_input_line; logical_input_line = saved->logical_input_line; + is_linefile = saved->is_linefile; sb_index = saved->sb_index; from_sb = saved->from_sb; from_sb_expansion = saved->from_sb_expansion; @@ -267,8 +273,6 @@ input_scrub_include_sb (sb *from, char * as_fatal (_("macros nested too deeply")); ++macro_nest; - gas_assert (expansion < expanding_nested); - #ifdef md_macro_start if (expansion == expanding_macro) { @@ -283,8 +287,6 @@ input_scrub_include_sb (sb *from, char * expansion. */ newline = from->len >= 1 && from->ptr[0] != '\n'; sb_build (&from_sb, from->len + newline + 2 * sizeof (".linefile") + 30); - if (expansion == expanding_repeat && from_sb_expansion >= expanding_macro) - expansion = expanding_nested; from_sb_expansion = expansion; if (newline) { @@ -437,10 +439,7 @@ bump_line_counters (void) if (sb_index == (size_t) -1) ++physical_input_line; - /* PR gas/16908 workaround: Don't bump logical line numbers while - expanding macros, unless file (and maybe line; see as_where()) are - used inside the macro. */ - if (logical_input_line != -1u && from_sb_expansion < expanding_macro) + if (logical_input_line != -1u) ++logical_input_line; } @@ -471,10 +470,6 @@ new_logical_line_flags (const char *fnam case 1 << 3: if (line_number < 0 || fname != NULL) abort (); - /* PR gas/16908 workaround: Ignore updates when nested inside a macro - expansion. */ - if (from_sb_expansion == expanding_nested) - return; if (next_saved_file == NULL) fname = physical_input_file; else if (next_saved_file->logical_input_file) @@ -486,6 +481,8 @@ new_logical_line_flags (const char *fnam abort (); } + is_linefile = flags != 1 && (flags != 0 || fname); + if (line_number >= 0) logical_input_line = line_number; else if (line_number == -1 && fname && !*fname && (flags & (1 << 2))) @@ -499,15 +496,6 @@ new_logical_line_flags (const char *fnam && (logical_input_file == NULL || filename_cmp (logical_input_file, fname))) logical_input_file = fname; - - /* When encountering file or line changes inside a macro, arrange for - bump_line_counters() to henceforth increment the logical line number - again, just like it does when expanding repeats. See as_where() for - why changing file or line alone doesn't alter expansion mode. */ - if (from_sb_expansion == expanding_macro - && logical_input_file != NULL - && logical_input_line != -1u) - from_sb_expansion = expanding_repeat; } void @@ -516,6 +504,33 @@ new_logical_line (const char *fname, int new_logical_line_flags (fname, line_number, 0); } +void +as_report_context (void) +{ + const struct input_save *saved = next_saved_file; + enum expansion expansion = from_sb_expansion; + int indent = 1; + + if (!macro_nest) + return; + + do + { + if (expansion != expanding_macro) + /* Nothing. */; + else if (saved->logical_input_file != NULL + && saved->logical_input_line != -1u) + as_info_where (saved->logical_input_file, saved->logical_input_line, + indent, _("macro invoked from here")); + else + as_info_where (saved->physical_input_file, saved->physical_input_line, + indent, _("macro invoked from here")); + + expansion = saved->from_sb_expansion; + ++indent; + } + while ((saved = saved->next_saved_file) != NULL); +} /* Return the current physical input file name and line number, if known */ @@ -534,11 +549,53 @@ as_where_physical (unsigned int *linep) return NULL; } -/* Return the current file name and line number. */ +/* Return the file name and line number at the top most macro + invocation, unless .file / .line were used inside a macro. */ const char * as_where (unsigned int *linep) { + const char *file = as_where_top (linep); + + if (macro_nest && is_linefile) + { + const struct input_save *saved = next_saved_file; + enum expansion expansion = from_sb_expansion; + + do + { + if (!saved->is_linefile) + break; + + if (expansion != expanding_macro) + /* Nothing. */; + else if (saved->logical_input_file != NULL + && (linep == NULL || saved->logical_input_line != -1u)) + { + if (linep != NULL) + *linep = saved->logical_input_line; + file = saved->logical_input_file; + } + else if (saved->physical_input_file != NULL) + { + if (linep != NULL) + *linep = saved->physical_input_line; + file = saved->physical_input_file; + } + + expansion = saved->from_sb_expansion; + } + while ((saved = saved->next_saved_file) != NULL); + } + + return file; +} + +/* Return the current file name and line number. */ + +const char * +as_where_top (unsigned int *linep) +{ if (logical_input_file != NULL && (linep == NULL || logical_input_line != -1u)) { @@ -549,4 +606,3 @@ as_where (unsigned int *linep) return as_where_physical (linep); } - --- a/gas/macro.c +++ b/gas/macro.c @@ -131,23 +131,21 @@ buffer_and_nest (const char *from, const else from_len = strlen (from); - /* Except for macros record the present source position, such that - diagnostics and debug info will be properly associated with the - respective original lines, rather than with the line of the ending - directive (TO). */ - if (from == NULL || strcasecmp (from, "MACRO") != 0) - { - unsigned int line; - char *linefile; - - as_where (&line); - if (!flag_m68k_mri) - linefile = xasprintf ("\t.linefile %u .", line + 1); - else - linefile = xasprintf ("\tlinefile %u .", line + 1); - sb_add_string (ptr, linefile); - xfree (linefile); - } + /* Record the present source position, such that diagnostics and debug info + can be properly associated with the respective original lines, rather + than with the line of the ending directive (TO). */ + { + unsigned int line; + char *linefile; + + as_where_top (&line); + if (!flag_m68k_mri) + linefile = xasprintf ("\t.linefile %u .", line + 1); + else + linefile = xasprintf ("\tlinefile %u .", line + 1); + sb_add_string (ptr, linefile); + xfree (linefile); + } while (more) { @@ -249,14 +247,8 @@ buffer_and_nest (const char *from, const } /* PR gas/16908 - Apply and discard .linefile directives that appear within - the macro. For long macros, one might want to report the - line number information associated with the lines within - the macro definition, but we would need more infrastructure - to make that happen correctly (e.g. resetting the line - number when expanding the macro), and since for short - macros we clearly prefer reporting the point of expansion - anyway, there's not an obviously better fix here. */ + Apply .linefile directives that appear within the macro, alongside + keeping them for later expansion of the macro. */ if (from != NULL && strcasecmp (from, "MACRO") == 0 && len >= 8 && strncasecmp (ptr->ptr + i, "linefile", 8) == 0) { @@ -267,7 +259,6 @@ buffer_and_nest (const char *from, const s_linefile (0); restore_ilp (); ptr->ptr[ptr->len] = saved_eol_char; - ptr->len = line_start; } } --- a/gas/messages.c +++ b/gas/messages.c @@ -18,6 +18,7 @@ 02110-1301, USA. */ #include "as.h" +#include #include /* If the system doesn't provide strsignal, we get it defined in @@ -119,7 +120,7 @@ as_show_where (void) const char *file; unsigned int line; - file = as_where (&line); + file = as_where_top (&line); identify (file); if (file) { @@ -130,6 +131,25 @@ as_show_where (void) } } +/* Send to stderr a string as information, with location data passed in. + Note that for now this is not intended for general use. */ + +void +as_info_where (const char *file, unsigned int line, unsigned int indent, + const char *format, ...) +{ + va_list args; + char buffer[2000]; + + gas_assert (file != NULL && line > 0 && indent <= INT_MAX); + + va_start (args, format); + vsnprintf (buffer, sizeof (buffer), format, args); + va_end (args); + fprintf (stderr, "%s:%u: %*s%s%s\n", + file, line, (int)indent, "", _("Info: "), buffer); +} + /* Send to stderr a string as a warning, and locate warning in input file(s). Please only use this for when we have some recovery action. @@ -146,6 +166,7 @@ as_tsktsk (const char *format, ...) vfprintf (stderr, format, args); va_end (args); (void) putc ('\n', stderr); + as_report_context (); } /* The common portion of as_warn and as_warn_where. */ @@ -153,10 +174,15 @@ as_tsktsk (const char *format, ...) static void as_warn_internal (const char *file, unsigned int line, char *buffer) { + bool context = false; + ++warning_count; if (file == NULL) - file = as_where (&line); + { + file = as_where_top (&line); + context = true; + } identify (file); if (file) @@ -168,6 +194,10 @@ as_warn_internal (const char *file, unsi } else fprintf (stderr, "%s%s\n", _("Warning: "), buffer); + + if (context) + as_report_context (); + #ifndef NO_LISTING listing_warning (buffer); #endif @@ -194,7 +224,7 @@ as_warn (const char *format, ...) } } -/* Like as_bad but the file name and line number are passed in. +/* Like as_warn but the file name and line number are passed in. Unfortunately, we have to repeat the function in order to handle the varargs correctly and portably. */ @@ -218,10 +248,15 @@ as_warn_where (const char *file, unsigne static void as_bad_internal (const char *file, unsigned int line, char *buffer) { + bool context = false; + ++error_count; if (file == NULL) - file = as_where (&line); + { + file = as_where_top (&line); + context = true; + } identify (file); if (file) @@ -233,6 +268,10 @@ as_bad_internal (const char *file, unsig } else fprintf (stderr, "%s%s\n", _("Error: "), buffer); + + if (context) + as_report_context (); + #ifndef NO_LISTING listing_error (buffer); #endif @@ -290,6 +329,7 @@ as_fatal (const char *format, ...) vfprintf (stderr, format, args); (void) putc ('\n', stderr); va_end (args); + as_report_context (); /* Delete the output file, if it exists. This will prevent make from thinking that a file was created and hence does not need rebuilding. */ if (out_file_name != NULL) @@ -312,6 +352,7 @@ as_abort (const char *file, int line, co fprintf (stderr, _("Internal error in %s at %s:%d.\n"), fn, file, line); else fprintf (stderr, _("Internal error at %s:%d.\n"), file, line); + as_report_context (); fprintf (stderr, _("Please report this bug.\n")); --- a/gas/sb.h +++ b/gas/sb.h @@ -66,11 +66,9 @@ extern size_t sb_skip_comma (size_t, sb /* Actually in input-scrub.c. */ enum expansion { - /* Note: Order matters! */ expanding_none, expanding_repeat, expanding_macro, - expanding_nested, /* Only for internal use of input-scrub.c. */ }; extern void input_scrub_include_sb (sb *, char *, enum expansion); --------------zRQwP43YAW3ga6zyFFhImPGh Content-Type: application/octet-stream; name="binutils-master-macro-location.patch.bz2" Content-Disposition: attachment; filename="binutils-master-macro-location.patch.bz2" Content-Transfer-Encoding: base64 QlpoOTFBWSZTWRr9FOUEA6zfgHw1e//////v3//////+YMee2fdfB43DoBRT60DoBr5AA77tl3vB vPeus0CIsQF82ffblSoALoyPkMAHnua66euOM1CuHz5n3h8B6a3nwCg+ZvYCPp0A6gF9Pedqju85 0XkfABABjCAHqQAAFDu9vTD27DPTRE5hhVV6Prj0QJEby9PbE7Y7PnR3cDmVLi+voDIpgCwg4CU0 oNFbYFSaHp7wmB7hRmEpSlXfRyR147YTrL66pvbZ64wteqGnvcV7wDSBNu7qQ4CKxahBQ9LDFt64 6GYakogNDPLGeDgOABgENB91SAYZOgE99u4uygD4W6YUAFAAUAAAUk7Yvpjnve8PbC+PreDQXjyv aNIdxwAvPqcHVtzbcbZGaKTQxCpLZt7HQ12s4qiFGn3DFCpyxLYBm+UsPqSJDD3VQBVSChSEVEzy +O95e97hd2OSSuG0w717173DXvMFAAAApKERInQI5zc0VlNBgWmFKzQYhQVNjKqKStmlG2QBLQ1K EbMUEqKlbFGPPVQJTSBtUIEIymCpvJoaT0iZpGhk9TTQAaGnqaGgABKaaCJRCZE8io3kp6mn6pjQ aNEeiAD1MZTAANIxNMNT3qikaiU3pU9pqaIDRkABiADQDQAAADJoEp+qSImomE0CE1PSbKGYiA9Q DQaDQAAAAAUlJCCAIACNBNCnqeQaap+pmp6p6h5JvJNNR+lPU3pT1MmmAqJIQEE0aAgTE0NCGjTS myp+R6mSjaj0h6T0TPU1B6R6RPEyqar6ObamtfU2XOHOXHVpUCGxtHZqPnKan+H5H9v2/jLn831y T36/xYf/zEImUX+/+j7+LrKSECQiQRjkc/7mc/d/leP1rERvr9VjXnrqjX4FHnSX/pXUt5kfDvXn sCLomKqc1+U7XrE454ykr26/0XZfp2Z8fb8U1ZMSRHssRbDZDYe51/I7Xa2oqujClJwwSGVEmWZu /DmzZOsqQbuTKtUxLcs3/dvOXGouHttvrdR03bc1R3uj/lOuui3mNojmbubm6HJVxHMRhcbijDOb txlznObtuby5cxs3OOK5zNy4m25ummRhLlucVyGBxHLXHOOM1mpK1bmZ4VyY3EREULnD5kXUfgZ5 782kgcI+KSivhHxPpwGiy+SfIzR899rhv52EYkiBJdPMNuJXFKNQL/5NItQpi+9+zk6GCRswg1T7 FKKnx8ds5Pz//P/nL/6iPKnlbYe9Iknu/mSlJVFtU2zFrIxP784XKcqFNiFwRmFjpVVf/wsYrGIY xMYxjGMYxjGMYxjGMYxjGMYxhSlKUpSlKUpSlKTGMYxjGMYxjCTZsEsY1LbbZjIyyzLBIxiLFhGL LLRLSwZGKZBMxjLLLMsssy1ZbMzVtrLLMsssy1ZbJhmGGGMRlhGWNtttVswYxSsYrGMYxjGMYxjG MYxjGMKUpSlKUpSlKUpSYxhjGGMYxjGMYxjGMYMYwxiY3021OsbGzjmPLps2bouXXKvOpaNlZ9nX 0+fPn6q/uewG26bboAbZWfk9WR+KydVzTTBylqzSYrZFc1NpVnFitlhq2mnFNq85JF9r/MRVWFRV EWCGcmzkuyuNZOC5Li0y21pyTFwZiZJMVTMsTp1rc1q3dy1azm5h0p2k4jOOVkOK3Kapy5rM2tls WHNapyRjhZLHKwrmLUxys1UOck1Nxs1gTKuLcbMhzTTks5xqcTS5tjQtqZWMMlbMbbNWhmzNRi5a 1XDmq5y0YQwTFxYwMjBKMzLbDJHJFzW2ji4icjm42Ycm4MzKbbDGUwYp+PLmtNpqYxhho002jwMY ccxrNWMtaYZa0ybIrtpsmabJmmya1WbaTbWhbKNrZNqbFZqtabJrJtU2m02m45Yyy1nNHLHFjljk 0kOMsYY2rRbVshZjIQyAsZbuWVbZGVGVIZCnC0bDmbhcS5qsDJEHIAC5PLf7bQes8xY+w/7P4zvf ft6IUfw+fx+hSK/3M2Vo9kwT8hr6sxbXy5+hRzXyrnKv75L4j5D42zg9PognXuzps/BquNZ+Gr+j V+wsYswswsxa1GkxfpTkD9eqGzbMbG1JPHaocYXX0KXq/XPXyVyc4k4mtDvycWstlhNNVzOJqMsy 1psWMsy0ya0wObiZtk0Wp1tYnKYWq02RqdY5UzTCNNlzz6S5+nadZaLtqddLkHWXXS51qddJyrrU 63NHNLmjmlzHOqu7p2x27TiXfLibu5OSNNlu+V36XE61OulxTrU6xDmlzKc0uZOZc0R1MWnbkvXQ XjVUXadtNhkWxYn6ttpJ27vvff5PxiPKo6t7k9M+z477nx+RP11vPzWP4yZ2mpySVlRbK/26P9K+ LfhnHHORIlHo9Jv+x3f+bf7ePK+PT7fP7ltru3rFcueIggCSAhCUSD+zJ+Rlt2Lqu2Y2U2yYq5dN E5mXMwoGIRLmJGQTI1CgShoZtNMpkg2mpGkoR7cEvf+GrI+wOe0GhCUBVQ1UNVHafQ7/34k/dWx4 ul6XbqJG6olmkBuM7W1m1t/U44vDc3jXN5wrd3HE3jLdtnLcEyiMy6hRMKFCV19n6+8jv8FMH7a/ 4EXOp8Q6Qi6+TvgPeoxnyNBuvzrtJ/1j8i/ZPw/00EQEfLAevvLCEfSf7klnEdLeSPbk8bMNfXBv 7/GePhn7RcGyLSvGJ6X/CZhnwRKMzMFoXYqStyT1O/rvGwijerWmYuontPUtJdL6Inz/TIGEnkSl HPr6xWtK8ID+ZWhboyPsaeMv4YfrlSF3K8NPI3pbTz59Gx+3+T7P2T8j/Kfb+V/CWJmE5zVOD+25 WuOE7yWjqtR3m5F8RLydKxxSEk0Kp3Nfdh4NgP5jwUtRVbUMV+g7lKVVVUpJJJJSkkl1eL3XLly5 aaaaaaaaeIRg4RZRyVumxHIRid7yOjGMzMxjMzMyqpSqqsgyi6EU0UpSSUpJJJJSkklKUpJJSkkk klKSS2J3vjGNZhjX5lXHBlhllK7rulKSSUpJJJJSkklKUpJJSkkkklKSSUpSkklKSSSSUpJJSlKS SUpJJJJSkklKUpJJSkkkklKSS88qKtrP4XfzXep3ejPCynGqszp0R2sg1iMvJmZZmegnFxmZZmZZ mZZmcE7vKMsMsMdrOpJYkliSWJJYkliSWJJYkliSWJLcyV3SlJJKUkkkkpSSXbozK8OiOnRmMV9x omMg5UWh+dDGxjGGyGgtDTRjGGnZWxwU6pTjJkzk0mpq5NZNYuaSgblJFOLMSRqYYNqXLo6ODkZr UWWq8v2OPK3a7duhzjt1NbtYO5n+Yv1fZ/XFcWRfyn4/vRVvxc4pVYQFpV+3ThUs5guI2VkwtAy2 lgxaWLSwsSrC0tCNTFqMjVYsqwslYiI0yt1q5NITrnJVV/1VIVZJQoFEflDsQ4+/+78vb7fdx1+9 b1sx/Ks3/V8P3s5yTkk/pyTv9H6f1Kqqqqqqqqqqqqqqqqqqqqqqqqq7PaKeX+U0+lfUIPrVeO/i lT1nsuCIcH0jbfoTmJrl4oxzF6pISddo1p/1SJHX+p8n6Hv8FsmpjJ+3Uxa7q1qZP33ZU/N7ljRg Lbe0to+uY0CxMb/H7xMoPp+qfvX+r43ssoJqZa+zhb/VMuY6pSRcPriGpUDRu9Ra6i3M0346cctM b43225M6kR7SI+QHxIS+f9ftA+P9DvVbPN5ilJ/AlHl276Kqq52S/f1+flRFcJO+3aiifYkmPyT9 DxcyOfLg5/0iZ8q8cfv7TG0c5IeCeKor2qvTu9FWucSPzUvL4fzVCEcpJNx+2WESBz3w6frvTn5/ vuta08giT9nd8FK2J1ns2Hg6vzEkH8iaktNVi1Wj3F8i4XQZBaVhEh/iMNSlJ5CYTQ0mDBSXAmMX Bw4mMmHQRdBKcJ1YcGuSVTSyOCktVynUvsJwdLslqmRGLhwLiuUsWDgSshwsGjBcGq4WHE4wcBkX YU6FgMXFilwVVwGBwUcE6HKE41OVYo1XBxMMyxGTShhl3ahmVsMw2hbDMNpODXPPcpOhghhaYK1g mksGUwu1XdB2Pf457KvZ6vHoqvacQ9nxj5OEDCZenPrBJN9ddbScyIiJ6/mCCC2htkNOC9mGS542 O+5cUEOIhRFklSTib9+oa9G7Wuny731uix5bZtePnPdrbf/txnjxxyM7+ze+oa9nkf16FG0kU0Kk 6vtV3ZiqxWKx+pNkwEfpEKAYqMDEYem+1D+hVZSuvbX2UiPs+HFHl7EQbv/5JKr7L8vHz7EkxJPl O/vnt2znv4d8/XOJOW6EknNJPHx5OJ0plqpJmxPLwSTOTjwnR+jfAdInRpIm1RIk4nz2rML55zHg RHHd1wXXhWs/JV+n675IiIiIif++WZfpiplfm+lnLOMAAAAsypSsKKSduU+rf//Mdwd4iPIjfx19 5Pfk6emW+cIh/qkbjCQn9SB03+3aJzIvlkQ6Schrhp8fj/TJE+LfqL25vwP7L1uZltvx5btseKv/ hxp76OJUkJOpHh2kf8T8RGGEwxWJWDDAwwMMDDEzDDCsMLDAwwMMGoDDDDDDDDDDDDDDDDDDDDDD DDDDDDDDDDDDDDDDDDDDDDDGGGGGGGGGGGGGGGGGDCwwwwYYMMGGGrEwwYYYDBhjDAYYWMKwwsMK YYkxjCrEIEAfe9/1H0HD8IxjGMYxjGMYxjGMYxjGMYxjGMYxjGMZ7D6vWM95kcR4ntk6GOvq13BQ RtxcKz+SZvcAPpzvzvHX8UEwhrb4d82BL7MeokgzwNhEOpCJ7HHZNhW/h5cZmLk4+N+390cOu3hf ciTwERH4D4z9f2UFVVUFVVUFVVVBVVVBVVVcg+n4HR6aqe5y/SSJP2c5HkhzqW2X1ehO/eML3Vq+ IH4e/1xJ8XYq5eyo+z+y66XrmiIifT57uXv4tjlWW2MrLbGVP4x+cnn8AijkREEKKv62HYLx11uj u5WmfVUG/tBaR5BgJP1pvV/6GJlXDCTFVMmET62VcEYyqtuCVlVbcHeSVI+2UklLLElJJSsxSUql RKb1d0YKpPGkMchwkabsy7HHor3KvgpdESwvIDwVcoFe8Gng/6P41L8P39o/LV1hvOqK93r6CVJ8 Xlrj7+5EvbQleSAgiNX9wQRAUePy9tary8udp5xywERC2xp4oMZL9I+xR57aNQ4gnugtzEWwe/qd 5AEHlv3eld8v29z5T89ut+88OZAX6b2ggiIAI58WxP9CMpIq67e579q+s9vHhY599z2/xJx5EcpB ucqckQTm+ndJDONtJJ68HkTcE5wUfkehV/UfKnYepP2k9D4E/aTuUXqvHL/L6gRB58/H8T5/rv0d k9hZJ/ZH7es6wiT7p3lypI/6vk6mEGXffH5XBTp1z9vEVOPJVu3XK8XidfYDgld1Xz+2njqvw87n /R/+1jZbbNjTaPWpRd0hd6+2eSorg9ZnnrxZdhKVkj6gx8b9c+jCI3+Hxubc9+vXHr9xGDuTw7dX 6ffLgqH1+klVx7M/g+T9VmtYsZfpaa0L9c2QSTDdhXKVLZRDdS0szlMuczN3N5xznN3dt3KNcpFN uON3c5hzKy4gYgCCsslKzFSsvHyv2enxm7G3Zb8fktAtAtAtAtAtDhaBaBaILS1aCUpmZ/ye6Zqw V3Y7Viky7KpWLLsdqxWakkk8wqkrxYKvfzu/NqR54bu84Jd8XRe7TuawudNnHHJzn4WerMyz7a/p 2SSxJJJJZiS7sy/F6+r3b7zd3d02Z258y90uWFkV+K5630kbbGta1SSeyYtpSMG5rZ2/hCH0nOAu FvyfLpYlH29/t+3nft8R4Dqrk7SsPxVFfOfrKLwIO68jMyxZYyxlqllhlhZZTGqyxclvPz/NCM17 q27eOqkkTuP79+Ufgkifbyrbt4jgQDAfQwiknu2tVbV+GnqhTlDp0+22W2v2/t18NozMZWZM7cyE TwBPrOsPZI72RbIufz3kQGbGI9vX4fIbsJtE21/f47c/BZHI70SQdYk0TaF/Z/Qe10b8zSSent/Q +aeuu32Ojt38fB8oG6REOrZ5SROmxIT7MST2fd9nRm04Z69iESzxb7myIicndipus8iOyr9D/owI iANAOmEHO8nPr22kDjsIk6CJKB67fswdP8CQLxJG54fr7B1iLtxbKkl+U7b8ve+XXkTnI1Rwvqdv MunfiV8HSpcKuX3rbVi/i27fDxA+zL3263qkibPt/P6+m2ta18jTdNugbdNugbdNugbdNugbdNug XYsgsgsgsgsgylmWfDL5Vz1gbqCIIg2r9l8O78Kvnfh8nzWbPhepJ8Pf9b3+xaPn3M0tG7maWj47 maWj5tzNLR67maWjrczS0dbmaWjvdnZBOydk7JhMJ8z09NLRu7PyXXWlo3dnUTrrYWodTZmbC1D1 mzM2FqHrNmZsLUNmzM2FqHrNmZsLUPWbMzYWoes2ZmwtQ6mzM2FqHU2ZmwtQ9N2Cd9dACVBQ666g 5u1VVVVVVVNa9eL169HjK7djt27a3z541rWta0qqqqvkyju53W0bc2to253W0bc7raNud1tG3Oq2 jbnVbRtzknrW0bcnrW0bc51W0bcnVbRtyetbRtyetbRtybW0bcnrW0bcnrW0bcnrW0bcnVbRtydV tG3PTLkzJ1pd10W448+6vjHK8yc+LdDB4fJfzBEHGOPnjiCL2F0WuRqD7t0barQQRAKIg7AZo6+G ksYXY7du2t6+36wAAAAAAAAAA9Wd5ns+zxu7u+t31r0MMLPNfEuVcq91e6qr3V7q91dXLq5XK5mZ fmcya7W7mZhmYfNDwevwz3fkq+nyv1RP34nURUuWE5YTlhLLORctTkTORORORFSuZgzlhM5YRUuW EzlhOUkTORORORM5E5E5EVLlJE5SROUkRUrlhM5YTlJEzkTkTkTORORORFS5YTlhOWEVcrZE5Sq1 dFVaujRowYMGDBgwwwwYMGDBgwYMRy+x/nM6Q934ImuthP/M+DD/r5Xy+mm01Mv8b9ZzjdVrX5UR 97f+bcUwub4nOINhU9SxKVCQ/rcpFs+C+ndi5MNfnlQs/6W1P+lrMeEPh8/gz+TJ/BUzX01VjVxl yq4QspfxMiZEVtwMSC88fg5zOsW5mW/6GaVJp+hhMU3vFm6m3245k1RFAqQ2uLWWTLMWrLy9nX7N a1rNZluZmZ/hP/G1Vt4JOV32/ckyWyJ+ow+Z0n4y0lHM2P5HI/rODRyNjY2NjY2PuOhuPE3Nzc3N zc3ODc+8dDsnPbnmhS8S0UbH8Dc3nOWko3G4aChSYYGSTpLRophoKGpNS1G0tLZNLYd34sPI+jpl mZmsktttttttmrCEttsYxhVKrFMVjGMYxjGFWRkliUlsrLZSUlJYlJSUlJSUlJSUliUlJSUlJSUl JSWJSUlJSUlJSUlJYlJSUlJSUlJSUliUlJSWYJSUlJSUlRiUlJSUliWyTVbK2WyzW5mEyyq1ZGZN AUsUpiqwY+KsRh7n/L4ZvZrWas1rNWa1jUNy1DctQ3LSQ3J9OJJJwH4pgrT6u5ESbIrm8mmkllic jo1OptLkzltsFGxwpnGZcrMtyOY0jEN6+diSx1XS4rD0HI7B40OzDqdl0uViXnEk8yTZIkmzZLOv PgbzMwAZwa8TzHETNt5zjZkcRMklmTYiI4jQI2xwwIcjSUEolJERmyB1RED64TnOVOc5S5p01Tmn GpzW1O9kgTJMEyTETJIEyUOGxjh2y1QCyUOuttm4O+raC2maZptRBBclhBZRHkSW8sxwgZMR/LU9 5MeqbmNTcw03MNNzDTcw03MNNzDhOArsHoecsiIxEQjVJEYHji5sLiolImqcRCBWbJrTg2pYbIWp NWSVy7MzGZnnrWoIIlnZBBBBBBHUknfnrlWOwd6Foboc5MreAetAtA3QOdTJMp46787u7bbd9zIC iXMySSMgZTmZJJGQlCeARtRlE0BFdYF2T6XbAuy8oD2brAaggT1hqk1rJIzMkS3q1rUSW6a1qC3M wUqSFNsB8HSoCqHSqKodKoKodlzYF2S7LlxdjsubhiAgdFsBsbgbG4GxuAiIIfaqhJLqSSjUYtQZ 2SPQJ++B/aR9ZB+8ofMUKFChgwYMMRwYYYMMGDBgwYdEViOGOikoTQ9pgmiGj5k0FOCOBGhQoUUU Tg0bDQUbDBRRNEUw3KaFKce/kz3vpa/W1xc/Qb0XwlM2uKNZWK8fE7HmP5zzHmNjoeIxjGMYxjGM YxjGMYxjGMYxjGMYxjGMYxtcsYMFzBtsoRsbGzW5zQLlIup1tvNhcZOmi+Epm1xR1ysVy5HI4OR1 OpsdDqMYxjGMYxjGMYxjGMYxjGMYxjGMYxjGMbXLGDBcwbbKEbGxs1uc0CEcup1EKRSlMq0enETH myu3ptn0Xxir5up8KxPbu3NhCwtZU4t28Dw7SSYNjwMngeB4DqpZYsMYxjGPWpYy5cYxjGPOZYxm DAxjGPGJYxjMmRjGO95YxtYorS3oq8kmijbZXuXLFzY2NmuO/mdLJddvl9Zo9TCmHuOZo5k9o5mx ue40bjcbGHU2PcNx7hR7hR7hR2OD4jR2NHQ7FHcbjYUdRR1FGie85FNHU0YNjmYPAdRhyORhwKP5 hyOZwU3G5HI5lMMOROxobmGDRTxKU7mCncwU8TBSnB3KYRhuYKbmCdTqUp0JoNGimxhsRsQk+ZSn Q6minMwU5GCmxgpTYbDY2KdhuSlKfIeh6DwPoeJ5m5hNjY2PMUvu1Kh7W0fZvctu1a5acW32rbtW 7kp9F8i/R+yoXu9nedU/71jWq/p7fRn3Y7U/pM+pvVqi7cck/wQjEB+g/H6Pwm9vr/P5WzudFblp FdrR6i25VVa2/fGPZd6re2Jwx8MsmvwI7vqLcl835Ofek6DmIn5UcxFj2cvh7+Qd2Zg83s9X4z5P 3reVJcfP01fJacQW2j8ub9/n8pmZrf1Zsb7F/+fZlKPWjK56mTeTgzji+7lLisfcIAgJ+4/IkA2K VFsoLP/rS4lVcNah/NRI5UqzTNtWpMKmUBlVgysMDRhMMLYrJhbNi0zUxZYWyNixYsbbFmVmrMMa sahktWZNS1a1Y1Y1bbLNWWw0aMNG0GBkxsamSMLGYwtY2MM2LYwtNaTMsFkwNZay1lrLZbLYti2j arEQozKjIgZkspLKSNoyxsbJMTKNmzTG1YyUUWZkWYxWGWLAiJVmUiZmYrGWQAClVA2GZKsxGZsV bUWyG0hbJNgFtE2gGxNpMWEbK2QzKmyDaFm2lmA2pGsWtVWtFmltE22LNItmws0MLUjW2FjIGaps g2is21GslqRamJkmsrWSaya1K2TZSxoYyoxoYyMLUWZmGMmZZljWtWsrMLMrNFkjKlhGUk1o1kaa mmq2Zia0MWrbMGtDMMybZo1qa1Aay1rWmazDYbEzBmjUYbRmKWZWtGtTNGZMwzVa01lrA2DFg1ga 1UZgzEzAGZAawLWQsmbZprVmZs0xkyamM0GbDbNa0wzbNNatbNNNLLDMSwyLJUksSjDMMqSsjDUL DRYTFVVyirCAskpTBAv3aoqcR/Rof9zT/njsqL/tAcX+lVZy4qsquf1/8ObdQIT3FykvYVSdSpCD hULP7GGVPH2S/o+/PfPtft42h67/CPW/gn59/5SIjRERn2ERGxshZNoUn1c/j7bxaQr39j3bxMbL VYTnoP8NNGZ6gwo/fACCAOQztUY/iQif7s5ckbbezZvkfyP6Pa/KPrZMpTSNlluZ+qUl1PvU7zlc yuANpZZbbbhJrtmKRrNg0E41nKknKhoN0rAP7Ya1kxBDA+mc9ts+d1tCivxSFebSK/YdlSSc5P4o 2IEo5PcqMUdfOakr6dRu33laaoi12u9qDFKNQXVviVS0LOTyilBMRI3FoMm+HTR97tYdmso6YjJs 5XL3deUsHCN4plG6pA/NH++D/lA4P6YrWzae49os+OVnxzoonRYn9ko8hozV0M0aZVrCoRU8Sqt+ eVQABAACSSRmZmZmZsD4ATod6T5KskZVoMzMMzNG2tGYZlNapszMyMzNQzMxtrVVhYJqbUy2ht3v aAoKDcoKUBgMGEnU/E/uEk9Z9P8CzY2lKfQ+J8TsdTyOA8g7B5B3B3gwYMGDBgwYMGHrHU6nM5nM 5nM5nc9kTxw+46hHQKcjkyO1kt8aho7hidhVGHIcBku1ktdOg7Oxsbt3m06TRyaeJI8BQ5jlyFo0 MRvybMxgqsOgw3QNk5DtwkbKkdng8H1MMMO3SL1MzCZzjxq3JDpUF3M7DMPceKdrRozNVrRozMXa o70nE3jox7RirwOndmdXe2zoro8VLkDsn1xtWqbyTUkGCiMc1KrVaKb/J4I+b/v8mPqa0jyH/Vs9 iNI5tnNG0NlqxchjCJkyGMImTIYwiZMhjCJkyGMImTIYyq0HrTQandH4d1HqvSWR6I5KeZT0R0j0 KdFPNHZHn5qO5TzLsLyF2LzF3F5i0HpTQanZOw7DsMOhwTttTQVHQmiOZwKTkTBOQnMmicxNCcib E5EbCchoOA2HINw5BpySo5NypwmE3JyTSciaJyTZOSNicjQ4GxyG45DXfwDqKr4h8B1Oy2bs1tyI mHBRsPQexIicDk4dVdVdVf2bvzg/+qkaEifzyAmVWLkCn/Qy1B0FYqPKk/AUfA3Rkh+3FzheJs2Y ujXiJVPYSod4/P9FuT6qhmrjoIjsQkSfyJjrtuuYUz95TLZH3gIIPgE/R8L2fo5DLtO7seTd19IJ pJPikhJu2e5vtb+ppNHVu/J5pj0OhEhs/IwRH7p/wDTwehXNODGnMczzGN1DzVGLH64vlIfv2uPd 23zMxkRIkSIiDPqySSNz3/334/NvtPPtfc1nm8M6NVtLte231H8oWIQDRKSeNJGylm2bE2W1bG1L ZVsjbZbQbIltWyltIjYptW0waiSOUybE5o2VJRmUWGYUZhZRkUVGYtqJtSbVtVVX+ZSrEDS/XLBg yWSyWSysrSaTFizMzGMlktaxjMSFKZMkkllQEhJIZWEgEkmMSSEkkkgEkhjEkgSSYxjAAASSYwBJ lkAAAN3d3d3QGWAAAABlhJjGMYxJJWYMzWshWta2xjGMVjMxjMzNJGtNNa1WszWtMYxISZlEmMSS YwGZjEkmMZMmMFKZMkmWYyYxSmMZMmMYxjEt223bbd1azNucuXOHLm5tayRkjJZLKqriqqxQFqlR WVWqrVLgmq1WE4J3jR+AH5gT7RJI+t7/uI+sn2J9MzMzONat1mS23NEFAIiIRIRH3yyD7buwoLME IqShlCmU0m0k5z9PQKCi9bmZc0UgiRsVWzZdazM2diESkaJpNmZmY6zLcGZmyciTic0Dcy3BmZjZ ybQpDAbEqq2q4c2Kre5suNl1l1bmrtm2txsKQ0DSStquG7ZLlqbyXNXLeFzf2f2sm9/yfuF7Vl5p zqc7A9My3BmZmycmScycwDcy3MzNa1rZGkJNhhDAGxKaw5N1Vs0xppjS5mst1q25m26NEDBhDAaS bMNtG7ZVbNtMabLmay3Mtp8ee3v+hbyzfSTk8ScTnkD0zLcGZmbJyZJzJzANzLcGZmNnJsks5ziS IoglsGHSxCKkoZQplyk2kpmwJQ3GEMINEqVN26qVpjS4xbmW06kkk51OZJLySWSZJoLQyScySTJJ gALQAcmcnOWSTJJgALQA+WTkn0vdPMnmTnmSea5c+KXw+Dc+Kc3i6B110ABOQ2tVrVyROzm5szMz N/l8czMdSdBOA4Gnho0c4xjMy3E5O6+FuP7dW/RmW/MyB9/t2SmZSr+J3uliZSx1+BvulduqScyl hsbSSSSSU1823/2MYxjGwO3KZmDkAINiOZxDxntFpJu2pOc+j7bLLb5nck9/j3Kq1DGRc9+NaFpS lfjoNpXp1QmpSw2NpaDcibCvt0vv0ve9744CjkAMO3MgOkQFxWUpI2wlkJlLn4+Xa/d3DCUF9KSB TWRMJkW2UD3jQAAAfeAASRz9fLl1tvvJyE6B7xp337fPbMzMzMzMzMAAAAAAAAAAAAAcLQhahaAA AAAAAAAAAAAAAAAAAAAAAAPEniTJxEA+Txb5hanv5mW5C1PbMtyRKVrFrJSEylzOBQku729PR6cO 3Ou/eY7dUpmcqxFptb3fmzzvnl3G9pS6HhxdYmslq5Y655nXjHLn046XwZ4+V38TevPjr3bTlwxc mevis/t9xPP0OMUrRORPEToHiNPacesw7ns+X0+rWta2Lttta1rcHKieakhyG3p9OvQUeJjAhkZr yRCgiIipRFkIew7HoVWMzMzMO/fvo9h169e1rWtcL3ve1rW3OpHQjfraxHVRy5aOXKQyRkhKKoRo ZcCFmPxwEecj5fep/1+yY/fV8TKSIQnnHs+T4KW5cUvVkT/wf7Ek4CPglf0P2q5X8dXVfuVWX5ft 2zLdDazdAAAAAAAAAAAAAAAAAAFt3bIfWk+pjopskNEwrxtuI0O5nEVnyfofC3flzTqSH+f7tP1y pskI5jZSbGMPwmzR9pdG6KGSUSUkJJxBURBXqdPD757CyyyyyyzBOHDhw4fY4feDxn+5efWO/ieO omFRNTRVtW3IqoIfj/2j9nLs1Jn79vZeYn7voPgPB4TLa2NhobNmK2mw0Nm0xWxsNDZtMVsbDQ2b TFbGw0Nm0xWxsNDZtMVsbDQ2bTFbGw0Nm0xWxsNDZtMVsbojwCkVCMkE7nQ7HiEcHKSTY3MmsOPC 5OnlZJhgOxyq4Uwh6HYxG+uP4CJ4+ESqfiKSf6yKQsUhxydKytCaxa1WhOFEvaxKnxmeOTCNJ7fA 83FJvEbpTViMTY2flskmyOUxxkwaKJUvB4cdaLV2uNaObYWW7HZ93UlxYjeWcZM4shsvysGtpjfJ hGl3UZYbUZU098Y1Y3lMyYM5SbtNWTaERMxIDL8u8XI/U5fbjM+W9nOcJL3oRZJzbKiINAgUG9Es NTdMjeETSSSSV0sJXEJKQImsuWk223IVEwgUIORMXFDAHBFAoDFpKIxiUHDvZOX0Wxy75cZGHTY7 d9nqyplIahLA0KTuZSSSSSSaaiM5WvQrQc7qSSWBnXVOLOFKTks5BkMmOGBwEEBkgcjkVGxccALc 5YXswDKhdlK7w3Y2TgMKCdgah3saXVhEzc6EaQHQjAhlFEUQwBkHFMXKI5Gx5eTzrKyrWVeBaKfQ 8ovoyuHI44/e6qn2YtGtJrFrVa1GsTWGJdiw88lzW78tra3OW5y2LrXYa0msWtVrUd+W4TlhpOsq 7jopZhmBDPDX5rjoWlyXFp9ZEni+sNDB5jQ0aNGhoaGhgwYNDRo0YYYf44+rwvu4bK0SPsvLf25x 7r8NueNmtv6gPwOHv9UnvUr7R8JbIq1R+BxzwkktMSrctZalVVYUYS23bdtpJbW1WySSSkkkkkkk kkkpJJJJJJJJJKSSSSSSSSSSkkkkkkkkkkpJJJKxiSSSSSwkkkkkpbq3ba222t3ayqbuU3cruvN5 kgHmstvr5phbbbbberxeDwfN3bt27du3fCrw4cOHD38l94/qFFFDI0LO/rD5/LxOKPFkql9u1X4e 1+nH17aYwX17W6rbRbJnOZ99mnmrNpkymrlfZWl10O0dgI5idDodTf3IciRcAxE24D1k8x/IPiSo f+wqn7RTAX+VdtZZFKPASPI67W4bMKP1E/OJ/KOOWH2pCPM+z5norv66PcnB18XH/JB2iwnq6clW 1Vb05VTmhX1+VVsb3GDUhrGCiWdQ7aVV+b9Wl/IbEoo7m3DzIR5m6o/V4TxmxrzdPHxiDc8G2iNG mJGGMQwxhhjXLnvNzdvttIMbsNWO/KyX75jUCzWnnLdG0iyxG3i06qrzY7PMbEoo7rL6/yX0szL7 PdKlTrLLdAAA2I9pyV7Xlo4DhVqwbP4IHySCer19rxp9yVJlLUvpPdUvrMTPGal0byRZZIbWSGPF VerHq9RsSiw9BLJX119KICpV996r5a2z4yxFqLrWk696i0xZeQMc1V3Y7u47Fhh6vZeVqaNTMZmZ mrWQKAAAsgwAAttttts7myu/fRsibonaOVJOKZUS1175njK1k1DTmqvBjweA2JRRzbV5CBqQk7vG MWG7AOiO9IOSlqbdww7qtRrJcaCwcw05KruzuvcbEoozptIfrttttt93/fpmYzMZmQk1bbbYS20k 9pISPwzrnfW2cbre+ibZWAIWumta25cpBq21ULbYj1L+lU+JJ2TXbK/gs+FfdZmfVW37tfD4AAAB AMBIF7/KkrPqqzL77bK+ysyvZUHv+ONa1qZZ/fFR5nzSlS4lFST1RJ26RVJ749x7jTeSB6DRKKPd 9vE9/rDZE9ls0qxlhotpNHNyGEoo25EXE5Z4882OZHFSOLNmDImMwUWE/qqTc6OgwlFHJU5U3iTo s6ZiTKQ6XfxTBk1pNRqxDg6OgwlFHhN+Xz/S/Lbrs85sfEm+jSJpaxOa1kInOT4DGRGIHlCqJLxG 2o4vNLz5ZmZmZmZmcsbySSLQcigzUaMZnJtcRtVlg2m8wTDZnujIAcBQ6szh3LLiwtdMDyO84uKZ JKtCW7sZe2dtCSSW99712iIy7zjuq2vJFFhRFFhRFFhRFFhRFFhRFFhRFFhRFFhivNnml569vF49 QZk85MIoUGJKDig4AAUcjIyNjACgZk2hISEmUyY6TNLA0JCgqKRFKNq2sU1KbZnQmzZMTITTniHU 4L9PckfZI7r+X2Ov3QZRbFv6nobpNSpMMhQwIVD2vJ0LS6MYp/n9REndEfmP2iijceg8RsNGjRoV sK2GwwwYMGw0aNGGGHD6Dk8yT8XDZPIemuj4K+F99NWTvSp/kJ93393wSneYI95Ev4Uq2r5feAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAB3fHJ9b7tczWxs2e7pvOqNrzXFTE71bXsqvHVmObZuhu7yuU8 AAAqd3dMxnKXe1XOM7szrm2NDm71XWc74AAGUvF87u998r53m8Xi4cOHDhwrryXk5OTk4e17h6ii ih47eEeKW2223Ofu7X7G237gTDyOZIwX77+Maw1hrRrDWr5PYew0LuGXVXQ6YyDzFV878hTsl7j9 9UjwCwwWqoYjDIxH+QYjTFXYwu05ds5znDQn7U06JvTwPu/GSDbzyJJmYRHz3o4JRRc/TGk7U3Pv pI57YRn5MD0rDZS60cGRdNV6DyLDDpn26Rsh1+GCfZnXXRZEZZImOY5Eoo2TlidnJh1/Bvtejryy R16XImV9ssDjcsq4aq6ewewsMPO93oTpZTXCJ1qWjrR0vCOsxEspMRoy9cE8TsOpKKN+uJ0dcNZy DtQ544bUmb4mpXmPIsMO2Xnj3NwnRs56A7OTEeEqGMdZboEdR1JRR0VOjph6CRtrgTq8c7WQ9lqn XXPZdrcSjs1T2D1LDI4J2ovTAnRUknHA4JRR164nTfD07+QGx62lrSemr0HgsMPf6urfu/b8P9d3 9eZmGwXDXOICJN0ssLSPcpvtS88TPROeJy9XoAIknHO7zEkk85nXlJuriIgu7u+mAFETFxcSEA4N K7AokAIXYgXB8+2DwqOrzzd88zMjDIyMKvkmBKCUC8VYWiqqnPFSJJMCUEoFg0Xa8wOSYtXoa2yb HNRyyscyxizdTnY5A2xOUqcpdW20nEvK1TcuZZTzh0IQt3JU6HAoKBttBIkj4dIlELKCGBHAI5RX nSLIogCoKgTenXxmnSdzkX8CJOUR6vIfBiyPmBMUuhqJognd0LS7MYp+TmhD7x+Aoo2HgNDDDBoa GhRh0OHDGPYID95PxKeRQ0JOu6Z7az8SQh8NfP25tHbr8rbbbbaAAAAAAAAAAAAAAAAAAAD3b9lW 2V45yrmVe/33d773VdFZZZZViRZmCwwzD7T3ABIEget/Dq511fU+f1szXL5/Tj75Hysi2RbItkWy LcyKxhhhhhhhTMhisUjDIiMMiIwyIjDIiMMiIwyIjDIiMMiIwyIjDImUq+Ne6vrrar7KUfgUfYib 0HjlWz4RnJPTONH2ZUnpKIsokwonxGxKKOXGJ6eXKaPYKePMezVXfV5LVzOLIuHm5C9BzJRR+X1n 5frwzMR9dkbW2222gAfOs8VlveZned7EZ43c5jTOW7W63IkSxdW2JiSACINaw2H2Jo0Sn2BOSezY mx0E+od4+Fmpn7p0CGo80KAUKAjWzSmZSkg28wIB/QJOXte+eSdnu9/gJxVs5SoxZktL5+S/Lojv l9iynM4tBzst6dCy8pSZWTpkR+ntveSbBGayHEshlZaXg1U7rq4K7NKzHbFMZRxumA+CFBuqTgsj Fw4xEMNbpcuiRzqYstIssSeXH3bZ25d33/c+721o0a1qNRUEac5vNVMvWgIwaGMZjMDw6nglyE2Q oFTlJJJRRFVZMzM04sm4HNpqYbSyRtGORvvS5GOW7tCWoSFFijBoyUx7VVRQVFRUFQUK6FiRTJMz GoguJkEmhVPVLkmZg5loljROQ4jqUbU0SM2TjKoRaA6DHHLLjYuHHlIAB14255t7ylc5eTdtOuvV yxemcUYGAwmZI6kIlLgQbARl80ioKiI2jaM5bV1abnUHs/GJ+ioUCyJZJJnNsWlqqfgFHIfcNDRo 9DQ0NDQwYNhsNGjYww2vz1mX5/p8nj6edfg+c+dfbZfZmZme/4gAABjAAAAAAAAAAAAAGMAAAfZ9 dl7qskzLPjLxV6sVdVhRqQNlbDZKNjCyt3d1cP0NyyyyyxFlnzYLCzD1PdvtPhi7N+UwkPAwPIkn istuIphatttDAwlZMPoD9o+ISvxJXswjyxI0KFQ6dE+CI6qTkWMWZ42qvI60dHPpd12F1m1M13ND mmqybRsmJJqjjgyauTiW61G1k5cJ9NE51DPlcJnLFpOVkxTEshbJvwnTtsRzonOjnVqTnwZGlM1L LMRaDDkmCOLI3pbJvZikzMbm6b7cK15IKDAmGidipSSmJhkUaRWb2cIKJRwJs9Q5J045c3PnU2Km 5YpQwo1ztck29XNz45Sbyp1SzNY0lDQoDjsYxuzvO/GDBgx45Ntaq17Rms3kZcooI5nWHrFtQA9L l5zMz1Z1XSx6m7sq0piocbA4iBxEdgvgw8IiUERGHCuGGnbssLOGR5GheqNExohjkaLEJFFao8oB ILEJE9ArIYiTHW3lTZMYPVcuXfuzK7BWZ4BmZ3jLOwWWeS522RDaV1zwhLidbgSDmbSVcbAjgI8y 7+nSqjrrvevYXaea71O9Xebd5zjmfgRJ5h8znMPF6gi4rWgRyR3Umh8hhh6GDBgwYNDDDRhhh0QS PcSKRB5eXpyfEXnvcSSSPbWOHm2bfJd27du23Wbt27twu/Cijny1v08tvW7wkpzPAaHyHyHybpy+ UnHwth5CsWYVCnXz35J3nvVynNYnMzCLhxwnPnxvXFkmSWTLM2LKYQw44TfXLG8TUslwycCwaMDC M7phAhGICRG4RdFQQhRwiwxGpHPknGkgLZsKmBNtkzSWjWaTlk2iqjbZN9ptCryJyphPVvt5vi+r aKr4XE/c8OBzhy+3dzPHq006cIDkGREVjBy1kKSJQkkkpOwBUGdSmJmXexUZFkDIIcGzIkI6ci2V hpw27LC44Z2Nig6oEt5GFJyijqi5uF5C8ytnIRRMRNnJ4LwMMhxUOGBXCA0Ao3zuzyTgeSCiGDc+ cS550gN8OBrIZAoGQQwLvOiOI5lD2CjveFicx8BhhsYMGDBg0MMNGGGHfr3338Z3ss93bqapIfQy +ZhxlwyeHh7zw+JZZZZZZZZZZZ6mHnt3Pn+f3XWfP6/MmTJeq99fdVfPMVMEAClBDpQp8R7hgj3g igijli2HBo9Uea9/V9cy0tZ9Aalxdl7Hlw2m5UsVeAsMk9eSZpKljqJqFzOCyuLt2XOrZlppm1Y2 ZZcJ+ovuv17bb9fR1X5p94PxVEnzff+zMuY/NDu8FVZLJallip4+WaipSWxaljXtx6bTKeglKJcs cY3uOM2tutsa1JJSWkZcBSRn7G/HGybylBbIKqrwxdr9vr9v1762+zd8uN+V5F5jpvhww+7AHIOI Fy4rlJJIo0hQTEQJ033Upq6qqrkBUTFRMQSAOCepHQAAUmHOg9Wc52xlRsWHYzuYITmea11E3Tap NOThamqVonBC2Z7TVouppUsWmLHixFhLq6nC4XhAXVFhFgoQMwmIIiJjkOOUAs0LyUkkkmB4DaEn yy52+xhHARExSUSEgoG5ioogOyBHnQJxp1yRgZHTOSOchH2oWJ9N2QQ5D7hhhsYMGDBg0MMNGGGH g699/KPFvy8W+bo+xIiaaeLm6fEsssssssssss9DCDQiz0095Pzj9jW9y3r9o5jucjsexPt0JHfn x7bavcSwYWhzM2+Pjv2dtQDba2BbEW3XHJmnFnXbt787Rmu61cbSbi3KN7u3XU0abHZZyMNpsG8z FrkKictm2pasVLF3ez27OT06+/6NuPQvLjDNzvXPUXd2Xw4VBoFIBVDkabknLLcMzCzU5TeNo2kb SKNLogSILZIOjO97zMDsaasg007kMIORJSlkNBKJk4gIiLCe63NUjJk8hUixZCCQA4HYcOHEwBqQ 4EAjEJjzpvVYec0I8oSETDSiQmBuJSJF5AR2dbdU2jaNpG0jK4R5IexNjhUcD3DDD0MGDBgwaGGG jDDDb5eG/mzwaeFLVsTZvH2/X9mLbbbh+limLaU6zbt9ljz/RVVcPAWTYUpYps2ttt2GobQttqyK 7vJ7W7zfRZZZZZZZZZZZph7vVxBz7mpTqa+SsAR1MO7wSVVltzEFEnzQhHzcfGSyzkLMV2zC00K9 WshbNCyXMSli2PMjRSUzRSbVJnzwccIZNiyl7vHjm5ccLXIFZWwmYwQpQoFCCTR0MFHTx9GKztcV rI1Txa42ZiIOkcufElcpc3TnpatW203c5JMUnRbEUmZgybVebMzM5TiZNTSNJpLCUJGgwIRcuUab zmtMoqihEXWFcKQRVOyG2yG6AGETAESAUFrhwszYGaEeQznfDwSRJ0UxoB5pCio7GRUU0kBIYF7m QbsBokI6VCSkECixIVU5hykJz0ImaqWEUEdAgKghEMiiaXOEYepEnoOsnqnHoH0NTAuFOhur2uYk e1RGhzHzGGHQwYMGDBoYYaMMMNkCec8y0rfvr219EYSMos+RZZZZZZ3DDDDC8IK3Md3mLeF3eXvv gVbhcLB3nnEJC6AARbwjf1tnXzYnYFcb4sSqS0ttrx31OXRmZm7jaq22UEHXwuc8Zu7m9+OtVtLl ZKz4MRDEVFKIVONtIhxEwpmEBIoCER9AyunnnyzdN3TTfmk315TktxEFZPTvCQa0OwhkY8pjbmZm ZmZUbSkmIgSDpCCYDdtKZma5kVGxsOC0FoLxIMKo1otYJ1F2N1rTqKKqKCh6uDEkcUJVVFDbGV1A jgAg5dy5xCOncpyFEycrsakJlimLC+gCio2Mi4odiB9JgY+pJJScHZsYtDkJKIuEnEpANvZi2lmp AQ9VOBwJwOBxPwgiIhGHVXuKNhhhh6DBgwwYNDDDQww+Tl8pB+J36ZJIgccjpOplGNi+1HQvk6Ur Z0tMyYvina2dLQx206qstZLly+k2aL6G09a1jOBja1rLqnlZvd08602285yZwPI3GqVFJsobTapu SmynrWM3qsmbZyaqrLEZ0UVkqqq6Y22qOtb3G75ucy75Tec54G0eS4Hd2Eez5fofncICIjj5CIIO TfOOdrcW1yFzKzQdHfLVYvGZM5q4jkmZyr8ICDe8m57TdN9rlcutpvfPCbvLqIgzcWdzOauUcdrJ 6EUEdAjoEcsst0YGK+hmaowMyYGUZxgoyPFGTJkoo0MoooooZqIgC1gixAOINRECWiIURAT3e1fe 7u7u7u7u7u7u7u7u1O7tbuajNKpU3VlZSpsybPFa1UytRELFqqm23VWpqVKlSpUqWJQNt1lzjGta rWsY1rVa07IcOHDiooqiZLuMGGXvVVV6vm9YNKCbPGqerkKDhHYGzCMI5B2BZhGEZBkC5c5m4twu eGbuXPTO2V3H2+dvjwfO5fN7c92ud2+dvjwfO5fN7c92ud2+dvjwfO5fN7i3l93l8eD53L5vW8T6 3ddlJJcnjXIiBN126iIip687jyn3cyILuIiIJyIEBHAQQwAhhEqnu7WVERGgX0CQoNADgVAdkSEI TCgQAMJXHvcfRIQhQbuvdfQzNccca1z3Wqq8izZLVmFMFFFHS+h0uVZ3BABUGzV8npu7kbi4XxS+ 3w7O2t17emzt8E1pytzc7w2dudSR3YiIOb113Tk7fRNacrc3O8Nnb6CMUyphArYBVTcpI5oF1ett ttyRHKIfC3ETrvcNZcKLRUZjMVFRUOHDhw4cOHDhw4cOHDhw4cOHDhw4Zqk1KlQ4NQMgUFEFTzq8 k2TzTMTzmNV5zWq8ya09JtPSbL0npN6J4q8TxV4my7xmBVBUGoMwVEZFAJWxiZmazU09UFIQgmCd mebzm21fauclZPL5zuZy773m7rzMt9IAA4AELYcF8y+bnWODiI5znMvnNwObxvmczMzMziPPQMnu d0v2BERAHuiIggSpbNmwlpUaGkJ8EqrSlGE8eu23Sorc6Il6j4572VrK67/H7q494rRXzomcCWyW MuCQMwwgMYiqvqZWbnVtqMNYZvXx66y6Z1JJOIDZiImIilzmnLCcXDlqYiYmKSJImIiJlxhJFkJR KFPQznrgelNF4m9UUUli9poyVV726hoYjGKoprOM4KawPSd3NNMZehZxmTJkzpNjL6G09a1jOBja 1rLqnlZvd08602285zd3tVGIxnQzMXvSpKsS7MGFDFoZLsyrTIMaQ9CZNE0ymMYxMqHpjdizLYmg Y04ssDEUKoliZItBQ4Tq8yymmYc1Dsm8qcXbq1ratalar2uhTExuPnVfFqtVqlK1atW+LFilLtu1 StTjTWqqTy8VK1ONNYqlRSOWn1SpUq+t5bUokU4qdCzrd4uOhZjd2qqhC7MvVSWU6WVqy126tbur erN2VuastGbJ3NrqlSpRMzcwk7kdq7ux8kvF3ds3ZMxNmZJMp8UpYpaHqriKdJu1NLrulTtTaHcm 7LlSpUrskrqSVW25KmnV8bVrs46zG1iaeY321XaW9XFiqVidq1a19WLFMKlSapTbTWKrV5lKlSm2 msVUjMk4uW1KlSt63lm9T1ZdWud1a1culmWsjm5q3NW6iVFaq6pUqUTMzKulPF1Mpd1VS7dWqdqe q3cpu1NIm5O3NmzMqVckzvcSSnMUoNaDWg1oNaDWg1oNaDWg1oNaDWg1oNaDWgt3TveNa0GtAGtD cMAwAMAwwDAAwDDAMADAMMAwAMAwwDAAwDDAMADAMMAwAMAwwDAAwHrWtaDWgSSlSkuAPmrnJ6r5 itWq7atWq7atWq7atWqKXLm0TShpuJTUpSuq/YB6kAIAp+hzvl9vHTdy3Vd3a3zeP00XSvAivJCN 88vnL755nSBPPO5XlK6PPC1GCNEUIYjwRQihFCMlFxEUIyIYjRWp2A1S2WPJxdXi8qb8zE6cqVw2 3XgWg5PiFaV+Taljnkqca2N474pxqnq8tXOqsJ0I8CH55HdxSpUqUwbxSl1rwS4rV+Ym7QqWW5WJ 3SpOWomYlSJSs5S1Wq8tWrWriyrU41jxHLUzCEvFktat7xczVqfKVJ3SpbXWec87qvTK6yvTKzLt 8dwRbaRbbbW7aPXAOO7d20N20A3bR11m7BFtpFtttpFtpBFtpFAbtobtu7aG7aAbtobsIttItttt IttIIttIttttIttIIttIttttIttIJobtoBu2j15AAAAAAAAAAOdd27tobtoBu2jeeLxOAeAHWh56 B4B2HfQc8A4D0G+A5ZvgN9A9A9A9A8g8A9A9gegWbY9A9BzoOegeg68Bz0HNC9A9BwG6GY9g30HM zyDQegegegeg7dt9cbzi2mpbVU1LaqmpbVU1LaqmpbVU1Laqmp7HdlTMU5UzDcqZhuVLfesZZxcx CFlq96u2cVzeTmvMnZT2nSqqdKqp0qqilMrXeO3mFZWPHmFZWPHmFZWPHmFZWPM8eL3vfjE1ubia 3NxNbm4nXjzVVVVVVVVVXvPNVe53fS83Ety8zN6tvp21KlpJNtSp7j1k8ni6PvLePec4uLK6093n VrJalSpUqVKlSpUp5q3dzVrolcn0iCIDcIFBEaxjdZez23T1Wb5tZ61erulmta05i5zbq5meXznc b1rbno9rrmUkrWLFW2rVqu2rVqppUofaVKlRSpUjtKlSrtq1arbVq1TpRSeUmqVTSpRwpUqRLUNO WmobhpoppqHlKlSrtq1aqopUs5aatVy1atVtq1arlq1ae0qXFXLVq1XbVq1TpRSfKTVK/QI74qUW r5J1eKOprK1eLFuYo6suOKlQk11cXVOK1nLVq06pUu91RhixXcWnVqJmJWKZwtYqUAiJe3t73u7t 3eAi4Q4DRDvWHht61rGMcfP9pER2ICDoQRERGgDjaQVctuM8+WcY53tbNVgIuEUBGQI0XZHYuhHQ vHYvIuhegu5eiNycpIOUkXbM6k5bdKTlzwnUmwmICQhESBCiIgAm4tFMrYc6illujEYou83LQQ0E PCLIcCgkg0jhGEYRkFzeJ6B6U815rznnN1V0mycTMTqY1XlNarzJrT0m09JsvSek3onirxPFXibL vPE3nPOeU8TqdTxZkM3lJ72JLOTMq4nNwZ3nartvt21aLesa6Szqkk8gOyOiOqOqKc41Gdekoyt5 h9Xq7Pnc43vJV0WkWoFaYUpMGZCZH0SVBKRkEJ7cIkMEgsS+Xbx7eGta1rrrrnOdcPU9bxbykqPO VlEYDUDKq529L2opa0lTWpLTKVpqqNNQHwxQ2lLgmlc0HBMoZWlW1K1WSjhaRrVloawUHLJAmsCH LDiYRXLJcTBUuWHEylcsOJhBqnFJyjVVtJMTFGUquSrGxkMlVYr2/s2NjY2NqKKMKKKKKKKKKKKK KKSiiiiiooooooooooooooooooooqKKKKKK2Nj/yIiL71JgMCwH6kEP9npZV+FrMmfsyPL8/x+mb G/DfbJn+mRvB+NSIP/a8X5KlB+DyRwv+abX/n5MKRCFy5jamL63G2MF88xVqcbMuvSD2z/yWT/T/ mqW3/0xdXbbZLLbKs2kxjbNWyJP4LH5iP5l8/+KkuxR/96S1V/e8En93+NRE/2O8oTbxgP97U/ca p/oX87+dkZGLFll/vf7qiJ/6+Oy7rGMssY/2C/xVdj/1Hk4UBeVRE/1eMkO0T8H9SpUMJhhMGMTD QH8L/lURP41XpeK8jJjXkXYiX//mqSXuYpw/01ET/C/4nJ9v+HsVVVX/A9BxTtGe9/uf9r7WRke8 XC4XA4uLg/5nS6WMZZYx0L2e6oifCPzqLzvY7x7O7JKr36oi/FSQWptkcfZHZPM1O6r9dRE9KfbJ /sOw9ir/LL3KvY8vZUXZ+p9LzfAoTobvPHZ7KiJ1H32//zsp+zXk9z7PyZ2fQhV+odnzl2ld6iJ/ ZwePjeSn+H0fvUu4pSftmJRxVyoif4/M9/UfuKE+n63un+R+U9qx+L7lQqGCYTCYGJiYOXFR/cB+ o5Qq9CgL8H5Kuqr3ZD1XqsYyyxj1F2eIoNlRXlURPX7Y+gH7Xy+Xz/xng/L4EHtU6qcqInlv0/Kc Vff9r3Kvsdh72vOfrPw6FJX7BSkwmJRqSvl85w+R/7HL32TS/6y/vqf6SVDKpOUQ/7NwlQ0pOYU/ cpPBFsMGw2TZWz9i45XDmtyXDmjlY5rlY5riGOa5GrVq1auOBmotgtiaatotYhnC4ssssssWLRo1 atuOHDk4VxznNsjI0aMYyTkyXFzjjGMYxjVcZKwTCYwmExmZiMRRRYZOWuScXLi4sssmTDDnOc5z nJMctZGuc22wYMMNVXHK3JOC4cHBkyaFy5WsRuNjY2oZpynHGcFuc1bVtsGMY1Llpy4wuKjlq5Tl qHBYWBgYrlgHKc0OJU5w4NRxajgrCxNXK0twHAarnK3I3Bq4qcMJrRy5RuI4ssspc42bW04s44Lj mtacrOOLiyyxc4zWacrOXEcWWWi5cZrYmrkrONamuCuCyXLk5Ock3BcFoOOOA1pzhNyoOVzBuUOW ta1iZmnDS4rWta1rWta1rWVmacauWta1rWslzkzTlrWta1rWsmnGnLWta1rWtYxpMmjVjGGMYxYx jQyc1cGMWMcsnEyy1aytjOOHKZXOcMxrMNCVzltca5ym5szDimnNDchyGGHHE5MsZIBZWWZMZJkz CYKJmDBzg4UtWaaMZpo0aNGpzk4DAwMDOYq4cxcZQDAGUBcBMAygsxMTJiVWJkwUpLhWJcTEzLiy 4sWsowsXCxRwDkN0dsIBxO6Ef70I4X/hf4s/h/ifu27vM5wACbm6/PVn8rxiSUf15ZjFVUYYpOIa kf5E3JuaNedDFV0dHpf6y+Bf0/1o0xBpkV25/mPZHHDkf6wj+498Y0f3Dk/uhuVjcq7n3FAPf4ed rH847smDGTHWtGLbstzFRttlVosb2ZZeWLMsslnm8nU3UEEEEEZjM/zp/yVycMibqxjJWMlcjJS6 1rRSzRxTJhsWmTDYWjJhlyxra01prLWsmmtMWmuNJyarTI0ymmqaYmmtNWWsaNNd6qdwWBgblXLG MmMky6qrqIiIiIiIiIiZVzlZdVnVYpTIEEIECRoeBwGH9EVHY4VMrSqVKVKVVVVVVVU9bNs5N5ed RXPWReM1rRZU0yx1NTZqxqNTY1ZGo0WKvTXJzhyaaaabxrMvPXUxpqaYWmq0yNNU00njXJzg2to5 Naa01pkxi01prTWi8g71YMGPB6nXldgG5VVe3JJJJJJJJJJKqqqqqqqDm2Os6TUl2oSYMsNUPaaM 4CcUl9V9N9F+07fhL/b/+eElV/vokfnL/z4KhyVUq4YxixjGVSRxJNiU0qToJHjolQ/40lEv5E+Y /b4afd/8zH+E/l/RjGW/wXNH6XJ/c9Hd/n/HxPE+k+Mf2WPLsSGD9B9vx6/R2iP08XjXGr/BHpPc hEqRH0HzFvYi5cufA1jBgwYMH3T6D6WsturZRcuYHlYwYMFzAxja2jwKk333tg5yFlGMSfp/wSSS SSSSQiiqM9X7Fy4z1RRR6HtNuyyyyyjmc2ruyGMYzOMGDBgwMY2r+vc+VQE1lns7f+U9rz9b8pJ6 vhHtptastkq34Hzc+VoAAAAAAAAAAAAAAAAAAQAAgAAAAAAAAAAAAAAAArm5XmvyWZl5/a9op+tE XUG6Ij1RYNEHL9UHY1Gv9JI27l/adO71pJIAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP2+8 XnLvL0z5fTx9t+i58r2jtEebaINo8IIOxyvBWTQ8d77+ZIcIDUZBQOsfV1cvVp9f9nbz8O9PjKqJ 3QLVRS2VVTMqTYRVkK1SVmlCPjq+xaHx/TjovP3u/3eu3bsqqS8PuCEYYGGGCEWF2XdpZiWYZmJW czDMxLdSzDMxKxh0AAEB/uPA9EtOmXNtcYXPyboe1Vf0ko4f90/2kB7faV7fal7vclmGZiVUVVJZ iWYZmJeh6B8jsHiOSSJz5Z/7f6/U5EdEVY54TjnhPVVELhd/UPqyj7lopiUaRIn/qDyOiqrJJ958 D7zu9qxM8nJBzVXf/Cbzg3bqqlVVKqqqqxiHICOEkOGx5nJtj93h74h3Nogjz3nr8filvtSzDMxK qKqksxLMMzEpAMIPcRFJIpR3a+ykRt0g92OrfuuKxx0L90yAtSSq8EvhgnLG/hvVVFVSXsPUQjDA wwwQiwuy7tLMSzDMxKy7Lu0sxLMMzErMAPeBDggII9AjwImAiTwCKIdEERAHnh55aXfEswzMSqiq pLMSzDMxL3wXZd2lupZhmYlVFVdLOUs5M5ykwiCIgg6c95ICIjX6+lj6vOS3Emv6+ttsnAl8Jqxq 5EutttsD0zhJL6C9nPkq5XOOe4k8SqV2gvZxIXF9pauuVfbfQjzfT5EEx73WSQG8kPv9RXbvfj1k eQ6xSbTPhElgmxAPN6Bj1ZtpSe74/gh3PPtCR4uZ6a9bVtQ9AcvH7CDnB/9oiSCL+s5cnqi1Hmb7 Wy14Bzf7PMiSf8d2LPH4Z/t+9tqf1tsjVlstP9bHOpvTe9oh6PqQyfXSNUH3n2w93ySSnDnO1DYk nOj5eu02sxPxLkkSE1X1jX02sTczJ0+2PvaRBOiPu8yLB9VSZx9xMB04wiPHg5ASffrZz4eyJwm0 JKK60kScoplnByzyfQUdvYg5eTqDyTwfLbKnlyiDtFeKC/Pd2TKqvjWoiIiIiIj9Fd2EzeI5cSWf n+Hxa7a1rpr8Gvm25Vyr3V+WrlXKvdXuqq91e6vdXGuO6vG6PDw7a127Hbt21rO/G3jdhPBPBPBM JhOydkwmE7J2QTsnZOyYTHXjVt8XxfFVer1ber1equXR/D/F2Hzklkn7PoTmPGnDkjdFSFSGExGC kUjBhMRhlZnlyWu7r42Gk0pa6KcmsLJ6pJOhObicudhjlSBZUq04D1qQn5pH4qkE1ObfhcXFxcXr 8Wz2vkxjGMY4le0xepwnsog/LAf9eE9uog2HadzsiQbPaTzJJ1MJ5EA9097Znx9lUvUbqXJ60PVJ VdsWSxvgAAdc5PE51OTnJ+LnmTlsnJ7idFJ+6JJOwV+E5y09n1zL7Lk/TTyff5d3m7z8PxLJKSVg pSlEMlKUQXxzM/JTPN9gAAD6qszJJ7pl6AAAAAFkc5zY2PmYD62lFFR4N2HNSRH7hZc8AAAAAAH4 7PFnsJX6HkStXquxZF+Igfn9HyqQdfYMMR16vXol5E8/gSvi5SumhVvueg5T7p4J/L7fWpPZDz7k 1fu/BHPt5xRJJNMUqlVHsCFZJJMzJYX5r51WSuXgYAYbW22230JC+D2FXtdJvcjte8vx0H5/xc63 44tvRV5Hz+R6chcqSW1Vnw1tZZfi+AAAHiq9rMz51fuV872GB1ysucPNeZJe+llWySSSkkpJJJcu hgB1mebHV3uSSgUewevauQi5gFTkPeEk/SeZ13aNGRI+1ZCB0RT8rbfRtTY2N/Nvr6ufXlU9azjd MPjZs5iSI/V8b4sy3GLlzNNMHlvNjYnHJuq2220nwDd+T2JyR7k58/VJIQTZHZ7T5uY9R+Q6kSHm PIHJJEsgHqWjqhUxGSiezFIkzWtIlqSaJsFPq52/8N/E8R3bwJtpbkhNGx2PMUw+13iTu7wVlXKu fpzg5zq1FX0cqUXDEnYqUnFOpwuuvgG5zlUVzv1+X5M2AAddpWXWWV9VZbti4sys8s6Vw4LqiLeZ PM6nQldTnJKrHmyzNwqc8FjlKh2ccM0uqjnYd+04eC/o/o/euyvK2LDyHEeSeRtNsD0nA8LzeaaW lGCUYKJgYYTEdEjgHc69etzN0Ekx5OISdp/7Ocb2ltturlysVwiXFaWj8h50U9FVZVlWVrNZrNZr OHNltRmFkMzTGYTBiwyUyWVexKspwpjiKzhnFS4OEyxMsWDiphcSZYrGUqnZ17PKZqpezW11Nure k5gYhh7zB1K9P0OzzO49F0ZeE8qWSWkST4Ugk/Hl8cIKyYTMmZOs9Pgf1VbfLwu9fDzf6m02SSu2 1sKEomoZPEDsSvJfTGM+4upPCdyfkZP1ZPId/489VLyypcLl23p2Jz5DXlqnPlzpqCB5HieApTsR so7OlM+VlKxmUAAABWZ+f1n0pFI8j7jkvv9NvSrIyyi9WVxMoWTLjipcVGpHxBIVHmKBNJnBGgHJ nvA/ozRl+b8wGFFYGUBZIfiqzz+3WPcb9FcydQ8seGHe1aO6+ojMHqS2kJIiAigmdlxv9ftbbSXe bxyhtKLKJ9LCd5zttt6Rpz8O8nBIGZH8ybt4dbbeVyW2i+FOe85E324Tr/B4uROEkToQicu5P6te ql2VYqlsOX7yTnx8rx28eHt3tJ9RGTt7DEk8o8IhQTp28t3HeeyOckPaDzN+OWiSZLZ0sf1+flB3 TnEe2JtI77EoHiS6cDhrnJwi+jwkxukRezcZIkg7vFgYnpvFVK10sjqjl17RAwjHZbkRGuqrE8QD 25BBLZpQaiLIrdQns6yRza5Lw6yH0tgpSlPAbjc9bkXx5y5m85xY40yCvnt0oy5MMBYJIYECgywh PlOL/iHG1JJJJJbYS5wAOcP3vd4OWVmfSvVWZvM8hRW2q3Yz2My1XhjoqQ4ayTvvkZPCZ7TUgRuT k4mrhlzg1oSQYdUaJXqTSdkmHzdXkB1/+M8li8weVMpkKtJVaXhU6cbTHm9gPb6eO8kdtSMzMzNO 5qnuqSEm9iOmnuTx2IjJnNpZawT4bCV2UquePpldFX0CoeOnz7ePPkvOznsOTUqSXsDvpI7hUNth 4uj2DwK8iD2E9ASHH9/j1sMCQ9QK58PavDvK5UefQuh8icB4y6MxMnOlcYVDoeSopgj37SISGy+Y NhRSjuUYYKbyEDxB7CPJ+Ow8shEnZ1dZ3kRB4kk+uIfqf+P7TkiIdNz8f3X9mv33V6ifD5JfJ6Uk J5SDv6yQ8NkHmmk4Sj6vK5noOVOPuBPNV9AuAhyt1SbZdzwh1nuaeybOpoR752EdGiEQebHlxmT4 SQ2StgiTjRr5XlQ6e2zHNVVXiMShR9bynzfsJ2OskrKSSSSkkpJJI0lqfW6Dyj3KTgiS+PnhDD3T p6r7dW227GMSuTZb5zJ9afW0xmZqHQTo49eJd/Te+VVVU2lN3V1VVWQHqID1PCICI9fiXr3q144j llXropXPPk6oYkr2VRXYQft6pK87x2dhmz3DuZhZWFmFmFmFmFmFmFmFmKlc6nydpSo3ijyqJxJJ v4uCI9SNu8jTIesg/F3Jr+pfh8YSf0+ey11Gd2PTaevt/akRDiOHqBrj19ySWZeUQ98efDx1J3e6 IeCaRIoqrzPKr0pwcnbqisqXp7q2JhKSOdGEdmEniuj8SsKOwidxmBEnZkGCM99HdG7h6fv1Ifk1 fxxpb9uNrbpNVklgkk5k2yR7JJpMQRB+BHq9aXctyRliMFZKj83RxW103WRUzIf8P0J8hJKUfIep KfCHYYoqiqKozDMMwzDMM+kV+LuYoaYKapkZsrg+t1IOtsSZGMr3fC7vdXtfXbV7WLM+/wAAB8uV c4AAB8vazHt6sqv3MzJ5DlX4KS+9n6PV0zO56YPZVelieqNHie++EcZ5/Fp8X8uOLbdMMcmTeFXM VqWYbtbZZjBthtLqzFbZmIczUQ1X8tEbdwf+jnq8jYbpPYIqNz6z7B0FjFdeyzf0cc9OfJ8iJUuV X+1K0kp9xJvEa9zu8fHn1fdtttbbbbbbwSEj9h8gkn2tVfNx9eOf8norx9cqmfLLc9f89/7//ecv yteZon5fj9YA2222331e1H3iZH1FK+j9XHrfbB9JMdX0top9g1VfrsFcDEzKlmWPYWMsYaU5kzNf q7dR01Oz7yVlDjhK9zoujJYyHapUJ39jlXbc/lOle1f0Klfpx+wdnq81Iee99pS6LsKh3J4ujod8 qK7+JHl49fYTwLDDVho9/8V8qjt1enqTqkUeHQ7FfvxOxUbt3Lqgh4tJxJv0wUdHgGQdBwew77og nuJH6XTbGZjMxmMZu286UyzMZV7doiIiIjC2WpxLCy1EsyWc661BBBBAvz1fFVV6q/Uq+6rlXKvm r8auVca9mvZrWvZr2a9muNcd1eF48dndV11Ouurd68eAeDweDDCyTur3VmVcq91e6qr3V7q91cq5 W9eNW3L4virrt2O3btrXu/eWfiqsrNz3yk+qZswfwH8R/EfzHkdh5jcbjoe0bDDgwdBsYSnIwpzO g6DoaKcjgpwMG42MORSmFMKf7TmNxuOY/mP9w/yH8x/uHQdB0BgMBgMBgMBgMBgMKAoCg5jmOZzK cjmKOg6DsHY8AZDIZDIcBwHAcBuHAMGDBgwYMGDBgwYUFBQUFBQUFAUAwOgx4jxHiNDcepjyPJPZ ex2G45DsPMeY8x5jzHQdB0HQdB0AwGAwGAwGDBByBgMBgMBgMGCCgGBsAwGAwGAwKAYDAYDAYDAY DAYDAYDAYOY5jmOY5jmOY7DwHcp4jQ7juPAeA8ZPIchy5jApKFKCgoKDoHQOgdA6B0BgwYMGDBgw YMGDCgoKCgoKCg6BuHawbhuHAcBwHAcBwHAMGDBgwYMGDBgwYcBQUFBQUFBwG8IF3kaILhLMygAi gKwAIoCsyVmW1ZtZoAigKwAIoCpUrAAigKwAIoCrFWbVbWbWbZfS+ur+1B+IXyR3SD6uXd+1tf63 ifIFbuIzEkn7zaGnjIQNJ8xyTef8MRLalE8nYcv7f9M56Owvhe67HeTcZiMpOSSV0TkJsf7EfWde ORwI96pXS9F0MpI9vaq/sVYTZ6m54imCmCmCmCmCmCmCmCmCmCmCmCmCmCmCmCmCmCmCmCmCmCmC mCmCmCmCmCmCmCmCmCmCmCmCmCmCmCmEpgpgpgphTBTBTBTBTBTBTBTBTBTBTBTBTBTDAiT82wct xEex9uCOkA2OCT1/VD7KfYxmttNto2aYxYq20pSxVtvvE6/aIB8BwMMMMYYvrfHhe7ypZiv3oqPz R6feAfpP0nM+HvaBhwnI3PdLpe5x/UWPke9bVmmw2zNM2HpU/M+Mz1cvdHkd1S+0P45fqFJEUpLT RMRtO5fE6HTZXI7nSm4eIoUbzsfIpu+5+bkfApTYbySUcxQooZOgHtwnYDzf0/v8YtRf8cYsZUzb H+POJPwUmM8UkSe6eHj7ZhJzJ4o3H/R5T02L0xFVbCXU2ivkKhr9LVfmr8c9h6kPyxC9fPwB5FgO h8TwafVZJID4VlkHTbIkHITgbamkhuoOsUNzt1nHhNv5226P/pXyf7eJos84jzKiT1SojLQUkeG8 3LPl8btc+Kwk8miNM879artHz7y/t+3ld/Tx5Kj0VeZOKl159+X7ON23waEkgjfUkuw7Bh8CI8/K ue4k8lKfJW8SKjT4DDXNJho2GOSKR/TqX69/Ub6D28VFf6m8epzvU2OsORKk5pwJ7wSHsjbWiJYN QhpqQTY2mDVs2mGyZKDaltVLZPWBB9j9B5mhTcaNCnrg0KeYphRSUYKMDkSJgRu8A8vW3l7rzyOy QkwaFD0eLn7uCRPfQYGRBtolfHc0iQ/utq/9s9vf2jsO4ofD7xpEE5bg5886/B7z76RR/V06OYvT +Cl4sqK7MeXPZ6vporn5RHnzZ71LalK9rz8qROgxfdLCocHtg8VXh4eUkRE0oHF+Ouz37ftcH9za 3OT/DZt7VW2lUrlz6dWIk/mNiI6bz9xImc5JmdfwAAAAAAHfx6O5fdYq4szObtLnRiWZBnHN3d3d 3QJE9zZOZtuAFoAtAFoAtAFoDk4+W++2/C/Pfarrt2O3btrXkfmFstl5l5kl5hojREiJFiSSWYZm JVRVUlWWkrVq1KlatUqVq1JatWqVKMSnMMykqoqqWRF2XVpWbsypWrUlq1apUowWgR0I6jwDuG4f UHyGB2FFH2jIiXXDyefi27hdKti4xxx3JG56W22222gAAAAAAABk5JyZOXk7c5Jz6c5znP0JJ9BH 3Q1B8adxA+s+CrFWHpzdfN2Pm+j6Na+T6mteXkeXl5a3vu776OurqqSu1aStWrUqVq1SpWrUlq1a pU3Zd1bts222t+70+NdpcPI5N0ST3FJIlWIr9jFZlU7JhLvg7LonIcmtcTFxIw4nCuVcTgE9nZJ9 apa2XvL8Rx1GaWI+ZnJwuI3/J+r9nwqqH3K8CocE8EWSHt+9yvwvHmT2zmfRMPPxkHHq7/CKeKs3 w+A+9+Dy1r8T7mteXkeXl5a3vu77pKqKqkqoqqSsDVqJUrVqS1atUqbs332t22bbbW844JEkRyA8 5/1u/pJh97IyWn6KPu2+zX+SWuGQ/UxlktlfsS19yqqsxLNSfrmTt19lu5/T/O3Y/+WzlzXD+bSs xnV1r934Pq231rWoxc5JxXEVfwqujl3oT+tP4D8x7i7OJWwkln2oiSTqMd/wZ88zWWs/9/PWy7Lv ct9+cXXsjxyvT8v79m79UEHrPyEnkUh7PzSSaX4va6DvP1KY4q4LC5HgvAvO8PtKXYypauUn3J0X f8dP2fmSQ1cz8WpPy6su4Jm3HfRm++fTt2qjVHaMxzwkJ00KFkdDspUaSSeiPm/NCPCnn+Z/Ezw8 balUF9riy1PvfZ/p9m+7i/bZ7xIsviRGJYnVWkZVi5v0EgAA/TffLnBIAAAAEgAAAAAAAAAEgAAA AAAANs6q3KD7iyUPqocX1qy7HkKk4tKPqNsJokie5RsVsTAMvIML6QYvPmqO/aHkThPoah5CXoEr CYKvLo7qqT6cU5l9XsJAAB4vqrnBIAAAAEgAAAAAA9+6AAAkAQgAAAAAcs8VZ7Sq8kEAR70evPdE WkkkkloBHoQD8nxtttvMzMzMzMzJzMwAAeu854ttttt8QCLIB5ONtttttttttshtzMzMzMzOZmeX PyoL38HTXzR4hHhQet8UnEsD8TDwe3VeY/9+C6vUCdpTBGhHeIKPYI8HNPT0MROSiegUrKr40szq xYAB6raVtfHM5OfDnJJ58vkAAFmYwAAW8yl5l6OBXzWE+gjFPVK+CSQ9tu/8ObOvZ2+HW7QktrYz cUnoSS1VdsJwuxKOyujtpUluKtu3OSQdt25cnXhK5KrsZlllldbusM75tuWVtv2/IAAbbuOpO0GX lzGhwSuqnJVGVIA6olgP+MiQGRBBEx2lamMXs2YiCyyn0VUcwQ32lsYyNhNUYYJKsQxlDCET99Er A9nI9ufEotlp5u3eThY7iV5+wk7ds4lMcrRq73RTq1IVzbBS4wcR6Mzl08n/JV4o/29p3R4hBnD2 d6XZVs0tTS2p7bIzvyF12FyDuJ7aEhyV8x7zzST2ticSznfNOanJg+XmS/pXTkjlPKVFSy+OlR1i Ck+CgsOMHsEx6XznCTRVCY7t0lYTMjuVR/w0/n/Zttt2PFUD2RfD5n0fMsHZFXkKq01TSKOxv9G+ XKV7lS+j2QPi98q4NXDtKujJcBIe6o67UmVhpBRzphnAzbacaRwy2oldm5OxJ+2K4Er8jMdd6kp0 fS3LpXKvFwdHHUcLHcpukcQcHJ7PjaUH6+ctnYSpOyLV6nj8n3/WfflKgtKDrgcqe3lxTTl/b1zK fxUJqjx3o2TysvQJ1KipeErwna89jsc6HswT8dErNs3UVV8zpJVfnQerSw4O3nFI8ve1VP5NUi9A P0cq8wq3nUefcrv5Pb007B17ar2p1R6DQccFe4SFeoMQdAxIj3al0JWf34PN98XKeNFB5SQeFXux d+3Oydr9xKPh2LuQ7qo+U9yV5P4zo+W2vU0HnKVHwcKcrydRXJzKis57ZKrqXV65dsJ0/8ePxyF4 vJ8HljbbNba7JUODdcOh+VWD9dWpVVXQn70+LT2c8j6Wkyr38nNwvA+B6OU2Jzjck7pCdydX9ntP axJLAownflvfPcNdHt9/toqTsP8b0Z8D9ZaXb4Xt48Iz3FKmIj6kQe2CxPtF9qEkeg9eNaHkk1Zz 2kX0JttEjznsXwZBB8tSJPV8za8LfsuTsfYTddfnT5IR9J9BmZnwLxU+BLyPa0lFKSijQpKGuicJ sU5uCeb9wf8VP5p4khI/rlPYyRp0J18J9XmbFVVU/Q2AjD4B92G5VVVH2wk3B+h/z/nzNonB6o3P ZvHIpPaf+BK8wj6n3H2NH7EV95nk9s+KFHxSqtXZ94O/h5uwnaUqPcSZ6HxPpD3DCYMDCij6Tj96 1b/C5/G50JHQcjz8XY8iqqueHclOAN2gTj4v0CCH1hJMfx6fgESYr3tejr0qEC1Ao1y451r3/zmv Y/8X1ikdU/bo8yV5Iv3Klua+8sr4SO8fSePkPc+YT9hc0kQPrn6se+0fWcmmPHZB2T5SfP+lP1qf 934azZ9Tmnf0fVYkni8Ih+SyPz+O+uF/zuW7+28cb7rxct3409CvZi4kH5B2o9GSKcyk/98TDhwG VOjLNmZpzFMYLBhhgmSzjBYwZYkGVVtFlmMqVKmWo02hisGRjA7IvwnlRaYsy1rjBcrlRX4/kK5L 7HFLrj8gvf3q6KsaqK8rhd25WnTNnfSurunZAOr8WUlctu5Esu9N1lHkRLTrOomgu4cKLjCDWqSn cF1zPJ8vYAAADlwBOrbdrUtOujnOrbdtRPGZmZYZYYqzMqX6tEvz1boHF7XNOt0+6/jv89/dmMYx jGMYwYMGMYxjGMYwYMJCQkGMYxjGMYwYMGMGDGmmmmmmmmmmmmGGGw7HkPUakn2hSdiUp+IZJP7R v7OdmVmZlmLd2i2+dV88+tQwyciroEjejuOz5eDfSqeT64c+uMaMcqI4hZJsYlhqlg9HkzMy23IS e56u3Nz3BQlc5J8NDZzOiqcY4zMzMzNZsynGOMp36cOmU4xxlOqK6Ylww6cU6WOMpxY4ynFjjKcW MVI2HAOjp0v47g5rBU5CVKLLCywssLLCywssJYqxYqz9FVtz3SxlFAAG3VLFWLFWPcAAAqs2TMYq xMxirxwnGMLrbQAA9uVlyVZ34zMy5NVMq5TKzPdwAAgABysupSexEkkkl45ZbNe35/VlvLWZ2y3w +b/wz0uzsS3258L4fT4iQAAefPdZ10B3uiQAAAG/D7rLMtyzLMyvpZllX3Msyzz8vqsu+r517wAA AD3+8+NW6Bu6ddECvTPazl+XKurMv3KqeMvHYAAG1jNDEW2bX/y6fzP1kefl7qO9LgpqrmmTa92c 1OJUfHe3e8Q2GvyL6J82UV5dyD5t4i7A+lepfsdlRR+D+RcQj2+qrmvZeOsxq19BVlFewz+rTnSo 1P4dKl7n2nvfYLsf2/9/3j0Vj63hfAk7SOjhMl7e22222ASAe77DxVugbunK6QFvrMn62m0Kc8Ji fHg5ySkUI9R1qr+blmVlysqyvOXPfokAAHrMt0AA9boABy6/g/HV+qnSq7qLL27NtvGNzjTlefFV Qn3JVBdBhqMT6PZFVd98g9SXHb7krtH7hg5SqqvIdh/D1P0Ij8/R978vefEsry4+N0lf4JVWZivx /QAADfx2L11WZ17XWV+Os/Dx29bZ3YRODKbChkw/WakzcNfBdLnzT0KUj5iA/IrMrc+phIkJArq9 XP5fe+/7vfmLvx471ET/Y9BJfOWCqfh8HdB6+14+ndE7JJrP+fhO46bfmRHXtmwPqI689QiT3J6B Jym2wiGr4/wx5+0jz0Ik2vKzLLK+NmZ676usvplZVV7gAAXf3A2Zy2DtsB3JunTTt1ykSGJsv+/2 z+tOp9B3HiPkNh0Hce97xQ7/19Nk8kk4y4undP6R/BJBSRSRgmDBRKJgYTCYjR8JHTu5zVV9r3H0 tsY9OLcmk2ts22tw2p5zWB0dUVfsl9u222LExjGDGTMxjMxm2Z7SMjVcHDiXrQzt9VwhPl7Yh1do 4Zfx/bGCTUQpREUfgFHSGBt+Ix8R8/wnFY+TUn++4tqKo2TbGTUr3pOpn6ln6/HlqSfyIkz+PS5/ 3XxgUgH9Dk9mw8x6BJPqTSOR+hsOZzTmOJ9B7NPJBxsjU4ehOr0VPR31rw6w8+n06g3kQHKQfM5J 4Dh3VXVxJ+Uk/A+xVV9xUGKqqqqVVUqqqqrr9x/c8ns69k+ZPFVYmxsk9nsifN9EhHkSTT2h+fW1 bbLNbiO7cOPCD7sLp+ToGCiijby/066hPm8HX2PjqoypeToeFKQ7WfEcHGwsToHUpSlFHuowUKMP J/A1L82fZfPX1yr6xgsPf6Cnj3pC+08mZiMzMzMxmYpJJJKSSspJJJKKqlVVVVbEJ4eG9+Z9Ty9h pHs7cgeG4kkmoMH9p+WvcaJsGhJB2sIsmE8E+ryt7tEidyePpyySLlttu22232i+Dv946JR39mVb 0qR6nJHqKL5Dnc/loZyerJThhUk3BPQEoOBQb7h7ZwNesSnSj7e5V1zvTv1T1TD3+TsfmeKdJL0S SOspAzrHt0JuPi0OBjPAfQYljGJYxiv5xwYcGGChRRRRgowUKKKKMFGChRRRhgpRgoUf17R4thuN 0nU6o0CqXtTyPwHuX1Si7i7fCkUcE+Z5DBQpSlKKOI2mI0KFKUo3QbaGxzN0aklTCMVyd3ScL4i7 K4nxd07pr1x4gpHt8B3Tz8xHpRXDiLsGphsZJPo8m4YU++uDg69rPLvgPdIV7VS7B0KR+B7ijyQj qK2/kWLcsys/X+sYRmJSTLAlClirbSlLFW39onOfLvfaye7Jt+e9KZKx7OJN55ZNjZIno+ty5fCC SfuvU0yOIqsI1Map2qu3rXZR2ick58q9Z2H0quXT7uXYJDfOUU5HeN0jmSTokhJ28PDvvzJemMkc XOyEkdLvUovK707vLidTwPsXw8XenopI7khOlrpvdSBniVUksQ14dR8+TD7TqMTqbDyabSMUqo5A 7HQUvk28O7arVhSy5zPMRHU+D+L+17vb1tWv5n6AAkkk5ZX1ex/Fcyr6rqhef5tcA6fCqnA2DYBk FCVAsCeys2zXHbajLvptJ4xHt1kJnpkVLGug4PAdTqNzc9qSJ18oujyDyknh0HahV9IwO0V6l6Lu Oxwn5fat7XZPsMS9SRYVvfpTsnsenUdmpt7jiK7d3YHb3wcyorYmJOPLpSq+sq7ddFy5bYCveErc lF8VJO+qdl4Ex8ASG7xdPjfFHVXoXnyeeld/TikrrEKeYqTtqr0au7O+/S693xp+f0Irwr7tL3zP aJ5Snw3yaHuLL5rZT1qv9GqpWxsJEP0Un7aeTdnE5v6NSREPm83KQ8DwPGRwaA+wT0GjUfG8etxy P0pzHyh62GYZhmGYZhmGYaVJUlSVJUlSVJUgzDMMwzDMMwzDMMwzDMMNRKzANkVWMCDCV8OTy6nD N1zWc4K/CslK8ukrtX3FLicz5lgw6qPqa4tPiKUe5a85EkPhSNvhiRtPurb1HyGFhiYx6Pbyo8iU 9CmkNHYU9vl9aqvpyhPrMDE4EUjHufx9cy5mW+e8gfoSieKk88j/dkKR3YN1+t7VS52TB7TxHnt2 PDBP7J7pgTZ7T6I1ISe5E5oOciEfNl2McYE5Z5bo3B2nvcmfQYNJ5NmhgHvUqcxI8VJ4ExjBGxT7 /7D+L6yaj8pJI2+XZIehQyx9Kx5S0uP5eXxXdJSOz7a+k1J4J2eO77Vcg08+nGf5VFdqK9BTuaSf /PFLpUsXynoe1mYykkkkpJKSSSX35ZU1CQfHgPtg4OFVSFVVVVUqqpVVVVXYTuUnrr6p4JGkVX81 an8P4cdilT1GIjj1ewUjqhD061PbdScR7Hig/JNfu3yfl4V1VLy7Sp/9tR5vB2RU+X/POt0MEtiH xRppG6FfJa/QGSPEf4FXtymZSTYqn+dMyIeDSE6QYpiDUhfx5EfkIDUQe8/5iTMRV/M+oDynuB0a qY+hV+IlScOxT4F3TsiwntEsPDEj0JlifX4WeeMj4GxDX4CTkjq4JGydBwWCJOck7C8bsJuR1Js4 aI4bSvsDxh2GDDBh5CoeZIPKT3bjcUUUKKEcx0KnRLIuGFXGkuyZV7p7AO7/M1tP9TX6k7vC98jX oazWae8YuNI6GF7jpyReWoOMDhk4tBHwkSFGjYRo0GepEH4souGx5YWZTwIn14GGCRQD+0BgwYBF CjiN42nvfrhl5zOzzyfwqckJJ2hicpBT76fprvVaQ+evbdFXrOplq+8D6nKIR953fNzlkifanv0U H00mwn4wP2VZm3ulL7upIkkkkkkjM9kS+sij7KmwiZwJwcELCnBhwZVLFhl7LufU8wPBg/1fxfX0 HlMVffVyqobfrqtyy+398ANsqyyrdAD6q7/J7rJUe7K/Tfq64Rd51y+azmda2+lu/HX6kvaT20pP mXoqjj1hpJeV6/sdz6XkxljLGWf519tV0H4UPcOCiTR93wffrCzTM+5lmQ60hIV/7jBsWbVxXF0b aq7Y2+v+hP8q/3/uJ/+if2E0mhoaGhomiaJpNDQySZzn0Z8/J9IE+tLmBMmLgyZmDJmYJmZmZluD JmYJmZmZluDJmSZmY222223A2222222222222223KJhEy4uLcgEMzMmZmZmLluQEtNttjbbbctty 2htOUxtOZRJMkxblmTJkyZMtzMy1BCZmDJmYmZLbmWNpymNpyI9NCNCNIkIkIkjCNEIg0gkQo2W2 05bbbbbbcptOW22OU5bbcn+Yu5IpwoSA1+inKA== --------------zRQwP43YAW3ga6zyFFhImPGh--