From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on dcvr.yhbt.net X-Spam-Level: X-Spam-ASN: AS31976 209.132.180.0/23 X-Spam-Status: No, score=-4.0 required=3.0 tests=AWL,BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_EF,HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED,SPF_HELO_PASS,SPF_PASS shortcircuit=no autolearn=ham autolearn_force=no version=3.4.2 Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dcvr.yhbt.net (Postfix) with ESMTPS id ED2DA1F4B5 for ; Wed, 13 Nov 2019 11:57:40 +0000 (UTC) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id :content-type:mime-version; q=dns; s=default; b=MzJoGZ5PH26IqwIK P/vmIyWKCIqnUml+PtzLcFu9orNH8IG6qc3pnEnK+ysBnMx5bOFVvg/gUScFTQ5w +F+bTxASD9OJ8/b/MhiaCNAJALBMthE6ynQo07K6TZQ/Mh4QVpdDNrZCg+XNPo5U 6VgWTsLvHXj/wpygsadQBpcq0Lw= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id :content-type:mime-version; s=default; bh=VzH9VV/O2cPwQ8Yvjy0RB5 gXKyQ=; b=pyHGA9ee2aWHHSi5+lBgTrtzMI+at4O3fWKki+uNVHJgRmrpR6JwJN X0LwWJZAPbcu1mmvytihQYD6j2ZJs2GbXwrgju8Y7mRC6wH1aSyGuabil9dnav9O xpy5UGHXrbGs1dxTZpIswpGKY2TCMvqFhE4/pvHlZct5odornIvsg= Received: (qmail 17706 invoked by alias); 13 Nov 2019 11:57:37 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Received: (qmail 17690 invoked by uid 89); 13 Nov 2019 11:57:36 -0000 Authentication-Results: sourceware.org; auth=none X-HELO: EUR03-VE1-obe.outbound.protection.outlook.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=zOUIOSoBP+Y1dBc5Jog0L3zOeo+KgvAGkEXVvxbVN8s=; b=WqSjUU/WHhIS0UEb3JMwCnG0uEkeuQXLLN0c89HjpfW/17RdhJazKPEBfa9G4Cfx2TH96JMPWW538NNoRWVk3ZveZ8GZ/6GBj99rmleMgwD7BrA/OaGwcKTAFk5ZIQRemZcbGpCSjTUkx6gIg83CNAqbAhwZ7eG2UWof3YR2LFs= Authentication-Results: spf=fail (sender IP is 63.35.35.123) smtp.mailfrom=arm.com; sourceware.org; dkim=pass (signature was verified) header.d=armh.onmicrosoft.com;sourceware.org; dmarc=none action=none header.from=arm.com; Received-SPF: Fail (protection.outlook.com: domain of arm.com does not designate 63.35.35.123 as permitted sender) receiver=protection.outlook.com; client-ip=63.35.35.123; helo=64aa7808-outbound-1.mta.getcheckrecipient.com; X-CR-MTA-TID: 64aa7808 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=TtKu452hXu/YDXBQ2e8cIfPQiJdcURBmFPFyQ+qiarsNpdZtJ2E76po28sDGEwqIsANmESELvRjEzkYrzB+z1Q/eoZxXFRc0YoME1NR/jOvCJmP9tsBsfYMoUzTxPZElNCvFo8bZQDvxEjMzmnP/PQRWmfVVy0URz5AprfRINqoE5qAVYM402+sPE6fRgw3BqGWteEe963ibIIVCGyDEGdf1R1arWUgT7zLwyEHn8C0opw8smEsyyIV0dClY0EBYa3gfkCihtFHOhXNFgXI63PNc6M8Fjffy3fhwVA+woA9E1C3Ry1Nuaykw7wPsABSH84gndG1ob/ukUxVAo6gOdw== 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-SenderADCheck; bh=zOUIOSoBP+Y1dBc5Jog0L3zOeo+KgvAGkEXVvxbVN8s=; b=SKra0Y6lY/NBhcvYFLvlAv5N3xFdrOZcL/4MQJ9+V1ZbCybcKvk8ICzsZm/13Rym5GA1qiAeuEFemD7h6RTysCueUKX7wzx9GdalGQC4q0eqP9bHAtsOQb19u7GTouTZ/jbmGrm2EwS5ZkwIOX4adOTO2NvFCvr8CS9US4BZNvDesNK0VetL5FHcP09tOrtVc3QP0IN8wGXngtHxPCEffSniL1FUMqDD0aOKzQIo9hX8+8XsSNnIvEwAYGTyx6DDHpwAPGuIEEqmkFdaGKGMZjd0Jpm9AvXrC5xLv9+LWJ3iQPZZ9hdFw7ypXZ6H8NC46Z4mDB5lgm/1AJvZMnhhTg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=arm.com; dmarc=pass action=none header.from=arm.com; dkim=pass header.d=arm.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=zOUIOSoBP+Y1dBc5Jog0L3zOeo+KgvAGkEXVvxbVN8s=; b=WqSjUU/WHhIS0UEb3JMwCnG0uEkeuQXLLN0c89HjpfW/17RdhJazKPEBfa9G4Cfx2TH96JMPWW538NNoRWVk3ZveZ8GZ/6GBj99rmleMgwD7BrA/OaGwcKTAFk5ZIQRemZcbGpCSjTUkx6gIg83CNAqbAhwZ7eG2UWof3YR2LFs= From: Krzysztof Koch To: "libc-alpha@sourceware.org" CC: nd Subject: [PATCH] Add new script for plotting string benchmark JSON output Date: Wed, 13 Nov 2019 11:57:17 +0000 Message-ID: x-ts-tracking-id: 5a8e7e9d-338a-4900-b5b4-c49c2956866a.0 x-checkrecipientchecked: true Authentication-Results-Original: spf=none (sender IP is ) smtp.mailfrom=Krzysztof.Koch@arm.com; X-MS-Exchange-PUrlCount: 1 x-checkrecipientrouted: true x-ms-oob-tlc-oobclassifiers: OLM:5797;OLM:5797; X-Forefront-Antispam-Report-Untrusted: SFV:NSPM;SFS:(10009020)(4636009)(346002)(366004)(396003)(39860400002)(136003)(376002)(199004)(189003)(256004)(14444005)(3846002)(2906002)(6116002)(66066001)(71190400001)(71200400001)(2501003)(6916009)(99286004)(316002)(25786009)(74316002)(2351001)(7696005)(476003)(486006)(305945005)(33656002)(7736002)(52536014)(8936002)(5660300002)(81166006)(81156014)(66946007)(76116006)(66476007)(66446008)(64756008)(66556008)(66616009)(8676002)(30864003)(55016002)(4326008)(478600001)(9686003)(5640700003)(6436002)(6306002)(26005)(14454004)(6506007)(102836004)(186003)(86362001)(2004002)(579004);DIR:OUT;SFP:1101;SCL:1;SRVR:VE1PR08MB5167;H:VE1PR08MB4783.eurprd08.prod.outlook.com;FPR:;SPF:None;LANG:en;PTR:InfoNoRecords;A:1;MX:1; received-spf: None (protection.outlook.com: arm.com does not designate permitted sender hosts) X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam-Untrusted: BCL:0; X-Microsoft-Antispam-Message-Info-Original: pHF6GLuxjwvH4z5Pco2rRFfDsv9adEPUh969w9zDx2STyZ/5I40MhE9ci44kba5Y/+0MCLWrBQ4iLWtVVqCplExwXyNCxS8ZT2T16cFS/8IMcaAdx25d9Z3fjlAfPiicaXCJGqwQa/bRFsRES1LU6Xa3qzjEjmavNg5rvbdkxLTIf/ZRAgpHt9cnh5BFancnx9pMwzcDZHEEsKHTot4Fx6h0q/mJtMfXMfHqNswPR0EP0yj6jIKolF/R/ZCtyZ+LaNuQTJ33Ll8XMn0MfR159mA3aXEPNTXEIfet1QnG46A0zYmC3mXR65PsYTQlY/EdBca8ahi/pFk4vKZqXIK1xPNTrdmxtcgWwamgg3uujzeB+uluehMq3KbxdX0vHS6ItGDESvjneyWYbB8wkqyCAj7cptE/ysm/BmikXnu79pgr+LPnBWJq1G3qaYyg67fxIjIxhkY53JiYs5sdicX3d9dSEBQ0Q+jcXuiL/8GR6R4= x-ms-exchange-transport-forked: True Content-Type: multipart/mixed; boundary="_002_VE1PR08MB4783E72815C87C787CDA359984760VE1PR08MB4783eurp_" MIME-Version: 1.0 Original-Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Krzysztof.Koch@arm.com; X-MS-Exchange-Transport-CrossTenantHeadersStripped: AM5EUR03FT049.eop-EUR03.prod.protection.outlook.com X-MS-Office365-Filtering-Correlation-Id-Prvs: 9a5df6f6-ad72-47f8-11eb-08d76830a1b6 --_002_VE1PR08MB4783E72815C87C787CDA359984760VE1PR08MB4783eurp_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Add a script for visualizing the JSON output generated by existing glibc string microbenchmarks. Overview: plot_strings.py is capable of plotting benchmark results in the following formats, which are controlled with the -p or --plot argument: 1. absolute timings (-p time): plot the timings as they are in the input benchmark results file. 2. relative timings (-p rel): plot relative timing difference with respect to a chosen ifunc (controlled with -b argument). 3. performance relative to max (-p max): for each varied parameter value, plot 1/timing as the percentage of the maximum value out of the plotted ifuncs. 4. throughput (-p thru): plot varied parameter value over timing For all types of graphs, there is an option to explicitly specify the subset of ifuncs to plot using the --ifuncs parameter. For plot types 1. and 4. one can hide/expose exact benchmark figures using the --values flag. When plotting relative timing differences between ifuncs, the first ifunc listed in the input JSON file is the baseline, unless the baseline implementation is explicitly chosen with the --baseline parameter. For the ease of reading, the script marks the statistically insignificant range on the graphs. The default is +-5% but this value can be controlled with the --threshold parameter. To accommodate for the heterogeneity in benchmark results files, one can control i.e the x-axis scale, the resolution (dpi) of the generated figures or the key to access the varied parameter value in the JSON file. The corresponding options are --logarithmic, --resolution or --key. The --key parameter ensures that plot_strings.py works with all files which pass JSON schema validation. The schema can be chosen with the --schema parameter. If a window manager is available, one can enable interactive figure display using the --display flag. Finally, one can use the --grid flag to enable grid lines in the generated figures. Implementation: plot_strings.py traverses the JSON tree until a 'results' array is found and generates a separate figure for each such array. The figure is then saved to a file in one of the available formats (controlled with the --extension parameter). As the tree is traversed, the recursive function tracks the metadata about the test being run, so that each figure has a unique and meaningful title and filename. While plot_strings.py works with existing benchmarks, provisions have been made to allow adding more structure and metadata to these benchmarks. Currently, many benchmarks produce multiple timing values for the same value of the varied parameter (typically 'length'). Mutiple data points for the same parameter usually mean that some other parameter was varied as well, for example, if memmove's src and dst buffers overlap or not (see bench-memmove-walk.c and bench-memmove-walk.out). Unfortunately, this information is not exposed in the benchmark output file, so plot_strings.py has to resort to computing the geometric mean of these multiple values. In the process, useful information about the benchmark configuration is lost. Also, averaging the timings for different alignments can hide useful characterstics of the benchmarked ifuncs. Testing: plot_strings.py has been tested on all existing string microbenchmarks which produce results in JSON format. The script was tested on both Windows 10 and Ubuntu 16.04.2 LTS. It runs on both python 2 and 3 (2.7.12 and 3.5.12 tested). Useful commands: 1. Plot timings for all ifuncs in bench-strlen.out: $ ./plot_strings.py bench-strlen.out 2. Display help: $ ./plot_strings.py -h 3. Plot throughput for __memset_avx512_unaligned_erms and __memset_avx512_unaligned. Save the generated figure in pdf format to 'results/'. Use logarithmic x-axis scale, show grid lines and expose the performance numbers: $ ./plot_strings.py bench.out -o results/ -lgv -e pdf -p thru \ -i __memset_avx512_unaligned_erms __memset_avx512_unaligned 4. Plot relative timings for all ifuncs in bench.out with __generic_memset as baseline. Display percentage difference threshold of +-10%: $ ./plot_strings.py bench.out -p rel -b __generic_memset -t 10 Discussion: 1. I would like to propose relaxing the benchout_strings.schema.json to allow specifying either a 'results' array with 'timings' (as before) or a 'variants' array. See below example: { "timing_type": "hp_timing", "functions": { "memcpy": { "bench-variant": "default", "ifuncs": ["generic_memcpy", "__memcpy_thunderx"], "variants": [ { "name": "powers of 2", "variants": [ { "name": "both aligned", "results": [ { "length": 1, "align1": 0, "align2": 0, "timings": [x, y] }, { "length": 2, "align1": 0, "align2": 0, "timings": [x, y] }, ... { "length": 65536, "align1": 0, "align2": 0, "timings": [x, y] }] }, { "name": "dst misaligned", "results": [ { "length": 1, "align1": 0, "align2": 0, "timings": [x, y] }, { "length": 2, "align1": 0, "align2": 1, "timings": [x, y] }, ... 'variants' array consists of objects such that each object has a 'name' attribute to describe the configuration of a particular test in the benchmark. This can be a description, for example, of how the parameter was varied or what was the buffer alignment tested. The 'name' attribute is then followed by another 'variants' array or a 'results' array. The nesting of variants allows arbitrary grouping of benchmark timings, while allowing description of these groups. Using recusion, it is possible to proceduraly create titles and filenames for the figures being generated. --- benchtests/scripts/plot_strings.py | 395 +++++++++++++++++++++++++++++++++= ++++ 1 file changed, 395 insertions(+) create mode 100755 benchtests/scripts/plot_strings.py diff --git a/benchtests/scripts/plot_strings.py b/benchtests/scripts/plot_s= trings.py new file mode 100755 index 0000000..b346d9b --- /dev/null +++ b/benchtests/scripts/plot_strings.py @@ -0,0 +1,395 @@ +#!/usr/bin/python3 +# Plot GNU C Library string microbenchmark output. +# Copyright (C) 2019 Free Software Foundation, Inc. +# This file is part of the GNU C Library. +# +# The GNU C Library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# The GNU C Library 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 +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with the GNU C Library; if not, see +# . +"""Plot string microbenchmark results. + +Given a benchmark results file in JSON format and a benchmark schema file, +plot the benchmark timings in one of the available representations. + +Separate figure is generated and saved to a file for each 'results' array +found in the benchmark results file. Output filenames and plot titles +are derived from the metadata found in the benchmark results file. +""" +import argparse +from collections import defaultdict +import json +import matplotlib as mpl +import numpy as np +import os + +try: + import jsonschema as validator +except ImportError: + print("Could not find jsonschema module.") + raise + +# Use pre-selected markers for plotting lines to improve readability +markers =3D [".", "x", "^", "+", "*", "v", "1", ">", "s"] + +# Benchmark variants for which the x-axis scale should be logarithmic +log_variants =3D {"powers of 2"} + + +def gmean(numbers): + """Compute geometric mean. + + Args: + numbers: 2-D list of numbers + Return: + numpy array with geometric means of numbers along each column + """ + a =3D np.array(numbers, dtype=3Dnp.complex) + means =3D a.prod(0) ** (1.0 / len(a)) + return np.real(means) + + +def relativeDifference(x, x_reference): + """Compute per-element relative difference between each row of + a matrix and an array of reference values. + + Args: + x: numpy matrix of shape (n, m) + x_reference: numpy array of size m + Return: + relative difference between rows of x and x_reference (in %) + """ + abs_diff =3D np.subtract(x, x_reference) + return np.divide(np.multiply(abs_diff, 100.0), x_reference) + + +def plotTime(timings, routine, bench_variant, title, outpath): + """Plot absolute timing values. + + Args: + timings: timings to plot + routine: benchmarked string routine name + bench_variant: top-level benchmark variant name + title: figure title (generated so far) + outpath: output file path (generated so far) + Return: + y: y-axis values to plot + title_final: final figure title + outpath_final: file output file path + """ + y =3D timings + plt.figure() + + if not args.values: + plt.axes().yaxis.set_major_formatter(plt.NullFormatter()) + + plt.ylabel("timing") + title_final =3D "%s %s benchmark timings\n%s" % \ + (routine, bench_variant, title) + outpath_final =3D os.path.join(args.outdir, "%s_%s_%s%s" % \ + (routine, args.plot, bench_variant, outpath)) + + return y, title_final, outpath_final + + +def plotRelative(timings, all_timings, routine, ifuncs, bench_variant, + title, outpath): + """Plot timing values relative to a chosen ifunc + + Args: + timings: timings to plot + all_timings: all collected timings + routine: benchmarked string routine name + ifuncs: names of ifuncs tested + bench_variant: top-level benchmark variant name + title: figure title (generated so far) + outpath: output file path (generated so far) + Return: + y: y-axis values to plot + title_final: final figure title + outpath_final: file output file path + """ + # Choose the baseline ifunc + if args.baseline: + baseline =3D args.baseline.replace("__", "") + else: + baseline =3D ifuncs[0] + + baseline_index =3D ifuncs.index(baseline) + + # Compare timings against the baseline + y =3D relativeDifference(timings, all_timings[baseline_index]) + + plt.figure() + plt.axhspan(-args.threshold, args.threshold, color=3D"lightgray", alph= a=3D0.3) + plt.axhline(0, color=3D"k", linestyle=3D"--", linewidth=3D0.4) + plt.ylabel("relative timing (in %)") + title_final =3D "Timing comparison against %s\nfor %s benchmark, %s" %= \ + (baseline, bench_variant, title) + outpath_final =3D os.path.join(args.outdir, "%s_%s_%s%s" % \ + (baseline, args.plot, bench_variant, outpath)) + + return y, title_final, outpath_final + + +def plotMax(timings, routine, bench_variant, title, outpath): + """Plot results as percentage of the maximum ifunc performance. + + The optimal ifunc is computed on a per-parameter-value basis. + Performance is computed as 1/timing. + + Args: + timings: timings to plot + routine: benchmarked string routine name + bench_variant: top-level benchmark variant name + title: figure title (generated so far) + outpath: output file path (generated so far) + Return: + y: y-axis values to plot + title_final: final figure title + outpath_final: file output file path + """ + perf =3D np.reciprocal(timings) + max_perf =3D np.max(perf, axis=3D0) + y =3D np.add(100.0, relativeDifference(perf, max_perf)) + + plt.figure() + plt.axhline(100.0, color=3D"k", linestyle=3D"--", linewidth=3D0.4) + plt.ylabel("1/timing relative to max (in %)") + title_final =3D "Performance comparison against max for %s\n%s " \ + "benchmark, %s" % (routine, bench_variant, title) + outpath_final =3D os.path.join(args.outdir, "%s_%s_%s%s" % \ + (routine, args.plot, bench_variant, outpath)) + + return y, title_final, outpath_final + + +def plotThroughput(timings, params, routine, bench_variant, title, outpath= ): + """Plot throughput. + + Throughput is computed as the varied parameter value over timing. + + Args: + timings: timings to plot + params: varied parameter values + routine: benchmarked string routine name + bench_variant: top-level benchmark variant name + title: figure title (generated so far) + outpath: output file path (generated so far) + Return: + y: y-axis values to plot + title_final: final figure title + outpath_final: file output file path + """ + y =3D np.divide(params, timings) + plt.figure() + + if not args.values: + plt.axes().yaxis.set_major_formatter(plt.NullFormatter()) + + plt.ylabel("%s / timing" % args.key) + title_final =3D "%s %s benchmark throughput results\n%s" % \ + (routine, bench_variant, title) + outpath_final =3D os.path.join(args.outdir, "%s_%s_%s%s" % \ + (routine, args.plot, bench_variant, outpath)) + return y, title_final, outpath_final + + +def finishPlot(x, y, title, outpath, x_scale, plotted_ifuncs): + """Finish generating current Figure. + + Args: + x: x-axis values + y: y-axis values + title: figure title + outpath: output file path + x_scale: x-axis scale + plotted_ifuncs: names of ifuncs to plot + """ + plt.xlabel(args.key) + plt.xscale(x_scale) + plt.title(title) + + plt.grid(color=3D"k", linestyle=3Dargs.grid, linewidth=3D0.5, alpha=3D= 0.5) + + for i in range(len(plotted_ifuncs)): + plt.plot(x, y[i], marker=3Dmarkers[i % len(markers)], + label=3Dplotted_ifuncs[i]) + + plt.legend(loc=3D"best", fontsize=3D"small") + plt.savefig("%s_%s.%s" % (outpath, x_scale, args.extension), + format=3Dargs.extension, dpi=3Dargs.resolution) + + if args.display: + plt.show() + + plt.close() + + +def plotRecursive(json_iter, routine, ifuncs, bench_variant, title, outpat= h, + x_scale): + """Plot benchmark timings. + + Args: + json_iter: reference to json object + routine: benchmarked string routine name + ifuncs: names of ifuncs tested + bench_variant: top-level benchmark variant name + title: figure's title (generated so far) + outpath: output file path (generated so far) + x_scale: x-axis scale + """ + + # RECURSIVE CASE: 'variants' array found + if "variants" in json_iter: + # Continue recursive search for 'results' array. Record the + # benchmark variant (configuration) in order to customize + # the title, filename and X-axis scale for the generated figure. + for variant in json_iter["variants"]: + new_title =3D "%s%s, " % (title, variant["name"]) + new_outpath =3D "%s_%s" % (outpath, variant["name"].replace(" = ", "_")) + new_x_scale =3D "log" if variant["name"] in log_variants else = x_scale + + plotRecursive(variant, routine, ifuncs, bench_variant, new_tit= le, + new_outpath, new_x_scale) + return + + # BASE CASE: 'results' array found + domain =3D [] + timings =3D defaultdict(list) + + # Collect timings + for result in json_iter["results"]: + domain.append(result[args.key]) + timings[result[args.key]].append(result["timings"]) + + domain =3D np.unique(np.array(domain)) + averages =3D [] + + # Compute geometric mean if there are multple timings for each + # parameter value. + for parameter in domain: + averages.append(gmean(timings[parameter])) + + averages =3D np.array(averages).transpose() + + # Choose ifuncs to plot + if isinstance(args.ifuncs, str): + plotted_ifuncs =3D ifuncs + else: + plotted_ifuncs =3D [x.replace("__", "") for x in args.ifuncs] + + plotted_indices =3D [ifuncs.index(x) for x in plotted_ifuncs] + plotted_vals =3D averages[plotted_indices,:] + + # Plotting logic specific to each plot type + if args.plot =3D=3D "time": + codomain, title, outpath =3D plotTime(plotted_vals, routine, + bench_variant, title, outpath) + elif args.plot =3D=3D "rel": + codomain, title, outpath =3D plotRelative(plotted_vals, averages, = routine, + ifuncs, bench_variant, title, outpath) + elif args.plot =3D=3D "max": + codomain, title, outpath =3D plotMax(plotted_vals, routine, + bench_variant, title, outpath) + elif args.plot =3D=3D "thru": + codomain, title, outpath =3D plotThroughput(plotted_vals, domain, = routine, + bench_variant, title, outpath) + + # Plotting logic shared between plot types + finishPlot(domain, codomain, title, outpath, x_scale, plotted_ifuncs) + + +def main(args): + """Program Entry Point. + + Args: + args: command line arguments (excluding program name) + """ + + # Select non-GUI matplotlib backend if interactive display is disabled + if not args.display: + mpl.use("Agg") + + global plt + import matplotlib.pyplot as plt + + schema =3D None + + with open(args.schema, "r") as f: + schema =3D json.load(f) + + for filename in args.bench: + bench =3D None + + with open(filename, "r") as f: + bench =3D json.load(f) + + validator.validate(bench, schema) + + for function in bench["functions"]: + bench_variant =3D bench["functions"][function]["bench-variant"= ] + ifuncs =3D bench["functions"][function]["ifuncs"] + ifuncs =3D [x.replace("__", "") for x in ifuncs] + + plotRecursive(bench["functions"][function], function, ifuncs, + bench_variant, "", "", args.logarithmic) + + +""" main() """ +if __name__ =3D=3D "__main__": + + parser =3D argparse.ArgumentParser(description=3D + "Plot string microbenchmark results", + formatter_class=3Dargparse.ArgumentDefaultsHelpFormatter) + + # Required parameter + parser.add_argument("bench", nargs=3D"+", + help=3D"benchmark results file(s) in json format") + + # Optional parameters + parser.add_argument("-b", "--baseline", type=3Dstr, + help=3D"baseline ifunc for 'rel' plot") + parser.add_argument("-d", "--display", action=3D"store_true", + help=3D"display figures") + parser.add_argument("-e", "--extension", type=3Dstr, default=3D"png", + choices=3D["png", "pdf", "svg"], + help=3D"output file(s) extension") + parser.add_argument("-g", "--grid", action=3D"store_const", default=3D= "", + const=3D"-", help=3D"show grid lines") + parser.add_argument("-i", "--ifuncs", nargs=3D"+", default=3D"all", + help=3D"ifuncs to plot") + parser.add_argument("-k", "--key", type=3Dstr, default=3D"length", + help=3D"key to access the varied parameter") + parser.add_argument("-l", "--logarithmic", action=3D"store_const", + default=3D"linear", const=3D"log", + help=3D"use logarithmic x-axis scale") + parser.add_argument("-o", "--outdir", type=3Dstr, default=3Dos.getcwd(= ), + help=3D"output directory") + parser.add_argument("-p", "--plot", type=3Dstr, default=3D"time", + choices=3D["time", "rel", "max", "thru"], + help=3D"plot absolute timings, relative timings, "= \ + "performance relative to max, or throughput") + parser.add_argument("-r", "--resolution", type=3Dint, default=3D100, + help=3D"dpi resolution for the generated figures") + parser.add_argument("-s", "--schema", type=3Dstr, + default=3Dos.path.join(os.path.dirname( + os.path.realpath(__file__)), + "benchout_strings.schema.json"), + help=3D"schema file to validate the results file."= ) + parser.add_argument("-t", "--threshold", type=3Dint, default=3D5, + help=3D"threshold to mark in 'rel' graph (in %%)") + parser.add_argument("-v", "--values", action=3D"store_true", + help=3D"show actual values") + + args =3D parser.parse_args() + main(args) --=20 1.9.1 --_002_VE1PR08MB4783E72815C87C787CDA359984760VE1PR08MB4783eurp_ Content-Type: application/x-gzip; name="ExampleFigures.tar.gz" Content-Description: ExampleFigures.tar.gz Content-Disposition: attachment; filename="ExampleFigures.tar.gz"; size=78073; creation-date="Thu, 07 Nov 2019 12:21:45 GMT"; modification-date="Thu, 07 Nov 2019 12:21:45 GMT" Content-Transfer-Encoding: base64 H4sIAFkMxF0AA9T9dVSWXfQ2AD5IKi0IgrQYIN3dIGABAtIdKg0KSAsi3aVSCtLdDSKSFqAijZQg DYI0zD68v++bb9bMrIk/Zq1xrfcVH57nuc99zt7Xvq599tm3naWdi+UjY1NXd0FePuPH9qa2D6zt LS2MLZ3tXIydLW2NbU2drS2NbR2suRztrTH/X/3hgT/CwsLob15hQZ7/82/4SYiXX0AIw8svKMTL wyMgyAvv4+Pj4efHMPH8f3e5/8/+PHZ5ZOrMxISxcfawcTDn4f1/9r7/V7///9M/IWq3rxOfoT0D PxKrKCtoYDDYTBjMKR0CPHjllau/I/yF4yKnokkAf7wILILh36cdlXVdMBhSU/QfVq50zgMMhgmj oiCr6Z6yNOamQ3lvX3htlWitlOmUv4A6jibONZ3Sa7k4ZquSoecFaSMEQ1ip1MzDQjhZaSNCL9Oa t8kVksviXJBd583VwairxVwuU1/ZJh0fY1xcYrmRNHdkkHTv/Uv+uZSXQ2zbK6LWOCwsPB3nzcN5 O3Rwya41YMEP8K+yY3o6v/95nZ0In+l/Xj3ThkVgfvJz4XtHzPuTX58v4Pn/6VuVBad//8ZT55ho W1heJlanjHnxQqd4q3TD0saG0NNzv8deqSomOhqjTjk5PX136JZpuNZZaWnp4Izg0lKerEfqlH1N ntuqD7WGThMRPbsaOlhmft1SOLBpTgSTl6Gg/n0+/cCMiUCuDp/Jn0mG7JlzUUCCtFSkZUnGdl59 EL22a77N65XV1ZJ/PhlZWYFxV+6oDoh67wn8/pIalibpmeG6PEymSG7Y4Kql35l5ParUtA1vc+EH oaura3S3Ra5hg5DUzi9sOgn3Ugnhkv7cBjzNnEW7x0Mk2nWVMPM3BWGcKsOvBG2iExICafit3g0O 6jx4WVHBjzGZ+5Lqvj6lWFdt1x56bm1rK7Cq6nHdQFvPz5f81uwNp3+EVlUJmpmbm1pYaJo+1s4J epWfL7ZqLEvGYz8qMjg8rJooaDuoFktFRubXFkQqfznujWnbc+U7d7jLD4gvCJnM9iSU1tRc314Z M33wIOTZMxw6EUdMzp30jqWhijKPrYXy4RR2TiEhqr29vYQxoo58IhKZ/NxAQmrV/mq7keeFhRyf UkQphISE2H8W6NfYPxEmpqKiKi0tvbrtobNbXlFRsHRZ89rw8LCjo2Nur1hIrtyi+Y+omhq3mBYz SiGHcQkO/WqiyMhI5Zs3veYE38LsERATKyZxGcb3O4zVB8Kcmn5+JXhe0kPAwMBAdfRoW1HR+ML5 goVaQm3BzIdEyvfvX1VQ/zDVHkZ+7hwuNzf3+QsX2j58wJF/TiSroXEW82u8yfM8rxnOp8+f35SU RK2MNVy8fFlJIyiflylwv+UKK6vJh2ByAMiAtDSG4Wq7sF+/TBKWE/A1txZ+oJdSUlJKrT7Tjrb4 tigc/rmTJhHS7L3//v37U3wvieCWz/OYYI72FrmzvBSeRVwQfv/jxzlBm4FnT59iGRgaljlNKyWQ Pt44aoDPPY2KIuXg5DQ1MfG7nSrGLCFBh1mbaif0OtqdK62qCrx5Wb7C6nOpw4SUim7gfi8ePn7m 3ZzbgOh+ISGnn5PQh4q7rSgPhISFtTU++dtbbaf/IjkZFrJ1YIAKzLADlvXSLiHj349J3Jluq+M8 goKBiYmJU7V5C3qxcXEBW4s/Mx8vDvDw8spG0AqaWFvnODOeemfse4gm7MWrV3JgEk7THWBZitra iawlyckXKisro9PToyw/Jra2tso6hf/+nByUkkLXLbZwv14a8+tzsvDa37/yAXjETHHdJg4OUbiE VOhF9n3rK1eumK9Ptc+P1vEXFha+LiggtLGxCWeQpC0rK4vd+BGBxebVbDtceZpTr9IPZhgmhffJ hkXC/sLe1uJ5Uee3GSOhdXWiejX2EboVVszc3KQyspg693Wz9mbOUe/fhj17rzAYbuPmDxuzHyen pk5hY2N/L9SloBd3/bDacmy0siX9ZAPHZe5LYGbmRSIiIrUCbU4RMTGzg5314KiopBlppykcsGlc fn7+9ppdY691XD5+/kt2N2/eVPDyatSgzooN/yvq+Y/j8q1Xz7JvJb/v6iIAu78/3ihKxW0U/rPE +NpsKp/lGTC5mIvXNRMf/+m/BOAC/sR2NPDjh2Lbc+L1g12XrEY2NjbwAb83b5jtJ5qLnBoIbX4W 04M1hR4W9PphYbO24mME7EfPw8Lhq5Uaq2bkrgRZPuF66DwammFPpKyqeqYjipGUkJBwfnGxrb0d V9x1SU3s+plrfx5vDhTpr/379zwigvjR48fIY/syrxcc3hxt8qSWDyIJDAkJmTLankv3PXX1kJrx z58/aFXjLt96XVJCam5uvrk0RJFzOzV2htOrRcLnQGR0bMzU1rbwUeq1j/sV2dsy2s4HhMqCdzWT wm8kcZkC3Di6uLS9VYlzPNx7jHBB2H5URk2NTMxthQgWOvyCMMnp06cHW3ylEbaNNrjd+ZMznbEA Ux1UUHCNVuC+X5l5JwsnJ7Hnv6VWuG/Hvc0HjxYHbsVsg006urldf/RIQK/qYSCveQcTPz/Fx0TO tjqXOYGVvdL7fSwcuuU44E4f4HNqJUaSEh6bBOTk5DvLNRO9mddJFcfhQyaAWqVlZa0fQiiYCU6R MEgE593NmTrY/TtY55Lz9iA8nOjRwvfTz58/Py/4kLK/v7/Uc9ve/ckTZhaWUzAnckpKeHv/lsPA sJfGmy5cVAqXUVDAAde91Png+OhQxHXpPB4xLY6bm5tBk8e5/e3VzqEKaxjCU6UIWrYNRpgO6eMD fpjCvry7Vw7mpI9bAQRKLT9S0Ul6UN4rNniakJDw9jN8QKfalqb+0R//0xSXmQQFzx3vfvWltHMf qXWaXttfbcl88vf3eWF7us3NzbX5vovPgoKm4X5U9x2/Zd96IfaYHcyY59G8Grj8NECyTp3zpUgG ydC/c1/benvVHiRjmcx0xRCQknYGMfoQyMvLH+zOpetUPTyXJuUdauyzm6XTWc+6b977Wnbn71fp yV+//P58y7l45Qr+06dPYQDPe8QAz0of/mCvbWgw74pmBtCRMTCg+7c6EQXWeRFmCvza11p/du4j WFUxQbSkpCT52bP+8Oo0wKmI914lyzGsZl+xoTi4gs/hXuuXLyS6urq1LnMkPnt/rnj9/Szc+/Nn Z6FuBRkl5TMYs7un57X6vvvO4/E/BJlh2VdWVmpdl2mRIaAZkpZmvHI75V2ueubaV+ljZYa3PflH SdzGGeadkbW+x1ISEhK9JcbSZDCIs447a6ZE9GKaeWExLS3SB4eHpg8fhkp5770bHaXj5eXVafIQ jKQXf97VpXz+/Pl3gJY+Pj46FVbEOLLvYDiUpEYbXCWv0IzaQ6yBd2bcSZdy31o49yVdmhTi8bPn z6c2/3wLNQezF0GgBX4oM9HsfcnSbqKZ3p/JBGAFg7l37x6HcTMdgE47rNs5WUZy0++56sq3bima mLye0XdneQ827bi7YTkzO4sQW9Jj0y8vL69jJIeNnp4eg9tCl6igUs/40IPr1Ct64VuS3nuUyyM1 nQH4pL1F+sKP5nuxAE12Nr/dmZycfOPKcfr10OPNnfXp8xLuPM4uLn01DsYCtoNkKioqIo6/MP4B AU7/lnSzvm6mirv1Nnt7vs3JybxXYnR/qPzSymhdwFNs/PcfPxZojp2loKDog+9nvXw5A3x9Z62N dB0QdGq+L3NtY+M9zHw4LIZy9ZPV8SYRQApAzUC2u9nKl1vZCvYrLgNUqH4Yv1BdXc0aynKJlTX3 MxAzpYyr7Fmpkp6JOLJM6pQPwDlVP16++ULGnyka4hincbPBg6HYSzeUKRX1WnyaNOpramre0q+v r4eKJXLoZsQfw/SxEpzaWhnTZ/OGGAI/RzBI6rFJsrGFfPr0CT5GK+3TOGynpXUdgJZNVFS3/GCy LSj0eKLKhvq0v4zdcOUbam6jq/3Gje6y8A/1uvSZEaHHC5pZaDLY/xmDU/8BUw21BEZ1UZbsPjiF 6qLtRLOh+ni671Fepe3h3hYawNLQXbZDwNXN358vdLumij0OhXjIuszu9UnYYZxDNyr3118LiKI7 4vz8cQrqrGAACbvf+vspj9Ojo2Xq6+stLCwUahwmtHuE4eJncZ5evpNWGL/y+3f24CoNDU3oJgxS De5ARV8/mUHap7B8peZBvbTr0qAsTBQE39mZmat2FRDAQjKUwTdUFyW89+KBSl16/OHDh2hgF8BO brAZ+pA0Hr7c+vfvsixZLrhdfHz8W+WvHz9mFhs2xF4NfQQGp7iXIuoC0ybmPBP8duX9fkRw19ev UQrqb8EJVcYz4rcETUdrnWABi4ya9NgOYWrARBX19PQeLQ9XOecdd8VchOn4/JL/enmqqKioaufa p5f88MrjldGX5eXl8Rt4eHixTAQCnv9sszZrvsbF1vseN/dsAjmEAWx2MvpezQLPeWHBR5OVk3Mt q8Xn8BVE2q7+/tiNjY34RFjoZBgMTP3L4DNSjPlScRuWYEGHFDhP4SOcOqW/UkcuHje6/emfTX0y kZiQoAis5m1WliKswnd374wM6X3Lx1xnH/iMfq+6QYbTLdjR2RkE62FsbJy1+eLF+f4fPy6pU3ZP TBg/eJn9s29z8xGfkNBlFxeX7uZmp2k8mvPn1RYHihL6JSUkYJKGS00DNPbAns7N2YHj9hxucI3V P77IycnZ7fPx0ydWa2vr/p8/c67cSbvaP7t9A14Xe7Lxtofv48JRYbdkdAIDPtNqTD8eE3wobgZi NxhY1/h42sbfvwmJ4CDRTAQz09OZ8UaaGDNr6ytsQcFo0SysrLLjB17LYvcPDGjXSU54/Y0YvpDD 7r23yaxO+af3jfzqp5EK6ztnFWNup0tx6v77aewbw0TwHeJf1iP4/nfvZDZkXiUlXRcTE4NlbO/s vNFTUVFx0dPTM0tgF/dHW5t8rDQ3dxStkK1yxlUNM7Mp8ZrA4FzFMKrvcE14C6/Dj/yE4a1xn9Ke nh4NiZSmj/1ZN1QoFV9J+zZb6Hp4iNHQ0sY2NzdrRDMd26aJuiiVf8lQDIPZOkNC4mM9tprx0Hdz vi8AVnFtzVHlaMJn/9Zsm6w6cLnrHh4e8cnJBcrXFt5ch9mtf1zwNsVupBqGT0lG9lo5Dp8JiIiH tbjqBb/4dsFJCK1vi4qK/mV7Lw8Lgs80H2x8dM4zZvDzOtz6uTq6goWNFw1GBbiUa7AyNSUHKkP1 geU5v9y/S0P8yMduvngd32w7xAdz5XOwfj1rE6QeMk63FQMVXcBbzRp7Q7SAfn4YmOxsYHhXvftY qCkpFUZqHHJ2dtw9DvcEJd3X/Hx2Z6nButkHjjhuYfgg8sI3Zt9JL16vd75ELCMgSh2WsVJ7ThgD YZv4z+Li3SK9Kk2fPl6nKYUqrODLP/uqbH7mH9B1g2wJg3kBGcfCvnNKjQznYe/rpz2edY1HsThM GzatoA81uaQfzZOBl0sfbsax3PJpQepw2Pl/W5Rb6x5jf/1jGxU9wCAM5SM2931rrV2OextHg+1v 8ukwufdKGLgMal/v7O/+nat1W2WwtbXVJMldHa1zKVvE8Quj5pYjw3H38GjmdwCipaCuuUBy+Sdg /v0HD5jFxPTKP7W2Ygk+/K6mSqFIDvMJIhN34WcJt27n8DAtSDCNIRItbGlFdQWAS6fVcUmF69cz jZo8Qi1bjvauAfN2gpWC8HKt4xTGr7i4uEdsfGVPKx4kbIbDRLOIx+bVlNRUXvc1k0d/+nEBUEBQ pWkY7R45ubklxZvb2hJRU1OniLuRgDfHP7qrsSUa7zDXYPWD7WbcodPWghaQCRJ6MeUetoUKKjq6 cKBWLOzsZ2Ahuz5/1uKgwMGCH9vTot/Ujkh67TgW6teQHO5vd0Yzy/eCwwDtyzPI9ucMs/Fv3I9k Iljb3k6K3wY4x6iJ2mdzLKwOFF0oLCoqM2s/o6Co+AYC5Pz3PAoY76XpSZhRDATmg/VOxliPWTvw Rbb+b9/UQUkkPFFdaA+j1mlw5fT393fc/2cn4Xtk0JeFwGcwC6iuWas/LgER0Yd4truUf4BghQ4V jFsBJQFZ+8Zze+WFkB0tsLxS668M3buEGBjvvb0GoB5r6+tPw8IIh2scon4U3DP/tzQEWo0t7PO9 F5KeQv+WR4LgPZMNq83XvpWH3Yizic7uLKpFjAWxInCp2P0zao6Gw+WWN/JqZH0mmjy28nv+3pXC YwXVDtI61MYTFlBr/OPY6KiqxLKbhQWrnz9Xcv7wxkw3BVlMj43iCChfjgaOla+vRrF1/zhhNqQV fmy+3jiqyU/sxn/ygE9kZ/nPU8KfcenpJTv6UoN3xtqSsytsLS0sXmsX6T1k/EAI+PgMlEdPcycE D5TqAPLJrptt76FlZ7fMknTO5z7nzTEh+B37MJuwzQAHWq3HC9+fJiVRwyqco/4Ad5Hnzfa2sXBq bzpKutR5VnVpuIoQ2BoTS5cFHxENH07BvZLndXV1GiOaEeJsKWkxMcy62u4GwSkHOpQkLKEZf46i GV20VrvU3ehAIQWBdmz98AGHgYEB5MFTADCzRrWbN8OVAtS0Ui/kVzfA9RBlFp7wCoBVmAZYxSVH Glin8j65Uvh59SWxiSyO4tNf0ySx1ciCDZq9dC0l/Zl+Tfgecybt2QwUhoBvmfVlKIp47fDcTpM4 zSIHBs4L0f5TurSx+u8K66/RSUk5zhKqk9VW1tZJDzCxycmESEg0e9EAc753s5+ZEX9ybu7KLoeu vn7m9SgGINICaE07Ii5MA0MXAaFqYGDQW6jLn/C4rr7+fUcHHjAl0Ez3ku/Qg+fU1tezADmPiYmZ H2tw6xbSC+Ru3jkFMjMQGAQIhPzBo1DtUZcyVrCVmZ+9sePYYZ703v+WaIJzu0zwMEAnwn5w3Vpl C+wuOQdArCH6i07Nt8j9XpPlY1+ulf/iWaFGF3daFKO0dp2BYb1YR0eH8o0bbYs/SyZonp2noWEG XffkyZNYmgCI5tGvXuVvTBkNfLczV1UNzUiVaZVpJ74g9BpCTXBwcPSnSy02P7mqHt8X01G7d4+a kJrrw/tAwvW1SflngYGm+/+Wd7Z+GsdER/sBM8mqznr79l13t4rGbWfnco3mcs3YQ9P794MrKwVm 5uZu+JNpdaK8wNHRUWl5udyjR5Uz2RTk5Op4+hlGDa7LSBLMzMwwAVZ0RjF2Pie+wOOxeR/E0708 YfaPUevA+9mXU5H1tf7+nFz25K/Vh46OKeA1BAQE76baw2QVQh30I8JBCgKDL+r9Ry/2iAD87HlU VNSMLM+lS4qznul+/lhlMGdyJiZMiZz6z419D8+BabL7HkbvL1V8dTw+8n7x8uXkYJn5YJOnsFIk XZ665+dPnzAyswEmKt0tAkCx8SPpRE+9vKmdvzEzV5bP7a7pva5+9pKkfbv6wLbM4/DwcCaCU2Zm Zr2VD76ZzXLn++we5r21wzrTPPpSyE6v7GdB1zb9uW2GLtWonEnLhAyrz69Ka2o6Qa9p+Xj6royK RvTYTDRLBhPADPhaG4G1wMQVHNCICghQwoqx+45z2eRzWezu7oY+wJ51mZ5ocCOFf6ytrUVL2F65 dGlyvMlztl8KJW7oRM+CGJMBtkrOwFC882CivR1X4a3zGbifm0gV8728aemooXdpiHHDvJjdUW1L 9wYIHxDWYq5LV09LHR1uGx8cbk9kjYZO9fX1ycJKg9UHPV4ceBrsON/L3O78BGM4ahzZE1BQcE1B /ftOCif37du3kdo557BBcuaMBkfc16XM/LAgMUCPrPEWt5XRp0wE50UcX1voqn/rJaEVIAB5H2rc CvHoTWZmptDrHQQgsKy1dXWTIGiUwDHXu6+k/wKx2m5vY29fPPXXUHvsSOpw8y6CIQhKEKru5wWQ YkKNcxkk3Jl0s1eSRG4lbNaeCwIODnhNRkGRydd7rftmdH7XakT7stClllVQ6QUp9sKsrG817bAE WlruJWasPC3cFMGYJlgtDZZ1ffwYUFJSorEHKq7Ufkwsgqv5W84dfHLTLymi7pvzMRZPJgUYGRnJ yL28vdc3Zm8o7n1M4uZ1GJcg8Gd6iVcqAbxdacMnHjwIjXt+vKkhQ7rE60wfsKwse9uhoaEXIk4Z w1xGr1Rv3Wr3Pd43Vtn7O/c1JjWV2M7Orp2y2bwj/ClAf0ZT4Od0aUZQ4zvzmVE9WWGKKv86wS5l FV4AwdPYToVV5DCs19zQjWtxg/Cq+meSSViYOt37n26dTwADDU0IREaV/tkJCSqS+pu3bskqPGz4 pYXDz8+PMnr3ig1agS4mRIaMAtfSbI7K5Dj4+1XafWMmhNWwueXMNmHSnSxx4EXtJY8Cm9zXT4Hu 0VTlFxRsh7m4MfoD7+rOp/wzg6tjDTm1v3NZ4rp5bAd5JLx2yABgZW/eJPLYXokYrrK5sTEO9klx 5fazly9pXJeHccEucfDwWMTFL4DF39sbBWZe4HUsf/s2idWnF08/fFAQERV9cytZ6NK4VV0IxZWp nHQfOVCxTvO9b8wex3GSgF4jI6+2G8mmZJJyX8PcSORgiwvajmWomert62tdm2wDUH2adSOJnRPw 5FVP3q8bKH/IIyT0vKWlpeddeHB8M1FFdfXzoCD8lYmWKEafHVm21TfyQaoSR9hXz9fAlFCjXBlE 1bsv51qOD0t6uHrPycZ5Ml2TXPFvZ/9Mbez19PVrpoOj/dXaJ38vo9QZKEYTGOI80BISBonc8q/N 7BC7dEpNsBK5DM9cuXKl3VMGpGI4rD9KCOjX2OOq8fjuwUVL3VaNBOyGKbHxiPyYCAjOnJHz8pJA ISz7cOnHn5EabjwSumBQ/Rmmbc+DIyM71qc71Rtc7XBwcK5u6OrooPz3YIU1KVCf9VZ8RpSFA2Tz R7nv1FQgeFUaNXOgiRydnGT//v4MEY/we8E9UjAoxO/QiGj4ra4y/AbaGAW812y48sH9H/nnAHXx wEiePX/Owsd39tYrgdbQc9cE8o1/1Njlx1v4htOLU7UcH4nfThF5Ctj1xrjFp6u7u/XocH9yYSEU bo7NewBH9p11uvfzhGv3MoBoz0+0SI83PgmIjiYDxtk2Ntb0fcIvv+LhD3bwFDzD+kdPU1PpiYiI HKc7iOnEXYmys7NfCDyIZSlpaBBXUP/Q+OQvymC217wHrH5cV3krFRYNC7CkFdRMqcvc7UcrozSI AW/Ok5uZmzvN9pxbGm/S/+NNZzn7Pe/uDph13xt5fBEREZRZQqkW4O2VlZVru3Pp1zZcV8fpr90r flZSwk0r+PAZUGSUAgMnDV05B0NTb3Qkxnhszj+F97z79o0CyGBgcTGXXrVtiJT3HmVDxIYbt9fx 4XZwSAhigWfPniUDvgu/yvXSzQR9Po1Sijt7e8DlYeK0Y6+Ah6JcpaurEFy5aJ57dXY2UNTlt8nW wo8X/NYkAyXGpK9fczdLvHN0dvZPSDjJBMLEjbb4Mv7+/RtiUs3bNEALc1jQUCc+mVYmq919ZcxV SZ29/f3pJGMf4EtSepX3n85+TLrR88jVNZEomBs5zaPl4XPAJBFU17utRkJwme6KuYiyRWmSngJc f+2yRO3bEaVGa1KgXQQRnrq3zPw6ytwC+1UEAyenpNRc8nw9OvJTnYKCYmmkhjQAj1gOokIfSFpk xkCyWgPwg8PDFfT0aI0a3d/oXGFiwkAQfgch2mnqw2lwBODeKANIJ+VV+2GkEXgFSFBsRt8DXrjz KACI1sHB87BGMJ8oIUtGQ5M3j5f7MLknDGWt8Nityjm1qWzt7FRu3FhM/bb28MEDtpOkFYg1IPc3 Njo7O+Ouhsbmuc7CK4C+17KeeHreGF4vdtasCss1GV8Gk4+uqhLstuBzdnbOELQZ6AWwUCbDAeWT OGynNQsAuzkZxBibl8cG7ykvK3sjG4CnrqwczLp6R/pQAbhnFtiJWgStYC6glOq343PZD6W7hoaH VbOHE+5WjYEevXfT/Dwd3U16cVdWbGzsfK0CKmJ6sfipqSnW2Uav3djfX9PvwMdZJCUl0dcDX7yr p/eqo9PAsIGfj+9+d+wllCLI16/hggHk380hqWto+AaLpJnotPCdbWNzkxVmP7bb4nuu+sVXwg4M llZWVDbGucNX2t/8OWJid/d9D36BshcWfDRgx33+uITzgAKsBKeI6UTU2HyNjBiKdCuevxKyU93b 27OwtFSc7ojIBOSN+IKl9WRWkz7nbs7tmKgoUkG74fjwiIjud+/86OjpH/z+9JI9x+pouWaiq709 cHNrS4VSsWp/x3Cr2UZ85nsqoaioKCUZmQyoXRZzc3MYoGaLj/fCUMWVIuMWowckh+WF0kJCifAt 8jCJl1xcXNrL6IVszwPfyOeYPtj9KwBKsLy6+rKhoSGfsPAVID6vxN24FBUV2WaBhPg+AFWoWWIk 2R6f1p7K0Fj69i0rLb9VuNmrUUChvoUfBWzCwjVdi4TkMQEB2CDLraysVFfLYuLujBUueLyMi5MH PLyoTsl29Wpw8JnsC6m85niP53ufFhYWKt+7l/RwoFDly5cvmz/uGfdBgNOqlvdJy9/f/md9R2rZ Tv1YtZx7lo+f/0H/WxULU1NZvpfhMPO39att2SpcYpT/Tmfb0xo97twBR5hZXr71+/fwUu/b/1UL 8PttSckdLi6uSoAqUImMp/1lFgeK7vYY9y/el5M7dStdKpWOjk75zp0ooI4ApSEdkfQ3gkgZE2da PLe5kOk8/JGviIeH9x3cEZjZi46fD7VAAjzY3Zj9nn3rQr5uxeU/i4txTU2SW3++BVXbDmUI2D1y WrhWsO+iArxmBifjzBlOmm/vgDKj7TqUC4eAXLj0Oz7v3TuZnZ0dE4h27C2fLc4tAl6ubW4iMGze /Z3cY09iHj65WNLSARHA8WDHyd3dXdPV5fw1Fwm8Z1rsWoelYIllFt1n5+fnXztMNCf0smvT5+0V Snr+u9mXpP9D5m7H+Wt38otv/CwxRmTe5OHD/A1vrXAtfPT5fMAKtJdRpF/zvKyMd2p62mlzXh08 5Ow17cKrP1KmtWiO13TWrb6mRYAyemPeGcnDzy+voXEW7Qpsbj7y2ui+Ysn3K5G3Q6APpgHl0T+/ EpQH1yKjpg769cuEjFzIYfxTQJpuVTsWQYEmfEH7l1Rxp1/vsCysrN6/e3eCTEDSVQV41r3V1V1e VRzzu6+ZSDzZwAFNh3gweBC4SWiU9JHOAzJO83agv/cK/7r/evf0PkRT3Mr5QypaWr3CEHpwE16g bRsOari7M3F3KOPKJHyP6EB0odQ8r9uKwaM//Vnlydu34U60PB4Ui9nb2x/YkNx9by6DCiWIQzJ0 CjHPOj3ORbW0+MY45CYVQFita9oPfgBGWazzzY9br5IAhFehH1XZNu7/UVQR0EvzXwHGuefYZP9T DRI4iXnG+29cr8VHEkZ/xtvbOzgj1/2bi+JZRXKQmyVrHtc0TrbeObQZD/PZeXjIMq6adUbSJ4zF 892ljyQ0X/Kl+Orfft6T+xBYzgtRl8todwdUuSyov+WRmpIlqzL2cOt0GED+U7jqoCebiMh5fyYm +D/E4YQxOjSQcxRurWbhTUkMkh44GDovVBGySkMCt7t6ztfXNzgjGKIaGbmC+rOrob39/Ro926Dj Wz9+JIToH91tcX+0lhfodUxCwiW2b58/E4OAQCwDNN7k/DzBy5t4jIzpZ6t4RUVpQMwrQWAztbTE BeTQ0dc3h4gSHBGRMHNHWdnvauja+rqsgQHdc1JGEkJCQpQ94+C4GbO6Mftx51cAqcn9+wQXL14E w/4FEW/t79+Aq6GqT2ZBzOM6ODgMDg7KwD0nJiaiIgb7iWbDDLsGx8lTHv+WTgPGnaelfQ8jVldX Z//7e3Z2spPRVyGIhN7EwuIZxIjXWgXaSJeO8L+jHsc/ffr0SS3Dp0+vc3KCgMCyiIjo2CX/WxoK gBl69/07pYeHR2lFRVuueub36musrDgrKyuhh4M5dxhHG5/cjf06MnIh4yoLMzOW9MEaNqxr/lVf AIBQLxScgeqamJhg4P5upkvRlxg1xcZTU1I+i5LaI4Ag+vzpUyygV73gJLaDpbLl0md+gnyJQgrf 8mNi78+fvnMvMsFF0Q4imSI5wB83H7d5uBbeCjKCktqGBnkyHNuRauKQkBCYIWxytq3VicoHFNm3 U89AgCOiF6MEaiLi+Y9Du9ggJPN6FNrE5REQ0JxJKhEHhzKoc8YFysYMZJbAxeUvLBsHBxFQDH/g d8+JaFAZwIf2dlO0a+u1w8PCwtLb+MSl2wMYnizcWG+tkzkQVTxu42bNSn74JIi+rq9fO4FqmDo4 RC3+LAFGSQ92fU+0efL/1daaiLg4tWcDl0GtH6qOaGvD/pZ9qy1V3M0RQAFlOlFiAP6jfALhqQ+m PkXiyVmQYmj1AQvk5OR4vPceGdQ/Ov306dNYMYAsxHnxiGlNQDai/AqEaR6Td5gUKW+9DSFLsCB4 HRsiERoULH10fPwzMHsRMbEMUNGhjQrPLl6P/NX7Rn7+RwF19s2X/r5Hu/itra21zrNnjnbnGF+8 eHF1g9AfI0vGY/2FDhg5Ss4CQH+AeL6+9dN4+nOycC7wC/AUXsdfMojjoTuQkcFs/P1LTkb2+ru2 sbEx2Pwb7/1/pdXVSlZWl0HEBgAJ+tWTcC32kLnkuOKrlLy7uwjSa+NNnjf8l9/z8fH1wuwpKCmZ zfYkIP4c5uZIY17IQm4e3hQ0OjqqTKmo4gGh68/CQmxMDPlYs7f+gyEIHSpAoySelL/lkCXLhfmN T0zMVhfHkWVyc3PLqsy5k67h6lrN6gDiEO3egJXG909PT8OHzirGACni1uWWlk7/b7ejH6RffKLd cKVKmf39+7mIK6UiKjI6mmI/3phX+QXMugt4iV6NvWGhnYTnv8KMSCCR6g+GYGbgG50dHdVUjSvv k0Ow5bf69PrgwCvL7iWP6SkgBhBatetI0aal5gBcBrjfwlhDTY8dTK2kpO+RwQNdHx+prLdvrx6N N3uLwxeIiYlRnj2bEf/z588kYJUOLYfabGMjI8lwZ+Li4qq3b2u/tbawUAN+kacUQWthb3+7xn5M g8Pz729iwQf9z8BwJL33NPMawVNj2IFrAQuBaHCDfbEEON4lVlblgThGasBEFvbBoNu3b78tKLjR 4LaqrUsNPoiLaunGbyycigaamu8dfefOnSvy8vJoL0TYYVy5B+0OdiyrnfOjzIKIAfLqel1dXajA bltNQkKCRsPM+7Y2mA5gYTkW6LYE7Ud1zvoVGjZoW75jQslcmHrQTBNDVrsBKyOyz1O8jgMDA9mG LR4+VH288P1NY6OEylF4OBG8DQC0WDluFRtuOctPsfh/738V6vLDb4sNG/59sYvGZ4Iom8DR4Hss BRMnH0Sipbr9799ldcoHQDFiH3t5eYHtgG3Gcfzd3r43zLh69tw5RX8m5VPcTw4vCNmq1RlNYmaA yyFWCtEzFhPG25FPi3CoQDsjMxOL8tEPj2QgCwYGBo4ro6IIGfuJ84FPWg5EQsS3Ha0lBzRG2/f2 9sVmL5kI4McEotcOQ+WXHj16xGrZXZPnSJ3z3vLx0iC5k5OT6h9qLgMMBuXCjo6OYrdmzGVgNiDC 6BTaLfRnhfU8EhYWfhYYyCwmRgtisBWCX0xiIh4+Pj6HbrlCbHowYHmOs0R4RUVFz4oFSLi7thSY Rvf1U8L2o35ZWZdAiKkX/sNWW4jVqrXFoLK9f2IwrViYyoc/VMs/DQ/TYgAS3sanJSY+h2iBso5o Jwgl3tr5ZMnW1iblE7ZaFl2ewL16bY+5Aah+qHOZ6y3UrWD5y9+hYzkNkV67CBbiFAaIrCZXUg5Y onJiwo9wPeCYbfA+EzOzU6SkpCiSGRszgkID3ETiCnDz0qKunl4+Bzc/P4U/U65dev6m9de0p8Gg WBNZRl6lphqGc2oYk6r12rNoLO3Dr7AwoGFCvVSMJvEdRSH8JTypqqqKOdlX8DmYId1vZybw79mY NWff2NjQLIaBvC2XXNVLjIvLVP746ZNCspBddHQ0qrhApUeXL1/uHRhQApI1UGxYsMGPlXts0GUI CwGSBW3n0ArbG1gYdZwvOCOCMQ3XuraB/z4+nlJEVFQl8cqVK9dmr9k8efJkbXs7CDQyWMYl7KGL LCzfiwtWFJ88f/6ciUXC50Bn1lnrD1yBDAeLl5f3/nBlHp7+67T6vbsaGkwE/mbpPcfiAJqgY0tu LvgkS0SrbRfIalWgpHJnZ9vEBCMhFYeanuvke1zkL8v1qx5Pp4Atrs10UxxsfrszP1LDDWKWKa67 5+1YOK82gzutUYdOFUzRKZb3QxXWlz6CYEB7YV0WfAmtKrrK/49Sq7RJf+D9GAJS0iSOiywJsrdA TcsqsOf85mTT2sLG/TZMZZ+TmXkRoM8JxlHVwh6fCPoetOpzJOCHq2xmNa7r1oNMwJF991o2gPWj pre2IDPBKfjD4/L7JgpfTZ7bHcCRVLUum4cnXEEE7EfPC17z15mZAf+ToVT9COgbVVjI4bXZd529 Uy8eF6Lf/OLiRXZ21bwwdXt7Lqn9Jf632dkPDawgvPS+lsV+9uzZL4i1qh+F7IbfbqQyTHdGBYFb HhweOu1uWHY7s8gBaistB4eFxd3k9JzvZQYneqOeqRTKywJM7oWUtxiQnrf/Us+zsbGxd/rdn4Io hE1uujHTHbvdQEauoaGhquWjW15VpUVz/vr16+btoedWDxIyRZqPjzy9tn7cIzh9+im43lvP1APD a//+/csqBqBQDWgwefNLvxt5EuBr7aM/Z/u/fSvz3ndFqZdlMUBGoO24EEBC/menTvVjCMGEzz6n kP1o8MyMBUoR/fyJ8jNXVz+bLvnqHe5tlbku691MFiIu0qt6X2raZmJl9by3Vw1iY4ZK3GWdMjPF uh/cvg5tEE37gLVsrk4wOow3yiorE8ClJ1dWiteFx/2ZTD4mciIl0FdiLE3EIHGemFZABsLg7XSp CKMmD+T2ZO3H+7e7P3zAAQNog5VE1T8oM3IrWSiQicB97RcWy8WLgD3ZfcKzRkZGL0AZIxmUyKnP wsVFgk/K8CwtjaHafiw/3q3VHxc5ePatZMeZLvJHq+P0AwMD7hszp8E0HY8OnnDoVxdqtih4H6x3 om00kER9ueoX0ciBqKAkGmIIpykum0y+Dww9eDtl6Ts7u1wPojQMIh8VRNN3L/mte+EjQNom5/sy EbfxOT7c5stzg7AG3F2n1pEZGHIIGMW1+oLuzt74e2ufz5u3t7f4vX798UPspRuOf3/fquIvbbSD CYZ7ezrcaOy9dQ70KT7EtwOYqFzjFimIpYHSRzuZhclfB485Hs9NxLPddZz6cBrlUPFJ6N6BF6xt /rnrtTubFBwcrCZKVvd2QuajMdW9QVj89TG3CVkAPFTkR8IgQQCog2gbKnVe1NC6bTpW/1geNNDo 2Nj6XLqvWdtzYvfDPUEgeCbW1vgYVe57OH7/1RvjpfvssZ09e7b0wbfLtmP151ARZRSDJNoGjqiu AFqFeC/Kbvr5YVJEnE6B9j2BaNDqWQfDw8Mi7mtMrkuDWGDFOPj40/urLZ1AOmQUdn4nO6DNrYh/ T/MtR2ocOktajkIv33qFMsmoyu39+/eogmxz8edq6mJLwUq/F9eZivJyOaBqe5t/Av7Ofb3IxIQB Rj5Y63QxkdvYaGpPq0jY98jLa3+5ptZrlw+tQGWlAObd1uJPLL8WAiATYk/ZN669YWcH0f3nzx8e YeHrmpqUw9V2+jPcTHfSJGSBmyCtyqFTKrNB2AVEHiYj6I7ULg7KV7x1WxwgXl9HpbjccekjNOZE V+czHoO3Q/SRu3OnpDy5LT8XcA9lJpWVldU8psXhkgJHuDi40tdbJHUqr8IvAuLi4mZGxOtev2aa +f3brCeeTfXP3eybqNwb7PvGD6OOweO0JG5j9uw6TltwheDw8Gc5OVfwGQuVTU1NXwg8OIvPGF6m 2mkuIwB0/RJi1+Tk5A9922s9ttgffs9lflKXVFBwLZigr68vduUMwHL8hw8KtbW174DrA9wpAJhB tCBnYCChoKAoNGqqL0/uyq+9dq9Y05XivDkRBp+JNhnQSSmS7jSYDCsra+6nuJSUwo1Aww3q15Ie m7kGI13nC3w4ODh4rD6dRzWGS0MVyHRQLbTpexwETqFOSJ/raHViBeOhMvsLwvYo6ir+9tzduPTo 8eNLfzao5Zu8dssNhjvPFzQDuK///Sp9z5UfSXqNaczbF2nSvpElzXtnUI3zAhBrCyMgwI0+h3qx XOmExobSy9+/ayJjq66uHk1KPjl/ccYDvhwJkj9/QiAu3HN1Gb9B50f5rWbCB9XIEl0Qutm3tdAa gI/x29x8BDf2+naqWG9fH6pz7XlyBOuCJWOHcQH/ArGV7SXkd5JhSHhp7HuotfxMofA++rIAfNLo tLRIVH6TRejv59C8iwfIJo8KgSvvY1lbWx9sfOSuffI3u19mk5CaS4YMBwRXQWHbwACVTCt+vQD3 nAfj51eChDYDhXlLVlfzgoUSHtNbqhupfOx91DT1m9u+uS/z+jQM+Zrr4Q9FLXE39nxJreXRvIdz t5z+HpWkCWPSxbWyGrfXR0MiItohilF+tbvpgkYGg+aBYJ5VeeVOmkn/W5Xz0j4SeETnX5/HGW7x 9f0E1wQouThQYlzS1eI0raSjr1+QinVjfLmnu/s0QDt7Dmfeq/Dw8PxRoXsKyT31keVXS95a3q83 cvpLLZze3OyTsE+k9SzfdUVT0zN/uO7ujy/JU78PjSUdMFJu+apPVhfrsHNXNb6OR2BHH3ODX9LQ 0LjvrDFjfq1NtoVyaad7/6NB9SktBl0NZoJ2w5SAG1pv9fX1zX9/eokKXRGAgKlMgZmI+B5JuC4P t3Mza5rOdMUkjOGEhN6/q/tTnWo2oZLo1s9r9kf5O0O5qvnDR3m5/zSrXHLyU4Uvse373tIakfZa iV/18FrR5Dy4vHn89csXEgAI9qSxFl9GQL7YzWfPcAZHRqZHHFq0PCjqRyFolQGssV65kgmxeWeh oITH7ANBld0OoFRf/WMbBUVFrTwHy/OejF1f6Tt01teftL34vfOkaHOHOvp49ehwn7bkbouP98zs bJ7h0WyS8dRH7haOWxX/cwxI+0OPPQZMCPexecF58wX48PkCIiRn8nF9os1uuniN83SwY/8fuSyU C/uhbWbGonH37rUGmnAt3e3Vic4J32PDoc8mhT25hg3VPSFBOkNTiPRyXrp8+T0sHrdRY+5SNo92 lvfh1k+YrI58Im9v7w8dHc5kGl9OqOONvLw8VB3lc7h1D/ijlqsLXE7LaUM4JSc72xnzP++yAeUl cQcgi1c7cI3p0f+ZSjv5Wdv05G2EpuumwV+DS5asUEJrif6/F29b3V4TnWmTRYehtNudMO/PF1B9 evjC1Oa4iO4ZeqMWHdxn2cO2gUEq/X0HxSBjMZPJl4EoU6YjSHX+PIE6ZZl5J0nWIzAJWKB7GgU9 t//34ZhrDWyFtCf3XDRIO8JyhRu/1ak1YYzyX5qTi0vAVe2WkYwDWd2xlnTfI93yL7MfkyYXF8PQ PlZPz5mMq1S7Rs8gDNgOleOi3ZpMpYj/OU2A0h1oK5I8Ye6yNq0smWZ2nqp1+CGjDymBeaHe7ly3 tPu/DV1L4YCmoPz9gGk/LOxfS0scKg7fsiNY7X4WG+q0+EiCpup9q0IBXLu2q3x7ZSyM7W42whVH N7egiAhitMWIjU/yazpKGm1drncy+sYPVWtaWn9JyVu6zKM9ezJTQlP8U5PeXQ3lya06CRcJToHb opMHVNeOgWFOLi9HAJOR09ffT20hAvl6/noknSzEyIT+JE795+AzZihvBEEWj4ROZ8rO3XhwaEgL sLxgI3/C4XN42bHKnWPvM+nyUudXJRgwJhnWGt2c+WIQ0JlCWUCOOq6OS6IKpSqbn8/fvGGWkJR0 mu4gxsg8fMiOjpGAWpO5c4e0uLgYwnzh20bQwwc701HzvW+wAS3UMpWIQcmdwcLCii0WsjR0c3UV SuTQ9Qci09bVhWob7g+WMiuFn386P39f5QiVHXVFM5eWl/sXF3PZ2tqudV9JZxIV1e3vKC3lIYvR 2EY7VjaNLcdH+w6fXvBif/nyBR0HAmZHR0fHA5HZwsLi6qxhnfMlsIznxBc0ExNSUojs7Oxq6+tP YQD8UZ3bi1evpgDmVZ8YN7pjgVSan59n4uC4Oe1KPZChSFhpO3R2eLh9P63/8+dbZ70wfnV1olK7 M6iUbFqXbqFDrytP7LaPj0+oeb3DhFSlzU8SwYff/fLy2CAihlyPYlDp6ZupPac4dj76fw6P/d8d tjJ2iqT8/b/O9wUDf32jGEbV++1bAOjhy3fSwuFzCVvSXjtk37Jv/c8hJLUGVzvEP+8VG6i/PO6O u/KCx/QUBNQ3YKnU1NRV+6/Kyt+3IOQIHMwpGxSzvOZzvLrK0y/on1x0geSXjKVwgWqd77EUxL0g RKH+OzDU+RQb/9fKSmRwMIH7kyetsCBo41VPj9Z1dfyEdv9bHsnVr+HCoKoJ773NVrgwSP9gCEHy l+OYWVlxvuXc6cy6kUR2/rwO12NsPyAiQFL6gNndTBEhB26nrKoqB0y/3nX5DAxTcbxIv8YMJAxQ 4PmfJYwLPwqCamtFUEgUcZ4h4DJqDK5/vPh+cPA8zO9gtd2FsxQUk3NzOQRvbe3sBMe/Jgs7KKmp kcF78ECwz8zNgf46A+gnGckoHQm2kwGEGOOHcroQkwWBUz798y3nRs9wncuVYALg2vcq55KMfVqj meV5Hn6/2i5jinnBZ3nGfqKZ2NfX99HysFYeHYschGoQJusLP65BCESJU9AGtA7p2eDJmNeDreHs r1wj4txyCAkI3sVcvI52alEpDqAQqjMwMzNzBEGrOIL5HJmcbecNtAcINDk9fYR2kZ4pWGzXp08f yi0/Oq6M1rF0xqIDciJPNlj3/i0TAq8HzWgCFLAW1CoIn6LKL3BvEaRSOyhYopwmxL6YV69CgRqi DX1ZWdm1jQ2NGd9/SzRij+b9dnbcEWKlij2Wc3bmy7758hQpadTDsUsxWnxmWkrAY7Fe5+bm9tif MV9NNWxwJSePuRNNWrVbR8w5UnFz+i/bpcDcu1dYPPf9j6V8DIyKigb3pv5X7hHYc3GlbXfsJVaC Uy9fvOgFwpWQuDxaF4cj+xoI7bV+Kk49BX+mXuAYV6WljWPS0tPvUFy+yaRO+QfC+6wGOg8F30Qr 4V7as/ypq0vt4Hh5pOaP9PEuqaiIiNpJHRy/9ZfoxEQqEH7KbGOfP0coqGvqVl8GC0j4FzE6UKQP n9erepigUQ9GFpKhDCojuvAbQGtstwVKo8ZL/XcYoXlv4RoLy/B/eUmQGvHxzMaXQzOm0pkI3hYV 3Ur32jjd5LG1kDoCtwIadzV1dzwxOfkGcC6UdJzpjqMtuaPZ66NOycbDo2Y3AquX0H9wcKBMhsPH xxe79BNoQMzV0Eq3VaOsR7eikutdh4aHY1NTUzWGwQTQPUp6VGp4AFt/+fIlvFHA58A9y3J8fBxd rsQ4PTY2lvLPkydPvgMBhYnlMm4uVP76+XMWHjEt8EaGVHG323mFILTLq6uzAVp7weQp/1Bcuc2q TvkAVKfqbmZGhvL16+gcANhst1Receg+XcdXm6xOLOVz7xnvd6jeZvB7NDaQoLRyQaWzLdLGC+ZF AedgoiWRMyQjo2fV+GNizxZMldS+EgOiOjcYSmGOYeB8PDyvl5ZssyxhdG8zM+XHGtyuZPgztX3/ Hg8EWx6VQnrAFKBjKlJe7i9/3tr0xeoaIXXKB4yLU1B/Czry7uwGIEpsZGSkRhOqXY8DM1BSUjqp 598Ek4thIthspza+mmVc5xwIpsMs/1y5BxbjnKi4eBys/SHoWgsTE5nExMT42FiW7gu0tKoQOSip qa9zGze/jY+nRLvDALe5g/sVb7G60PEPMpyFkZqSjsWehMsY3VrHN6y+gDew9BDrn5Qt3HMbFTgt QytwXwbAKD46montONmhmRliOR5TxtV+MKtLi7Yj1REwGFCnisNv5IM0fSJn4PXr8GuIscHBV69c CYIrysKNxCckXOrmLknHjo6dM19woubo0Kk6u81BMrbgFqBLzB/xk1OAA4NxXKbtrX9MI1iIs5Uk CIxfJSkUVhKDgQjFOnZDQf1ZYCAumAEGU+MwoQRgC6+XWnSfVdlVwAENA7ws8ckYBpEGUAbmQBkA qK9DBO+rc7GufPBNKe8aMcag1hEL4/hvSRcUu0p/GjB6Jm5uUnQmZ6Fai8rZxQWdzgXZhX988JeU j58fpSB1jtYm5bMOgG08i4kh99lfFi7UKZMrS692mCCRJfu1vMyZJ3/vHrXnvyXZZCE7tIsTnBEM 7373/r1cbI3Nz2JVw3ILPho8UoZwIN9vLD8movLP5oONGwIO443h/2SegpMj9X497vItdsubT5kI 7hdN4RTfK2HAMElKGrIZfpvWNviaLt3Z5LltYm6e6cw+/SVVnLrOx0k61eLj/6oFqGHm4zsr0yrC jMxbzMnJiYkFpgRtIgo7jH8AkO8Fz/leqHs3dgLis6WbakfPqRPmeHH/llBsRVxf11vy6JzdPW3t d02ex9tuHxPfDRRZ/myu2d2hxBENXORGFhkrwMnJWfXRz99nX1RUFHNmLwwbl5RPsSllCZVA/61/ 6v8a9B8OXK2j2Xufx2Fcgoz84UBhCDAfU7SlKKM0PgDgUWCXw0TQ9eWLdkPjWyAbzwGYBe73YlCt GoRy0LFYGNBxKJGcsPHRgg8UJpF+te1JFAUNCpoT1cjx8PPfXagwfhEQgI2qkiAWCzzoR6XdtFUV 9mP1aN8L5juwtLSUj1jGZ2cSH3EKgKs2iG2mtrYGVpY2clpNG2VXnzzpoT59K0rfqRs/rOAMSZhq 0rUVoS7pv/v/lu/qa09+9bKysorZ0tfToxri6lANwCYD63USXubCvI55cPFXyO9FRhEMEa3m2o1n CVqtE79/W452yd1Oix+4l9CNHQh+TbUbfXfcbmelYXVtzG0CFdESEBO3A/UEr5VmgrtYjyhqLNLV 1W2nFTHQzsjIQOchUfTyPdrN6d+sUniWcO1evoHDaK3TYOMT/lPY2GgW0GYohJAXgjaJLGqeIxuz H8nJybH4+fnhbdgfk7iDSkpKlJYF+a/tZKlp9epogCG2g2WjUr0UKW9aYKVcWk8yrvoHRycnX9O9 7BvMVYRKHXkEBHAwVasaT36Ka4d+BGbjz4SUJrs1692EllyU4O55axie9/7bGl9HfkRtpQhGRj7u +SW9iVE6AlL8lXHOHYcneIwJ6sYPRMXEECOh5jKI9vI0oFlaXuYFTE+R9KTCw8MTeTQfbaYLM4wl k/nn/izpnmZojetEnQs+Bu0PdjfwI06TxG2cb1Bi3hl5/3suOQm92LO5r+kXeXjI/JlyvR2uKyjg QPTEAR56sN1yHAhmAP98BmYQMey5PqWIURO1s1UpNKg7W2H9ValAu4js7FmNhV/YmIc/8nExsQ+C nvoLVycFonvO1a24DMNDZeesly+rJqaLuxV/sKQeaPb2JFMvk/4LuIxOqoLholPc3RvR0WRpuGEJ F04y3kqjFSLnP4ab5lvrDd3KS6ysrEQQgGrbEMcruFfC+kRDQ0MzEouNcH19vdb3uJlVkpOTuMS4 5XlzczOL3XDlg96BgQ50DJaa+oou3A7+5OSk6oPsbNz0C1qkIe2X0qu3l92MUO0I8NprzmPgTJMw FlQAAEBLuTrlrq+khIfySsDXFYWLIHjL3LhBCHostrECVe9q4JEj7wsOD+coT066DDrilLGxcaXd CFXOnXRtHJKsH9m3LgBoQaRhwz314MGDHSCWH2eY6wQ6i0RQdha0STe3JimDxDugkD0WF/a2V6Mg 8F6Vks4HRJV1Gn9oY4NqI7p6evzT09M1mq/dKzYBIZdlT2G+4HgC905XlkloXwpMOSz3oLIxMgqK ACDwk10xF+fHm8QLi4rWZ7opUNr3YPcvOhcNrL+ncQWM1rT3tez9kWpOeEEt5za9hPceZRAJvZy9 PReCUMXxjogL5osDRYjXo5IUbm5uERERJpjFkJAQEbcVuk+fP69/lT6+OvCnLxP/HwhJVPR6r8QI dIP84d4Wr9WnF2Y1ZXYj1WhriIROBDVieOMy98X9YIc3kl4c7/r16+3vPLWk9uYvchjUkoVRccK1 i3ta52Ra9XviYmNRP4/22giwvV8Nq81tlced46lBilrVvpjjNCyLhB/E1Oc1lb0Nyap8uEP5E7Mt tbleZgfeKM5ryrZ8+Pvf734bq+yExLoZDT0uS8uQkFe/uBJn+TKZWHK7mbg4Tkm1SN+/3EGDg/M7 haY5fXGK/cuTL6LbRF94hOfqVq0/nVe4fj15jPjhz2L6V8IOkUCV34D6QFT56HDfaWNGxd3Dw2ys /jHQXb6Gjpf81kjpKcda1F+Mj4kx1YvCwYx7rkru7FNz7dR5bD1EFR4gDO9PNEui4uOw2h8PBTMy M29sK1Cpw9QTnefBwIIouruLoDpPlHsMYvTxU8osq8dY6krOfy2qdPs47j5NjJLZxj67l4CL2+kV mIPV9t4XGCy3vBFS8Dnpw9AQDdIjNfZjvU2ebgpKSiwSEnQA27Xu6ywkjFLhHz4ovM3Kav38mVhm UnWrwXUZFR2i4xsoO5+Xl4ey0nB9+3+rwbly3d+9wwpN9IUz8Gt8Dj3It57Ezx8/9mXGMb6jeOnS pdMJqpeeE9GYPW5RzeKzcdOP1yuiIr4gVDnY7Lqsh3gBORkZk4GhoSIYgqKmZvwLYYe0oVe4554s A2VCx3ZQdS/5+fNXR0dHFUBQKgCraL8jfWixRQfUgTIAn5TqYZUeyJgQIEEIWXmdZ5TLPLftK8pw cXHNgP5lAO3NAPotl6WhW+nGGREeTrTec60EVShNrqxw0Qrbc4x7LHLGpKYaLv198D3rBvUbjbxn BQUFtR5b+e1HpNIHarma7H0V1ncKOrcXftyAf5Td72P5Vi087i5/v0pPvcRIEn2RhKSkIsxze63T tIKZWcaPvxD7XxVdcF5NiouL070xRMNvNep2ECCVpOS2Mkru0Lj+/H7v66eOjx+fe/PmjdnRwS6L tPTEQguzuQTwmDKRe07Hlz/uuTQYXzCykZ7+9Onm+kJBSSgwztPCwsJ9lQ/urkMADpMPIjmtEvth Z336cwcprUDX1BMhviMvq8+vLMtWS1qOzsZduQNuUUmWlpaWAZ9l4eC4KbE96mIGs03FWVliUMfy nISeHfD4koSEhAI4cfsrQZsVT+Lr7UKN1RdPq0d2F2u+QXtRQnbDv+b7MtGJIXE6loZycLnGxD3a 59eJOj/d5t/1YGFpWPuTk272IfikpwJQistuIlp6D3wd1rZv7JbhPQumk7vtQ8I1UW8wiBUWrGza X8ixGZeSEg4BFPXRkPTYjGZmZ3lSit75flY/kPMiYyU2Fbm65cJYg/DGxgYqcNrZ22NhYzs9UuNw 3dVV6Pfn5M7HwrmqpqfkFEhaX/g92/tLQqBVqBhGlfCw6XSRNmGEknlA8NJICMWV0seLAxoRqVLe Hpeum4tzN22ebd6ZIrQdb6QBqYPKpFuODx1QHdJXib/ho5PkQ5QUZCzOBPfsDZ+mBzGekhj0T2If wGf0UssfaIxl5cViC3z2DOfTK8GCD06xrKKap/jA6MLpRDVWeIIpn54mIBd99rGGK9PJ+3ZLRqi1 3TK5h2NfXx/p98ikYDr8sN6QLuZSTGpwcJcUDxYzS5Dj7j/LAV8ycvIhrMtMChbb9r/HFaxuXxY3 If/fL23iSWJc37GwsJTj35QJ7lp5eZZswA8+wcYA4yz3FAsgSeNKW3PbThKnhDexY/2vVx831oby gFqWNIE5cr3j0MsPF2Qppzj5kj/9j3OXtfRhzMHBuZQv/MhiDBtiPLHv2RtP0pPB14i34jwLXhoW bRPFwMdns388fKMhOl7SDoFPPkvj3H6V165zmDnCC2CF091X0hVMTJg02c/5+/uHNj1vNTk5JQBg yCwgQAnggtqdgJKXOj5wIWBm/8t8NibVKVEcw5Kx0UvzCPPCT21XJRZHJXaGJLNfYn+pgoCUtGZw vNpOP8wOSGgnqg2cmvIHy57sSbi2LbkN5A1lQr4X6VOjtIGaGlmxQd1J74vZJGOImOKlEKTPeHIo WEyc3Nq3rMVfqyukJQ+NnIPk3urEsk4OWae33+Bu0sxfBxTpeC0bsFbie0gI6HtpnMZj/k0Qooro bKjVyNynlwFAZCdBf7Umcur3Ap3B9yFSmBGhWzX6i13rvS+UfSc98kqa+ymQfGp5mjoVVhFD55lx IBoEWqc9wfsv3SEHgWvti/gqk7Dwz4Un9wp10AmL1rExelNTU51yixBOBhL1hIyvvUmeuJs/ThfE PJLsXmh+u6iik1pabzCXtO8BPM5PNet9NLM82und/PMNH6XvamqE612XQ6WPdrBBvw0LEjFK0YG5 BzY0iDP47JgCCumllLx+jWH03iQ/Olz1bevsxAc4gEV/1591gzN7WHOzCjV0AkfMBN9BJ17hKwEW w30O91DNHdU00I5gKe89JiB+xcXFBGfOvAfSEJOYaEU+DVSa+RlPctrmfGZU4u6ulOvSeSPvLa1n QUEXmZjebYqbTH0IqfU5rB8a3P07B2YzCYS70qO4slIAJOL0ZBAjHob10qXWr19JYeog/mQMDRYW cqDzBlxcXIMNbg4vp7nyQbChsyspqTe23VSLtG1ivDAyRXpVPOB1BMyFRxI3zL+mScK8AxOnQidX VsYa2uAb4S57H1aBBq3xGI24IMzzZMMC6ZOVlZW17e3rEP1KIZbih07/ag2AD6PDmmXmiMC4ubl9 +7rrc3ciPCovF8LFzTQJGlAt/LfMF0fr+F1XRh84cU5/rxe0GTDpjKRHpMXL23tyZsZCyB4YFzop dOrUqV+/fz8PYvAgQF2g4OIcX/K0C/pKTeULouw6wmmyf6qod/xUQScpvNYVvxcbXgAPQRxLyHbQ xCktQ/oryNfXwIFQUzG0wo8Xn4Pc0Gs6CmhenX8kJgHqGJ3mRRztcPh1aKs409WDdmHPf7Y4+PgX JSRGF5IttLWpIPL6+x7vT6AmOwDygTs77ohhtBxshLVfGC63/IhcCAUExN3QcWbwGWZx8QsQOuoj GGhipsFregdbeE0OVzFZGeo2PBYjZF5Hn+bU9vNvjcQVX3lZfY9V3/jrVV5e8iiJDQJUuoLqvgGj Eb/IuZ2KirVBCbaCzUHICQBQgMiwNhN3B+2sojoADGoqc0dyi9LnaNcarQ5SoMnJF1AaF6j1VO8b eZ2mYb6n+cE22DIwu+SMjFFdXcpIj4KnKquotMJio6xtpf3YsMC/v1+lO4PJL6LJz0n3oSWmFfC7 ndMWeu7aie6DhUbXRAWV5h1ESJh0d3e/4DV//gc7Qq+oeftN/Py3O9LtA0X6b/ru9wITQL2brkcx tL8PJERbOHQS7iiSYvyojb3I7+bcRsGSx3VJJ8zFe72dmkzOZO1Xa7a7Nng2eMuvQGojHu8X2H7A PybhblGptZjr0n1XBmYclPQFw5qZmXkNAIksaAFQ9XfnPW2weozagkW2SBApYwcQ8VvS+2BYqNMC 6tuFTiDR7n1lZOHj5yenoQkBfZMJkgEJ7WLDhudgZ1PrnYydV9K9/E3bnif82UOrwuAxz4zKLrq6 uvxAGih6WX9JaXX5KokPCgQTyDhcpFthRYzS1ZOTpsOJKSlEEUoBcE0FRcXJkCtp75ZHalCVzaPF AWLQtJ2wIJ+/XFQ5C4TgGb246y/A/Q+56pnRKSm2wy22Q3zo+KGRkZH7St0cavEF8IO4zWCzt/i/ 1QlSBweHir/n5nzuUvLz8ZHR0JyWlpZGOzToDAG4Ca/JO8zb7Gyz989OU3Wik3ouvz/JJnEZou34 +S0PFLDV1dUH61yuDNc4ONDuv14V92ga33S5IOLIVF5R8ZmBu1s5utZlLrLWeTaUTC744vVIAqBH MLmcHR86O/XpxG0GOIDefYDZujkCn1CMoBX8AGtuJ+T6691TRJGm9rYWtadFPDZzMUyRDJJ640EK mpbf94w5ec23icqA4VYsW3pLXrJiDb1dIBbyIVyhYOKegL4RNxubinIsqyZ7wguQrkPNgKaEKrHP Wlpazkt6VA41czfvyMHvjTyXBb9V//mWA7/8UFDSzL4y3mQz7LO9Ysj7aF4Njaxmwkef7efR4fZE IKtKhtvquDajdd/2AIScUPDgkNJSHgS8QitJxj7kt2/fRjrKaqRKrwgQTPurIRUYtNXXiL65dF8u VpWzq837xUP/4GbPAA0/2pkmDTMHk70MXPpZqwnPiJTH5n1mldgXfJZosrQKtIFLopYSnF9MR3M0 8m4ax7Ketra2RpQ6Ji7u7pR5LKuKALDWD07bPV+/UkOwpWZPUD04+PvVUsqIgNnM3PzWeoluRYft BEDLM1aVqYR7RrwjUl47jnAVwKD4IdcmI24vL69nycnJtY6Tci/NX8JswdDN/vRnUe0rRTFwwgzu ALNd9YxMuHbvDIwHpKYCyL0HDUqZ6IbNpjsirKb5+flBBNWura2RwQQI2gkfGaSmpBRK1UCMRDHq fWfn9RRJzwEWbZhnAIRP1QU/HpKfPWsmuAI8nABm49/SkHn12E7Fn58l6UP/3r5lnVxd5UZCBLj7 A8++9LnrjN4Wrp9QuQJMJIRoq5GPf5v/Dug76HpLDMT/28aTLklgpIj2pEzyo+zcIXTqjr2UbSd9 sIZiCTpwYWU+PT0Na4jUn/bXdt9eBcu4l3FsPNhmYw6LPal+BOovcB4ZDKlzSJcbVBqOa3u5/RZ3 Eti6n+XtDT/1uT7RLzvocu5zsuxUveEa3hJ+Qcj2/nqriKioLthRY2PjhyL9mk//zlFSElBTU69D +D3DfMZ3CB8HB21Ehfr7nwpbNGjxMQS5sg4LdG+nKnBn7tD1nR/WJanfxwdz0qCHQhh9dloXjtIk PdEWV8WituYpjZQGt9UzjIyM64PmUS/tjFt8mqJZVRrXOy5YjUS0RO1t/jF3Kk5JoSNnYOCC4IPq vZ4lJSXl3s2JrPXaLW8flPT8F5x1I+lM6u0r4F/tsx+T2n8a+3LKycvfOPSSun+Kz/Q9DlgDaInr L6ME+XxMlgfLMtubGxslgN+xDFfZWA+7zn2hn/zzh62xqUlRSel5Oy/IKgowtE9pkg2fyt6+fUtw 5cqVdUC0ZLsW8HUCAgKyxwvfy/aGeUJDQsh/5GtRgKKagq/KXr5yO4UslhX1htSTtB+ptkM3HSV9 NFj5+YUfZVL08XbLMec/bHe4ytq/f1QQg6e+pIpnL5O+8qutrQ2GS5lFvRS0SXyQvD73xCHW1MKL HsLNPQL15u3Ud+9kKjrvnb3MVN3GpjNrkXLdIFOJ+JvQtMQMQOOLCLtv2cRAhhHSUxu5t7rKnhW9 2iRLirm/NHF+zrF4dO7ufj5vabsM0YQUHabXXD7KOb1CIPItQ+tGTmLyrc58IoBjqrtXFwaKCDEE hIT8twj5NPI0UczX0NDAYKy/pgW2msjo6Jy3+ppm5+TDjDM6NuYEcvdMixBGwGYAfXyw1BQ7NjZ2 7RP/19cgFIFeFD14FdX3FBsfgykrK0MJQEUJcB9FWVmsL2mSNkJ2BSwzc3PTcXekWu8ZewdKHx9Q gD6q9dwufnAMa/qpY3tpiEJKSkqnxp4e1Je1RxowXFyVWJ77vUxhNrX19VMAaXIwzbwQFMHwEF5X 2ehzdQ1BgK5g07W3tweWJczwZIYc7ayDRb97qxLXm6EYdsYD7wynUeN5QmouhQqrzxwL7Iwfmlru Pn3/wLDK5qcSrM+DkZf81qgDKwm92ItsuXNbYPFT6Aj3j1dvYtHJ5yjJf+fRHube5gPEIzBryzUT 7014TCCWtFMtHe/OpaNrg02to5wvkNPKrzqdsS9fhsD36tF5bi1oAZdsrkYWuOXR0fkz7+6VMO/m 5ub7Y/WCiBpBrE3at2akpHz265dJ2LJeERW/9ZfKPYPrioq6kknaBe1AhZ0OdpwgbiYseucAmlKt Er8luinT8we4R2BUFGma+9Tpb9WI+oqKvrx0SWZSYtDPD8W7YbGbLEFvb3Dbtl5YYNRjPq3cv8Va eOjNmShdRfcxirPz0edH34uMakbnOG8vfNb8NMpP0Xbxufnyqk1flnqS6i05QFSOahpC7aJl7DPS v2ZnZ7Ew/d++YWHEUr9kuFfnolOrO1VP37+12F4ZQxy5+WjPpnH3dzKZ3GuIeOjs+Widy62QcN4B XEIqygs5rCq1jxe1y/YZNSeavcvgR4GH3wm+Su1zgH1h37t3D/Nuf7XFoa/2w+fPxN77/9qR0Ev3 PaIBKqJoZMSAsoKo9ScAX4VHKkQsVJfg5OR0f6AQNVvUyBYBRRcFJOUsUnYwbdcEsHTLLU4f/U0/ fv3k7+/gkJCyVwTxWk5zjq6uSrKyT//sf/p0EyNjYvL6x3rH8rYQztUi2QA8U4hUqLzq95dUwtel TAaxb80awg3rnHHvSO2yOru4rEMMzQRCa7UfcWzkBqy96hfd1YPth8tVWjmRW1QzCYcSlJac65y0 ybyJ/QwXn/HQ303bTp1KuxALsO6MzmujflNeB+udVoq3hoaGcrWLXv0wh9gZnZpqV0AWQvdq/PV1 P0/MweihKoPBKXOsnQXre/LLBUpJSoaFVKH34kG7vdj5q2DrYR93q/geeXiIHMgUdLLnI1Wb52pT 0Pa4J+nc1/ROwN9SYE6oqya4W7acpnmhsP1oaW2DxkvUTxJw/oTVkUofmPz76ciM8/trusNW7fz8 fa+9PzloBpD+A5p2UVKSfrozqmb+oQXqrfWhvf0NKEzUdQMlHUHF1N1cH4B18dsidSB92Jeh6L5c 9bO33PLGhw8fdA54i8tpfP8lcRtX10+IuLyp/VDDClj+DMTHQLFhmKjL71/gGoNl5vjv29qKLjvB hLgv5OU4rk8pFurXfCms3Rt/Ib3zCxsVGH4vGy3haZz/21v54G7Y4UAafoKqZeIm9eMWhazax2bh 0tg2X7cOI2NYux/dfDLuRvfEkNGzU6iRdB7Q4z0qwt/4yG2+szZptY8wDYJBQefszMy7sbExKuaz ohKpk6skOrOalfvx620tw/civqbv0slXE7NVWxY3GZRkIOcHtxVx/OU3ZJwy2w+aC1VlA+ChRE+1 3cjN/aPV4yNSTM935287ssbx5j/sm5od9UyiGCQ5sqdQo69BaRkIPCwCApSAZW1Ac24chHkYGNAh lZ99K3lqpjsOILkNFDg5NfW9bHfQxwSY9mojzgIQudNVP43kFRRwQMHY/Z3BvmoQ96GtDRsCUenw w3/A2rBMvFXvPTi/qpOVnc1y+TLe4kCRvI+PVEZmJmfHGebeFl9f1CYB7Zi0+BwWpn3bWX0MXkhK GScIhsBVfehkZXUZdABIHKvElJ3dXZQP0TaeAL3A9U8P0b+xmnB07dBZo5ajvYIfLmOe4f3jbrlm ayRd2Ig6w5XQmX5k2FT72NjY6mpqfiCEXzbt/p6dZZaUHBNYrRMBGcZj8xmf8sg5NDy88AW+zAzT lNm02scKKqRQ11uv8fKWfZ8biqvsXEjFN9covfKA9Pvkw4JOKQJ945IMADjTpcEy1CQLbV4EElK/ //z5s+0nYAMxMTGmW9zFswnx8TjMOHJycp+qLxDhzfz+/epzHiO/FVEit3Hk+nTnieNy6j19vz0d gE+aAeEr265jOi4uruiLNTex+cj44KBO40bPtexlCGCc69wjfX19qIlXIpdhKKPvQV8lVWdTsXFL 5NHhfhuYqsCtRWRcF6Mk/CEaY50+fdrqWwI418N1U32Cp4A5zFJSDFUPf7C7vrqnCzzjAqD99QbX 5TXQBlpdlQX4KPmEhY33C+lDZKKt+Iwv/qWKu5GgE6rwQR7HX+/wm0+ySEPW6aZbCz9EHi9QGhgY FA64AgdgQAcR0P4z291sSs9mYAioDRKI5A5YvVt2SWFiTzZYH/4stqu30YqFAG0GfnrS+LP/Bjc6 WpHt7dC0RWU/Wvt0si0o+YeyBAg61PsTnckEmxqq9AbaExwWdu1fpBxEc1TdtrX4M7mD9fJls/Wp dkcnp7I9g8VHYhyG9d+XHpfbjQgtjTVQA6vNpiUXHXdD9UYQzTBXb/5bPTyMTUjQYv6Z1/PCL74P 5HxfwT1udD1UQlpIlRwYFCRP8BSU1YumPEYpr/MgUYCK73iXlNmPiSkoKGi6LylE/pZOOgp4uoyX 0ZItjXnte3yU7Q2UuO173t0bj9PmHT+2GNDmef84l0Y0uOdx7sFw5QPUPBiBIDoI5b7Zdx1l1dHJ LbFUEtTeN0XUhf0Sluh/PaJR7/E3D75lo/ou1OQbnV7d3d1FbUUeLMmTSj77Kn1MBxbT3nK0xY10 K9xn18eP8s7OfCiQ61U9nIR3CND/BYprCtxyfqjiSprXhkptQ8NFEZHam4yaI1U2QfBWVO2OtmJQ idK1e8W/0BHguMu3Vvbxc1EGwKHl8CTxd3DgVdA+JzNpljFp/r9qAdhnUWtYWMFbd31QPxGE9eYd 4bKPHlUOjb1GNwBGh5JaqJAMotvSRAvjlTtpqB5+oEgfn5ubu8IGNetADbNZVbLF5WhoaKwYwydO Nov2sa8WPkXnbFJSU/uavT0rSA+VHlYNLxj696ANf9S840YiR+sb+aBe1P8YIs5g5QMK1MMMWJyU Y+xpyiN1lB5Fr25sbKxtfrujP7os6rXDQ8VtROTm5oaDh6fHyfXzYVXvfQGMHyqOKOtkaPvI3RLe HkY9HXOd4WlJCTfw0LURh5ZJ4NMyXl6NuqecWxoet7a2ok5tHeE0AcHBBJvLI9SoUTREODJGxiiI RqbjjU+sOlGbGZjQD10xF8kpKALwiGmZmJnRuY+T0xfe+64FPx8OlV9CbaPRxgNEv+tKSngo5QBT dbDqe1yxk4mFQUtLceX2BxhAMBBR2Zxvph8TOR3d3Drn0pNLAi0Wt1Phnl9KBZ07bDJ7BHiE3xyg 5BuXuZUYO1ZCvAqMhQ2dKoDl0V3SY5CjLMY+S0Zm8pieDGa/wA4rEG1qlV8d9ge+z2znTq+loRGL tF1XNLP2doEme4VrjWLej4coqRe2DAB6DuCACgsL6/2PH1rfS4yNgQiGwCKHxMfHq9a5qqqGvhB7 nD/f+yaAgIiIEqhwBnCYDM/tFdQFqdwjMu7KnVDwNsIqPU601yUj43e/LyMQNV5HfWGGBkHRneyH 5apfVC/SE3yjkaeQczu1MG3bh4+P78O1kkYWANNnDQ0N90dry9wXi2oUXF1dy77mqCdxGT5TzToL qtjKRuq8985kEFJBsCR6ks0AnugfimFUL6ubQOTJFfw42WMCG0AK7JWQHXtHxAXrail5dQigVovP R/chFFtURz4vG1s4bGaYqeOgvdGnXax4bjvFysoqVHjC6+6zwEC0R4V66AExYQdOznA10pNmZFRM VDSEU7+a8sL2YbPVl5QHrp8gon0A6onaHCoCZAK0BN0fLH2DiMUHIJWXy8vLb5rfK9K7pMmuFfIR b2m07i6qdQQPIIQrkNPSso97/b0V8/Llg8cHgPSBSpnkaWlpSPxvzvfJoxKVbbu2EfCBmMTEyyjT ihosoc264Wq7a4imFnwNA4X++9PLqXdPsVG3ZfRZd0/PMDCcsW3Jhoxxt9C2/70VRmLxpz+r1udQ jMuw/hk6OtPkscX3WZpO2J6OVUUOdEt0YuJzYEo6B+cKEGiLpmDWwHbNP73gRdoD0bQmz+1XZwZC jxKKr5oreW/Oq49jMbO39n3PvL//QJ/OY5ds+IdNEPEFIZ1RrMnFkOBc5zxN9vtVenftbqmgbgK3 U8VMwbfc95drronWl7MtrxIf+bBJ327dG/HHJbyJqxnLinxgsNyS0O/9yJQcwd3Vf7Am36Z2gC5W 4KC2MkBjadGeM0La+72vsVDJRpl55/CvPjLR5gwbtK0Uc2hyaqOmn7IwsWr/fe8bed5H8734xCHB K/LWvVo6hEZoI4oebUwlPcKjl8OWu8GgrHk7jIqzvD56uCmUivLuOsrCw+ImPlwCknRNMBF0HXqc RZYeN2rYZWXjo/5mv0hRI6Yz2hxt37mqOPRe/J5+mkCrmVRq590CLf42qPbTymysrKyjboo2F1Vi 2SWxVFRV3xfqVqhumbqv/Wq9KVN4dXGJLEKpbUsi+DQB+dAVw3oSwwuPE8SJ8k/1lGcTJXCIiQ1b LbvfyOi777i9YljXxpTvXHtWjHwo9VPKzYOELepVdLNDzOhO3MLpS3Ww5RQULHzRdtFYH80jzKB/ UnBwFwMvFjNLQ+aNn2+eXyfeqd/toT9DTk6eQI722MT3iP7blrt3sqM23/84xUcRviNn8HlS8FLk l9dtFBHpV38M3s25reUsoKAwQ7Cz/971ZD+qLs2F/md5ccIgVoFSBO3a2to7sEA7ShoYkDgpKSks lPwKD93J/t61DqrGS7daz5w58z7vbo4jav2VLr5sRZumd0xJJdGMSZUTS7h2m8Wz1LyTBPXwR7uQ mfClBGfOxIoTBXWibbxQrqZSXIcHob0B/v49B2GsrMw41JLcMPSpp1MXy69Yf0mZbHnMUi5K9YYi xrDvwmbuH3UKKXupBGefCL2AwbeDqqLCcNdoKsQz+TXt8TnsSqlaDHeJn9vKZxkC1Oeym6N1VLTu TdDxM2KgrcI7dWqfa6mg0gamWMsSTU/xPHFCA8Gb4XvEVSWvvpUGBwezn0a3dwFuL6GJ4I12keJS 4KBqEx45ubpWOxq0kq6YSUKQkE4YRdKdUpJncJWzaMe0QX1YUKYn7DETsI2EILT0xKmy9/I43SN0 8GEFNZ+crGDuEomO4gN/wUJsZhaWfBw0AntNV/zCjMqF92LR4UtEyQZR8I35J1uj8klGdWFkVFla NoSLMrG6J18Tc7JOXV1fZDxc6z+v+OV6/yD4d9qKngDGh3tyt62DWB+1BZneTSw+ReNiyVdDV+Ga Jwq08Rt8eIZK7YUfq8Ftk/8+YYY+IZtULM/5VW/Ndat6SPC/y6yfXKbXerAYO5F8UQZNy8mqE1Yv +WnFKxUh/1DQfPrfu2geCbVgn8IMmww8RfPKCqb71v25LTbREF6y6zs+voGnB68OCj6X3AJbC0Yf maLRX+vhxb0BsjT6DlmOKSyiFtnJp+o331M1Ot9sjWXNc5SMJiwTahECz7+IhhmaIzyvPlIhlN+g nTS7N2zCGZlD37mVslhukA4OEYPutf0bzcwfP0sLPdKZUz/RDLNzn3yrWMDtxFOPLv43PLqTlzwC lqmZOVRjWe//r8XAwDQp94Vzus+m+ONS3m4zO5mhXWRdinEV2NrqBqRosc14Tl5wIY7OkPOS733X gHUyPT0hsORsr768jqvCLYl5IIluR0Fh9j1YDOWtFbToP/ToWj6JkbGwZGyg1Q297IaW/SHnSmjD yQDY8dHA7tc/egIDCz2xo1nkJZTXJK/R04jShNZhs6icFXhITIG+w9nk1KlfwAYR4UIpHBwcHJks DfTwG+3ONClvWnTaFIIXORmZX5KRx+mfxYYV5688e9ew2hz2nPjC+7ExenS8GFi67hBpYNeb8+Im bFl4OJjK1sDHTC9FXzoHIdRJeuGHQY9aQA2RQHtclJCgi2XVpXf7038JbcQc7P59IezAYOR7+Bg1 pHMH7RaTnu4g5NoTz+b+97NwX5XNPZQ/APrlPhlIDeROSV+ClSXoNT9lMVZ/V0nMp5iDgP9udJrD DaOqVmNviDregnJ5D2IQPSKiYHr8yRy9hbX1RaBicD/YGHRABDVGyNcqQJIcG6Nx926Z46QcYm+M XmtYGBNgM8AQ3Q+3fq6Punw9lzxD1if96I/Y9/X8i56E4xm0e4IK3qt7wbdCFbdLV5yDQBZbuLnj 4/iFhRE+BMEyVYv26/Ny0vguMWLWgI0zc3B8WvrSAQwY7i4KQuhLeumH36++ffuWSUqqecr/irPJ HtHsIzD0InxnZu0VNTCHpbMU0Rqo2eaPgnt9qF7Am1T6gAc0l/2eFNwJ8IH7/W9D2kWYnw3psLCn xYqZnMsiHpjSGeY9MVJJzGWmrPjERDwM0LLKQerz5wkCWv0aGyW+DQ5X2ejT41Ne5ld45CsX/F6R 4JwrPs5/3vyEB4sta2nJFuNXUFDQLgVkpIIXZGYW7XWFdn6LC46Sc/UZYiY054qQuWWUm57SUF1Z WcH4jY4ahHmLiopamY+Ojd0QjAwOtV7yy/rAphPLKktRaIq+uw/bhLpQg+92Ot/tdnZ2Tk7io6Mj 0G+8EfCnSozk6lL9Y2m0SQpcaai6q0tZQUlJSnlewfXBRKD3u9V366mdTj27miHT01NTtmQ/pEcp xpw2d9QLc6tPMfyQUJXyU35qe1jPXC7s5OREVRJXWMjxMsOJ7qaMah5QHlSGGUknala2ClGfgJRU 2JuRgSHy3DXtXxDGrQLngaH7sapYmRfp1tjTo0oTLncW8Uce2w9w6nHM1sICbnjfPD46vMbL4rJM tLw2FJTOzMNHdue51IOKxbNaAvrN9sFLEVU/O4FuoHIeGrhwir8WHmpiAP7lBLb+rdqwwRXtls6P 1JQ8GOH/KoFtbW2NWhdYdfpudF9BfdVXLcgS/L+8/kSioxRxQPvGaMvjP6e+OI61O9KfdcPpcO/x Xed1EJRTU+1hGD8QOm+A06LzMijxCWyqcW+hAPX3pOLQ8UOHW3pfy2a7gPmQoue/lJq0ngJOig9h ti2RU7/U99in0LglLYzsLLqq/Ec9zlmSTJ3sLZkXiD0knKaIbuHUKcV0d3djzkjroKN4+tW2WJjG namwXKMmMdR/U9Lz36+qn0ZtM91xiLpLbH2/q1Nq8jTvqO3+0cHu2vZ2Z7nlx1KPrYfPnj9H20Xu R7tzdkeDMFlkp+of0XsIL3O6Xd2G4FQ2OYM32tWE5XDPoa4NVfIQ3pQ5SnzxQiff6VayUDtqZZZf Bgr1/VuVuB4KKvWE+LTUyE+jNxXvtJ769BP7xL7U/6AaK8rrSUaD/vdCIOi1nyBlOYpooZnC81hX EeCyqvj/r9CDh9DaCZjeqaZTk7qf766oqb4FB7o/rA5DYXa7CqDiioqe2IDvyN/3K88xpqFZlPl3 ZfW/aqSGdwhZrzv0Xms+asst8zX/XmSUdBL+VU+APLQMt6R/UTr85uJTg+CE/+Mjs3oDgha/rYY/ 05P9WhWL1jxx1wQ8wGQNSnN8Ds88LKwzizJnFP6LCqonQwj9olaLp3yxRYnvusb/mIUkwvqrMI0L 2iU21P+bJHigu1LfpPn3Davg6q1SvOt3o6asVm7VycNnNAROPvPvO/zqLn2X4smVx0jRlYmYFSZZ nrm647N+l6Z8avT0v2uggiuNcBvdn44Xt58bPgZ8+vEfI6g/iYrnO0h0/ongEl5Nef6YdYvgZLwr AWi8z7nGjijI/vt+xpPvb5KN8vix2NrWLr+ixvDfW1U70HTIW5d+BZP/74I0J+/1XAaGcFmn7WQB 909CHdMzv/HXNR8hCsIaTHF1dCO2GsNyElp3ri1yw5KZ/rxbimHiYCJ63LjgSEsFFsGLmAILBKah fUoOuOFAnf+m4YReEHgEMGB6u1oghMSnAxdrSyKZHkjVPwlbb0XQLJI/wks1rPnF2VPJoMx3Qgbq qdH4cFJlrbdx5/9nyAwnLzXJOmxvMf4fL8WmIhvfN3q2ZvTKhPjkfgvRnZQ3eOyz24/X/eFxk8EU nywZXfsVJsDOrs+fgeOz5CvArEZqABsixZV4NpxWdUKnHpFa12HX3rO15UCH81EH+a/Sx6CEhTCo SQA4iaKFBWua9z9dgIEn2JcyzmSeRMjekjefYjTp7tIToJDPwh+qLLOxsXGSlTeoRW3GUMWQggIO 6nImLS1NwBwdE4P6GRcaNlChDKCjI8/lmy/8yC8qvWtvV1wJklGYfQ2KodnNO+h+q368dlH7IGPn FEzbWv7vS24i4DKhr4Nx3gI0oYcxoYws6smloDDqdgDhGJ3b/vSSH5+QikNGQyPW7tSlDNU3Xx1T /uM2MxOfr4+2i0iMzzudgIAGjiIr093sm62vZQN+LSzo5a/bDVeeHIRB/fwN6spjMy9m9GTDcOzG qp2D1CdDB/4zTva3wSybMOR4sd2r+XpVD8/zmilcgkFUszy7avCsF2vV74R0d8WynI3u31ssaWF6 Fo0mXuaeg3F7kXgNXT5QNVg0khyGjmXxmlmSwGAwBsp0v9H6x4QBeMSoBRzaMYLo2Lj2nlD5zp0k cQFgf2jdKglM1RVPVruL5Gw0RHpmXl5ydIofFG4g6o6AmoCgE+du9xU0sR79CTz9P14t+ur7fX+9 tCoR4rDg4HmH0Kty+H7cLQdnD/e2KgabPbftUYuM7C86pqamykAK4tnu2tKzkGudAr/CGyf+tTLF 5XY14b3m/6YPlLK8bjKXb6cE5+ZepZP2GbX11NE5j6pDZ9A2GkohA0e5KPCddy6MQktQLOCLKeDb g4AqkUd/yE7G//o1zgwsFjo1jPKEpm3PJ0tajk5hEB1DWV8vb2/1Fh9vVOOFCm8A6S0iXwSz+2e6 vmP/j3seq908NfXnT0idy9xUzYRPm7HvYWBvrxoHRBW4CxGX30QoPxtISD01l+7bAe9SNSiMDo6/ Q4DVJLtaSl8afoJom6Tt3/3OCz78TqBfY496YaKzHujxV6tN2wwem/PMaCZbi0eb/fXd7EUPKDlO UOdQHm5/5UfWDWrUcsK8IxxZ0drOdNT097y7zkGKCue6QOT05ZhgBS4+PTEHZdnTyj4+UqirEARt 9PjC86LOrMVGTaHoVATMBDoqAj6EnnFpYWHRRc9FroVpkiU9fZZ2V9wKWGH4Y6Z1tvUT/GC91s7K BLMlhp7U2cnoSyf/nKgV9UpBj9VYGWvIVc/EkzraMUelQKgttZy8/HrfdcZuej7yhDiINkAuHV1c 48TjVX9WKt39vpnbjaAwf4PyLna5z6HHzVSxc+jbMTIFP1CJu+/BOj7qZYFBiVdUYYbOP0QIj7+b 78ucJXoZ3KNi3SvqhVUfk0fyDNCZXMsJlMDU1JQ/sKRv27q6umRy4N7tZksuXyWv6EsGG5Vcb/E5 RC2T3D08Mh58y0YbHqgOqQPe9UY+iGRtcxMVxaKKyNHmz3UTCop/iPfY1Y9N32q5SCKgaR/FohGy PY9uH2Dk/devpIs/S1DjllcCD8weNyYnL+fYAvt9Daxo7e/ftsEy88nV1aj/KeNDGXVgKBjM6dOn UXUYKr/bnvBlRJnnieMj/CajqNWW4/HfThRsMSdEAq/yPJPbVaFMLZsYN2FSWIT50dKK0Ukwg245 3tNdwPFQdhEJDCRFlKIYIu4Ze2utlH4q1K3AQ71xvLwa2Xg9dmeT0J4ReqoFKp9eX28FL/sF4wKe g9poY1CX7Mm2INRgJ1X8bwB+36x+kpP4qmtCPbZG5f9MrVaoigzG5Ne7p+iJAaOmlIu/Pydj/ACF XtqV3M0h0WQ/B7LjebKwA9ojo7h8kwdJhP4b3KYHO+vo/AHgNOXtllNqlg9lMCeWjHUmH6sMX6+I So4AVZShZyOoqp5BZ2pRL1n3rR/3JldWIid8j+l3d3fvf8uOGCrj4uJCTZLWpzstQ9OUdYHisCrf n/+ptqJm21PLoKxtpN0dEBIcTEdGEc03P1x1DYmzVHE31N4RFcEScjcicmna6o+L8ausFFCOffbu nUzYNDY2dsyrVw8XS0MoVUDvY6fjaWXgOqhni0WHnQjb/MuKt1rL8R9W0dJG4HnvbT5taZFGva8a /34Rz4V7h4m3W3g+u7Dw0KkwOTlZsYYjI181Xb0KBIVgwRCRoMRDJiE2qihBr5srjgBAtpGnlWlQ o6TzUl4imx5Nf0g6K75Khfn7n7r5SuA0hMAgwGF0Dv7n1E5KCt03n4z820nFbcc/jqXr2kpF/6/x PhYX7nMHfJ+cnNyUt2nhT056x8KPAlTUgIOHJ0fwFO4xbPpbfz+ox7GzJfwm7zDu7u4v7MLCwxXA 03cZMDFyBMyOIAcEHAboLtjb50a7gCdodT2xbb2xGrgzMVXW8+ScQSrnauLZoVDJJvvgGTJqaut1 MbZ6e3rJ85eZLB1ne87t7O/r2379+DGA7BRaqPFGUdTvfqaLHMyz0/amnNypNN+j3bMlFf+z3XR/ SUE11pWfuK7eYHP5J/Ud6c1Hgak1vsdH51yLe75vPLxRuOd+jrbS4d0DHVZxzydjZN2tw4vT4ElU n5/n2lIm+6WIPT6DNiN2/87FxMRggU70UYkttfnJldxBSUX1HBZcruQn2o/MXgbnDIqLo9Crtj3t 4OCATrKjM32VD77dLHL/WagbMFLjkOkw0SwU8VI5BKwJ87rMd/qskthlZKDqWtldODNh3M3vfrUG oO1EVB3s4+NDZb5yS9l2cuunMfizOOgufHQQAQsL6+S44rc70qaDpabILDC/Ut3G0XM6ULkrqvKm 5jZCz2pB2v/Rn/525OcRXE0Pq38JniRUtCxDb8qg5y6AnJ5GW1cRtIIzJJ2s7OxnQPu94DU/gda3 OTkXWVlxXH5/aoUIb0/7s/6xzYcPH1CbHVQeoNbk8RgV28LvY3g9WGZ7L2wSbJzOd+Z0D+vHseGZ nDvd1fPRPyjsejc++KAogeJlpry8PPQMjIxY0kzUwQMGfCkSTORDs/e+LRl5zGEfzSMt172EGCBF qf7iItHOmKjnEuwnpEgosyuQAORTN+5+MN2LL68LYm38KLUqT1J/7OoWp8odJ+UKdcr8l7FC6KLJ TgEzfYOlJY6lrsJ+318QqGhwbo/6DGUhrCSqcldXV0clJ/7+/r9QcbZSLKvtSPWtbIKQedmsMVV5 cO+E9P9r/klLEKYLnS0GN379mglxGHT6s/28SqxFcHhwzw0kmGryQUmdhFutOBaK6LdvWevkmTJU M4TnCx5BaPsfZpWRLxcjyKQwUws24O/l/2thid3tarn5yVUUQ2uxY1NSiDCAIHz7zawd6woW0o/w DBO4Zbh7dPBjU5OI3ajdTohd/iOgod8fCrKqyAGBBTi02mtmxcXFFQqODGaPHX99fR9veZZEnleg lfYuvXJO9O2TDIvmH8oYP9SdIZr1NACc1QRFjDlv9a8I+3MgIkPXS/SO5fw8MWZxZi9Bv6onAA21 gAi2fZgWTCe/8FnTYtayDFubnF0FFyV+Ccv+S09RcMhdYUnuu7CJeUcb7Xkf6A8s29CToZPfnlzx U6o4NXoG418nCBTvQEBfQ3dAJBZAwq4SSDZBVievHp+xiIBaVAz4KgpzampkKMYMDg7uUyXNzc4y A9K3BZGi11GRQZtySK7Eoz+2rTa3+lBYZ7meE0wbDZSKGJUN+eMSog4r7378OAcE7bqyMsHBwQHT MxklJbyzFBTo5B0QONSdRKfc4jQeEQS+HQVN1T0iyUXpwpMcjtYlmF1Wlfd+WNioqy9wPzogTope XhLoCOLm5iOMjIwMBuKwv0rc5cmX1mmyCgrPPqlTqOv+6X88T/ZddoWHUuVCYfuiuPH12z4koylj MyRBYIH9V1mw2PIhRNwfq68aNSVTx224tiLn0GvuuGMCk8AK0zrqb0CnLIop0rt2YvUJSuTIWnb6 7bOZxaWT6UtD+xq1XXYa9iuQ4f+3B3A6VRYf1Q7q/FaOV7mU9/r0wAmFP0nu28qdmOYbY3n4fo6i ekfJ6JQDuhNIzxdAGenLm3iS/t7+6p/zXo2+uZqoXST442Qh2NHOB4VYQOS3EtV3J8zpDFKCt+aJ xIqxNE79h1pIi7OPGTpRzxHNDWIVUJ5Yf+Rtp0U/jAzMOqsKu2sLq4qjiws6y4metxt+nvcU4JpQ eHRwD8uWFXv53wpR3AJKgVZgkHQ3RQki9C6e3Pa52zFuMgK0xI2Njah1MkSaZKorhUZNYrGxsb9m ZwPRWR94EeVt0OlyUFt1bZczzOb7CfXXnM9od+t9t8eSFpa+3QamEZQF2IoO9GTdSELd+xCZnfD6 S9y8+/sC+rnBbbUDfoUKFdFCtxxsEPLx8aETIf99J7FHLus5uQO5GRLFdc3YM7RVeGXUZieCJlfj Kh/WE9AUqKZRQVFRd+nbfQH32YR7PJY9lBg/7YL2YPKLZBQU5os8Ibnx4PD6a4lPhXSWPpQT/69a gLCdsPUTwRv0tgtHIefbWE026kAqlvpl0/tb9i2n/X92+s+UFEhlrHvLME1E4SfTdPUksQJzdFq5 7TlxmcfWQwtra/2ljz0973sSrpGf3fiqGfn9u+b3Qt1vicxn1WngFgZ8409yIV0xbOWEAxBFUIcX VA7V19eHSDlGpuSn+edXgqh3JjgYBnP16tV3w1U2qIRAVB6mYfSc2xvhed7KLbU6+bILIM+yzetP 6KHWVcD1r5LbdBISEmjS0HFvwZGfjU9cOAzrKdHxDYwMwdMXL85XT17SyL0hzMV8RTrITaZHGfwj uWFc4f/0j/cwn1io/2Km5/YKaqsNwgaDaW1tJSAiErgwt7QU/uuXiagca4ZG739ww9efK9jV/bX1 zY2gXt7azP8GdL79MpPS06dPqVTwyYdIwTkS3voP3wOEc82yXE7MFjvZFJhRhvBOSUn5Kyfd5/3/ TXjnsRsWeJlxMaO/P2vx9T+tClwHmjzWc2J4bgq2GhzjA42c/1moUszpLtQpp8HNAVi4DiuDErjT UoBUAH0pAxL1M4ZxJ1kHEsUYO/frgGVLS7bo6C1eAJbb6njVDvvVq9HiN1nYcQ3rSSIOL3ykf27Y n1+V/R+avQGTRXIPlcBmXifd2dvroSchl3zdMMX1xTJlmj4aX/Mk8nWpw4zlGbf4lN0tCe7yeaG3 Vo49gM2mhy48c5XypR+ieaiRpf1oLUrHaZIA6GJEcAvoKh9yTt2diklOv/afMcnFKM4DRj9LSqL+ n/Nd6Pknjs7OfBcuqpztiGLkvvtMQZMWlEIK65VnO8+76EPH+nGOKxiUNR3jT+Y9IRmiXgjFlVdH vt2xl7Q7AYQ0pEDcVZXQct3mcg4yq9EbsD9tLGz84XI73wlAve7CYeXlVV8hC849NU+05KdldJs9 571YNGHZC7xqhissLPs58A4REZ3/eYeYRL6P5grPUpqQThhby01Zex8ug1TD2RPTMaDUfXZb4d9q cW2Yy3MX+C6sWgZActGziqOopOupatb7P99yELeKjiZTjn00YQ74DnrZlpKZPEGrJ4JyhmoGkAP3 BP/hU6xMQMBjWWWzNF5631H4dxLhk8LIEhn/8yIAct2qhz+8W+69Mu+MRPvu6Hnqzs7OvaWm8gjl QC7zRoSEhbVdcGh8Ot0Z1TYycgHVw6aIuvz684fNfEahOlN4fpJVVHa5IFGcMug18YDZAvfdE5Nx vUN+Olhyd3cufX3z2x30NG9UTgRYiFpfg7G96EBtHF3mviAKM+577A2v/fI93mfc9JBEYoEm80o5 fapsJ1XjOeXMASZx6QtBd0kz5dXwT6iDh0nobZnYuDino4MnQM1lCEzLWu6VGAlFzIHMCo6MVEJ1 NiBYzTpvveTDPTo6GqywjvoTed3Rkec5KWMkeDKQ2yFtZopupRNQOlWVP3ZGqlgq+FaoJUoKu94C XAK7QQfMxhrcsP1+zMjHsoKrDQoUQ+hDuO0+l+qGwYBodnRzEy64V/fk72UzMzMe0/c4FX+00RFc sLeoiAvCfFhv2GUdeqfLojtnSNpMXyzIxJqta3fWnKDF/FM2PqwQGC+EZVTqIbHRdREEZ4w4K+Zd sWHDr+XlCNDNU0ipDFVYo6YcqDALVK+UgaHh+v5qy0VpaUa74Upe8YH2dtzJyUkRn4Pam30UQ5Fl uKvBQhdnSNrf3P+h17j1Uf8EoRsQR3/3FBs1I7X6ksLmdtXqkRg9qpH6xP/VBIg42oUzMzcvc183 s7CyQsl6gLAAVhW0eSQixcNDhmouiWIohgbaP4V1cXZZ4heeyday+Z8lh0mDIIkqY9zOU6F6LMCL cFrBM2jAmF8QvxTt7blQBaRuhRU6h4f5tfBw96eKsLDwNx+W69nC81h+gkznwlHWaIaAsu7s3ocQ CvRYJwtLy276UBo3NzeMTIvP4afqlrX3hGRyTFJS4wKX/6/CD76Cf/4Xqyjz4BWdFTU61f9olWdW lzgT6p4mK4slJy+PnozwvcSY8fbt21bIf3bWp+1o78GNol66Ga7Lw1YjNqh/R1dXF3r4IPMzGT29 V+3rDx48yAX+FPKThscEA2HiUzUqoeXjK6eD2f7idqVZPuKj4NpWR4md6+faWpFkwxu3x62byqaj 6Hfe/yEUKaDcpbrt+ja/0T6YQdPAIKV9UeGBL1PN9dCD5cfA5Rr3VxpQrAhi9Ln/OJzutHKykB1q YHEjiYtZYDM97xKIDswZihjUnG9oiAa1EUyX8r5pjp5/GR3tByNv/rCIHioI0vbcMSbYdubGnxsK lAqoNFGoqbio5EpQ6Xeewv1H9LRKggr7r/8BlSZ5zY5GE//fhhXHK2L1oavOZwbQU+hevgyx/JjI zMyMFRISQmU89zW95okBeH4g2alr2oU8I0dgkO/B4ABexsfHUW4G1VCDOkxGXUbwUPekiWZvO3qh mM9AJhGtW+Gh03BPdXRv8HBBKfkhTsVxLBVlZfRsLV7bQZ46eV4KBoZIZvnnqIwGPcNQKROdfFz/ LDxh0hPP9v+GPlT8fV1Ws+7MCtUvgw7R8A3GS25XSbpRHpTqLq/WSSKh5yYQMjk5IEFvdD4mcrYB g0BPggxnlGa4cjvlXYZiGI/nP9tvL0BPotQOAwMDUogn9a7gGduGkqld6m9HlVtB1QE2h1S26i3d GY8Sx3WbOSFSnyif4Fv8/vQSxCHL3tZiEB4xbRd9JM2VK1dQC24gQg2rtV1dyksjNV+V1MnZgr68 xsbcbs1XyN6S4aI/KbsYogcaAqwhsKSEG51qRAKcmFagdBh3MYBUKppNjoU9kssQ3zqB/3vzwzp5 Jx2gMIjQXmxwxp0fu1DrTn6/FzPYSLPTsHt1iBe+60YiB+/h8b/lkaJI01Nyb2+CoGRuZrYl1w9B LFerPe7Oqc7Ic0e+zny9BdRriyUbHQqzOV200UAnE3e01NSY3F4oWAR+eUeiUw3YzrJiRgeRo4t5 dhbLZe4ozuu8rq5VxFI0CyLwxhCU3xxxyJTYArnUfaIrEuuhgBLQ7N+fYsskC73Td8DaWni5SkgU f+Vyvg7QjNz3lKOc73bD/y75WWKjvBHd54gL7wbLZCxY1YpoHXccJ+mj/y0/fU5MeNzwpGJUXUNR 7QOrXYIqboJqYGEhh2aBNjF7wplY1rFtULDR6ekOmQQhuQJc47XBsCIiuB/xUrS+BJ8JlQPCk61w K0acjiXDeaj+3Hl+vFof+h3ffyvijd3l3tM7wmMBidVqrz/1jN8V4qOkfNmDR3Nm6pTsh/TaF2em CEMvqBuTKajJPPfruUagrHvG/1RGdjzfRw7O3v6XB0fub9X0ld4sxwnMzYk4986ovOJ/he8827y6 6LPIOW0d5SuV9fDz9dZpMtwu9DA9HQ73g7+3G7wMFVLCtgr7/O/dLd24vrg2ED7Bkxa/Sdk42vQp 8iJLLMRimkyGj4mynZFrrfhqxSlDeawlogpYfKbvny0aUZPPmUQI6q0lEva3MOy+eey+CHD5uUeA XzwyuOvWjTtBUVL+1MY40tI6lQQemxjv4yVaOmfiLiBhg7CqglGrIzVRIPhmzVnI62getia3VJIo KKT0pUl2eEROtr0xlt75e2d+6G570DWnrlMW75+dRlWGPyWa3VaNLt9OeREVojBjpWNepOeXFlVs hM/CMjXPZeifZOS/txWBO5csRJPJJCtrdSXu4Hc0blcEesDtbNbuF5bIDg9tTve/+nC3tlLlL79v alZkBgcbfBuuUiugaty9HH4Bv8FVNozKKudshcgniRCgeyHEF4QsDIzrH7EBrdVdoaam7rxn7K1Y pFe1wZsaPNo1S9W44JfQAoPor7x5t2I6ONjCeU8gnIE43ZekSK914YdaVuhQ3gdbkrt+hcYtUuZ6 Ce1mpn/6szialCrmIH7/HfdcnbWWIK972rYepFKV9RCHNf0Hp3oSpgQjpOCghsXCQtJmLxwaaZ2O m0x8tG/sPkNe9JcsoO1mq8fR7pyo955Azu3U9/Y1f/uuMzrtbf65mYTaJL540TXe5PlgtLZsKEZx hn1g0Fdv7SGxcvOG499fxc5uZZO9eOjOMWQ0p5eHW1/LOk54d7D8bQ3Q8uo6R8J/ampxMQycH4NP ysAqIEApLS0ddzek63NoeMSHts8B5YEfX9G3z1Zy/Xx1+sKV6FdpoTkNOUNOCh8Us7Lfb/7heXA2 /irWhDf+8khyqipdTFu4n0GRQZ0zu5RCSvhWYcJG6+wP/58490qwycl526rtlNwKyswj/tV7bufv RNu4dJ0CQ4gS1KYv/aTBXWjUIUZGHnPw6KhR3VHABmB+7SM3jx3tzn5y6k26l2fIyLvPxZTFLPhZ ni2Cr+Pn0Mf7kd9qnd4aTlPqLf69wNqV3QmPXUZhpjprqD9YjDqLnIzi05hk0nztfb0km8+/215u Y4dEhlmtrNRdzqaI8Z+fV3dfk50f+PzCdauTkceZtbYBLpQSCBeqs6PhdP+BdW2i6oxD+69zAXkG b/lO551eCh86fb69E154cG68Z+YZi4ba25y2/VX5rYWOV1HtYZPJDq8LPaKUSUS9sM5SULQB/VSS k/MfUleYoWUxj7glL4h77TgQP5C/YdF2fPxI6CjtyDZ4PFrd69OKWPLaa8eKi6HKWGv7q72NohKH AhKbZEsTpJIeuVXFo7RBnDLahTqyP/K12AzrBbYWf1pDVMIAK37usbVQ5rXrHEcR2mU5UKEtMSYB M846KTv56Y8YvgOpQ/PoflYoKXm3YBJXaxi3HIiTyVO2wzj81nJq0UPdH16KWmCVO8+q1j9eVOrL UKSR9pFwbZCc1oGf2bTyKV1+f+LlfRNs8JkWnMaKkPSMtcI0+YHrhjA7dV7hlLyC/ch//rRFFc5I +j/+FOv/jpkwGjy+r9zyBrCh80K2OonTt5KFLH8WG15mpYhZysVO3M2Yzhg63xRzVLXHbzPHITW8 HjMUo/BBJVWKGBuftuFlEhu2579310r8kpKGut++duwquba9MvZR36Hp8efp9jDque95d3dfKCsU d9LaZMm3k1h1OureK9m9ql/L4aTiRLTvev7SmYRfT/NJX9DfUUh5Nkby93frfJ9JRevS0Npam94c c91X5usyBwcHxQ3zEuzsoSyKoTMIoBLDkZNbhvpyi7hV1JbV/jRboCyRL2lvChahM3VVIHc6pX2t 0s6Gkm55pC3d9/3FqNyd6MbJaFxEn9BTJoC06Uamijj535Hafea52vTzmQXLhkPQNGmc1Y1vlBxx tuHjLyxb66KCSG32St7U+jrtcfyR99JofIKl+OFN1tt38WwdelEB+JP7q6ZHXle1Py1ZaETDEvE9 2bCIZJBUBXr4UtCGiiosUNBmYK3nWgnqCLDkKg5SSVg8O9jk0btTlaffqOD9oI9f9v+rdqx2JPzL 1+BmnXLJpSY+O7WrLKdKHxf0jT0cFTG/2NrkOdm8/+n2pWK0Xuxa+aBGZWNYFM+Lu3K4NqSCluG1 7EFNLlBbP1S6hC5QeKxGaNSpyVlJe8OTe7YzQHpj0+2O9cLVqyzF16QYnhPz/9ta2wqkF/8VIfzu 69cliyl2OmdyMZkIWkGdBlfOuS+pF/n4ziZ/VtrdmD1NTCwo/irY4BKfUCwAhZObi7B4qMX0ivjK 7+nbjPw7ya2aZ/I+zFtlfo5kZblcNmI6xGfO3/p3bnK5JkLug6Gv9w0pQJCZKOkjdOYSg4OP/w1U ZBxFSFfVSbhY+cWQt00woHPteLvtWJ35rb+YeUjt68zrpjuOOmWnxNyek0rx6C2FvmhlzjH5Uagb N1xlww83zHLx4mcIij9NJW1+7JFeWRseK+nL9CDd8x6Lou90e0F/XWFDxUOscZtBswBP+pjoRuJ5 xeBQUt44eSomgGPA0Hin6Q71LNVztAL30eMS0aHgoT6FGfYH1QIkHfSa+BxXflk5ma9gu+TdzSBJ pXb97XhgWnExRJlh/9Dt/gCRUrgfFrbJsc/8uGHR43YvEl0/iaOdaWDakRCm17+Ir/5aXf1KyN0o A1P4YLiSbbXxL0lnFCNanY/ilG7BAvqvlGRSnpXkcF/bK3zX2RZ0m1DMSWq3EdyLlZT18ntCbpnD Pcd1FgWFd0GMcpPvra5Q8IpYYDnrrk+100h5iUgfblIEkTL+Bh78wawMPXOjJ+GatasEeZJ1xGEO bsmAn0iE2VG7zpiDIJj1N08Vh35b3W39s+RzW22kHWkMDi3EFFfeFxsq1Vwjvz7Vi9v14/3792jb GcAL9ZBJ/mzlykqeRE1zISSpgdrylODLwZeapEVfYo1u6FyoSoyZiND0NIo59WvzgfmrH03bcnXO HZsFScZ43NwVcSEWs9GGpVwVI8u2g6VPS5r3QkE0OP3+ROMfEPDnWw5pk+e2kHha8MeKtKp83JK4 h/rNnPziXyzme95osmuEWL+SMIdL1+G6in9KJcw8/lMqaU1CRPv2McPUIF05ZqjyAUUYFadZd+yl FLHHoe/eyTC4/8Ly2F65NVJtt77m2DXIwtVJW0Ci82Wpby/KTNJmdkjwq/P1XvpHRcM/lpRZYrG1 r0kciRQakx7ut+k7PK2+QWH9Kzp9Rr/qoeIbuUCkWWB82SBq3B8QqX+YVOhQ6s9zvlJh3mXn3rS8 SCfi5udzY3/9W5t032sLbLCILuK3b8GC1hYK1MpZC3XNbzaddaICe+AwanwRSS8+NT1t7kpJXvf8 I6e74Kmp0VEO+0+ejgx2v6vf/H3/xdb3kbjlGZtbUcGZok/677/xXGP60C6rcfZg4ri11unXnLWr WEyKU5ciatJzb5156hcAcgTCvtnNA4lDnT5r3LSVtEd6gyGE3dSfwAGP+5vEbceJOqMu2Lna/Hye d1fLK9jFOZgcAb1pmY777mySk4uLef9bFWGvcOA9S4Nlu9G3FcopaC6cfn2LgDD4bKBqaf3Ew1df 7W+nl+yXZnw9IzFKN5VOQN6qs+pU9Xe443rKC/mDRdTNgIOKENVNfPwYdpri8ugaL0T1T5aSNlqE 46eyrcpecfype7bfUpuuPhE11USy+pJeRcFP0vPXp5efagIDX8YpsgqLKGBtrEpKVnYGBU9XdOjl kRnIcroTvnA9N7xu2kn6xOvHNLIH8ojrL+hVPmS1t7cGkMr9yO+4/fvKHdr2zv4s8Im6xyTqfsHB f0PCI75vFpxaKMOLAkSw/P5KPZ6Uq+S2NSDSUPhn3K9pAHav5XArKEJmSIIMnq2srHzxxyUsfnKA TkeOGU7Uh75Q8fSjtHWo9Awo1qrvt1ZhdG1f4gPufOOVBI12yXPuZrV1ZtwwgA/XhsP6zm/fvpWJ vKNKR12OPn9Gz4S3Fq22/EiFEvYtLdKmpqbhdKKxz57hUGiEzjQDrSVJE88l0cF9kdwesTv2+y4g cyqV69TgrrnV9bNObMDNpjsvJJHQf7p9MbYBrByrWNckRdo3DeKHWuX9Pq/b8UOgxVHBMZtmrlqi OVD2bLuRatZLl1BHn+ck9D2djL43S4yabiqzx+6TtDOyjKUVs+ngpqTnME5s7uK5hYmj65n1KILF 1j7Lveo+z5y5ptZCzxZMl415CcoUpqS2ocG8TGd+osW3Y6uAu7W1Fe2mod3n742Z16OyIdQI3I9+ /PNXkpFHSHQ0mZD9aJd5lGQHSAj348PtXdADug2uRacfKDongYwh1bhbeqa51I9He1v/89NB7M3D eu4/1Y/g+pT3Q0J6iy7g4LfNpQckt3lpUHRLklQQNKlnKqES0cFlV6mDNXmY0+ug+fnHOs3KAEzv BOARzw8UJauoTOak+6C+KUvDVWGTbUHWYuhpZgPFhh/n+zLXt7e/1nr/evc0nFYwVDGMqq/abuQg kiO2oLBMu3Gsqcq8OixXq5EqzIMr45v/bYmG37rjdcf0aEzKruIS6zgHh8K2I1aUzCy4MW2UTNsT vtLoP1RoIrH+gULAfnRwRlN3yFZIKfx8a+8b+TwYcuK0578lZk5Ozo9dwTk5Vx4vDlj+5OL8TTkH 2Kmy+2ujVnfzR0rBfeMyydWxY4Y73vuUCaGaZu6Zk8I+0cEzXUGMtJkMf+cuiKeGUWqCJjGw+5Ii anW9Nvslv7Xzzpqpz8F6p21U54cPJmU6BB+tgl6XlqKniW6IZSingdNUYcZwJYfWVOD+lHykY8X9 V16bz0aCUbHxVNs+tU57mpMuNOAbTGkBiGTgujmv7ro8rOjl5VWdjDqO8hijbo18PgfuHREXrisr K1dv1z36cxYzPj6uG7m7s2NBR+1kBXyVIXfPb4j3A8634VvT7+qwN3frScmjFNRyFNDUiTRRXHl9 nfT+6PnsO8LiEcrjEO9Z2dhCZAPw0KF/84ohULg0RU9KViITJnC7PnK33AT+Ul64X/sKSZru7m7d yEuXLlnCtbTz/uQpdCoWYCeGObu5WMvW4FYeFF4CyzXbzxxho1HrX9JhuX1N8JzHFt+AL4cRkZGR 1ZWz3Z5wb42b/Tc4DOvju+OufKt8cFevxv7zaJ3LaULC6eWaid8769OfkoW5jfkVlZQ2uq+ko3Z0 jksv+kgn7Gvi4uMVHj5kDyKhZ+HhiYbZBaLGy8ur63P95k2iSzfGdxgXUMWCtHTLzRpwx3Crz69m v4SR1xFf4UphOtx+FInDYPrm8ZshJz7bofL2JQIuy+BOso4jscTfma/4i3+IeEl4ATLXyMxF7P7+ HPA5OcK14YLQi1SlI7uPiZy6X+I+fFCI66dkcsXXzL5Jsw9GtezaMOYD0bKh3awMPUxz2h1Y69Id iXWFZqvhUtOAsc+fP6/8/m1Vo8Ohy2Vvb/8PjHBoenp6OS0t7R/AgYWHl6pqqCQT07uj+cwoo7+i qHMb/pK428qnxaSLzh+1j5uGv+AsBU2RvKS/FIdLSPWCvnX2wHVK2PMNW+CSIZVrWU5Wzkv66/ZP v1xw4dQxqQkYO1ppsLoSk9I7VzUyF81peztVTDFTKcLv2t1XxeOK6BGgMPUCxvyIn0GoL7Md4kvk Nk5zAvfAAxc2Bw5ERMOHioSGq+0+Huz+5bdME3ZgAK8aDldLMbKwZR1fGY8n4bBzpeTVXZ6q2s3v vFe453kOUUIYyIe8pSHsKKmHHCItXz7Zx5zqBip4jtsopcL666lfc3Moee97uEWdKu6GFz7WGxcb uyF4Fyxsvj/rRuKI9acXT9vNurvw0P4der45zPqTpbJO9PQKdLZ8e8yNcXm46uPXQZa6Lx4DqoHR Zx62XsM8yv3+1G2k5ePa6vO7bG/P3hHy6gfyQMLN9WXQttRMcWfHvPbhk4LgG45dp1A1q4KCAurV hRGDSQY2ibokWFUgaEb1bM491ziO95IzjZo8Cg0bEuHltaWKr2fJyN7Bar/kswxVOa3oHCU4kI87 H9tdqtRW2qFHczTm+D7gfV1L/yEKEDpCF4joCKy/vIukXyu5lM7C1QpagPyiUqn7ullsXNz6v3+/ f9wztlwcKEKdcv3OnGNfW2lYfZXSX+pzuGfr4DBQSAM21DMnwPKEm09Ig9P9Upjwqndcrov6pl5/ 2OcA4bsNta7qFN1f4tlKnS8V6uGeYwcL/UAHjgXRx5+KU8/CgPtuNtH+9qr11zRJCBR3qx5qSUjQ 8dUrP3Wtw3XIIrOTu/ry/8Lem8BT1X2N42hQGjURiURFue48GCtDIyoVCSXznHkeSoMiooEIFdFA ksoYKUMTKiGZCmXIGDLz38e959xLUj3P7fu8/8/n1/s+X/eue85ea6+9xr3X3jslLSXxygCbRoHx lphpii5Vdz1jee+dTr7XlnnSqvbgoGPDDTepnOOUfCELEokE3VCQH0IAAUpw3cGKDW9bGkOOCpeJ 1u3xvuCmdiixvCH9Lm6myEzISvqQHef3d3sNtJFOz+dU+zI/os6jvzFmv7MmGEsbyilvTRUgQiwX ThtNlb+nJnp30e3+uGs5zUu6DpRECEsHfWz9YmG/jlNVeBWPT4GXF8jYDtuExHsofDsht0ggbn9S wb2zA85A6UG61tXVJbVdWHDEAApjtFOupgo3fdP3F2/s11fLjeV72uUSEwpCETxwFX1Cg91cZpUm wFXcKVjBcdZUrG4JZ96hM9BrlDBRh0O5bjjuvqHNosd313RIgrg/0FvEoAC8OTJoc0M1rxkv6JcF Xtsbp3GJb4O8xUY9s6glV14q8b5xnArs7Qk3Sd/2K4dbbztGgITgW3FJXPsrXK6i19BAKBgWK/Jg aTAwUYPfyy0v2S/m4rQBmZToeqFNBvcjstwWt0XW14Q3Sz8obSYL9n3JntnwZgoP8RipGi95xlvX 6j2bXs7pxbvjNC4A9YAuuoIuE4AuP4S2mLwMEidRrnqbbtmiskICpcF3V2iTVIVU772BIBBOqeRN 46NYdRyDKNI0Ee1qNTeTSHbEODpdCtucnUD+cYbic8AZFrgW4MfZiq+n/HxyDZJuTrlYp+7pwALG TDD/omLQca3N25XwkoGbw3lw0x+aYU77BwrnK6+scQRR0SW88QKx/Q+FBAWhY/70KVXA0gN/pr8R y1kKIs9prxetSxG+PmVb4r22rd/DqvI89afcLTMHCvR84QH3mTgD7qI7dz6o7pO/U3N2GjQd11h8 u5TgzwVMiWqMMjTzmZCr0dHRfnX3QZHESO9zt/j3Rhyv5LpnNoLVVh84WmYlb11Z9Qit553w6WOR yuhIgKS/pr7eoVKhfufOnYtEdgnxLzy1GQjj4qPFR9UsVIJEtRy/ZiQFP9TniWgezAYDkrJKpgpY kI3TgAV5lvXdACQrK2S3AJNxIsWmPvDixYuf359auLq37pxKck+Vi9LmVTWpwLXHjZzVxNzr2Bye 2ikSrjkkJLusNws0lpRv4HVkyqd3IuqpiwaH8pWFRjOkS1JO2E3+y68DFkFXxPnkPAkhmEKVG9Cl 2vZpYR21eaF8qtnX1Qs1bnLHzlW3HgCRfFvFyNyevclBy31c7ra9kwFuveJi6YGTlhlH+jqvXhsO WZSy4uS69bd239woLz9V4fQiKHMAgVq0UmjueRFVqGVgYASlpCqagwVRK4Wlj8t1nMSzCabkPs33 Endx3ZLy5HND8pWVq8XDwdg+E9uXOD3X77hV7RXV1YlF3mT2k+9nSksSTN4dBKb4sqSD37Nnm82I vJ9fBq3G4981Gwmi6j+meCnO0rZ7HKi5qIHv2S3320aDxrqp7mUXur1Kar82mtqvCwhdwme+jmxZ vRyPkav7QqmYsfnQIcE5PPiPkf4ybAJkcvCJObxvk610F/ODtCCXR8zxwcyrdQ/vHX95D8iLu2yf 5JSgeSCrteIJQi31KZjFRYwGulyxWpQz7/PhGJ+ICH72ecuzr33nFJy7kmpECyv2fVNeYnvgcamH a/7Lr9pESb9nc8pa2uvO3fXITGiQEspulhcsyPnEMd/ze0t5okE+T6Ku9zPZWMO43bNv3liSHmgI AisWEFTpNn25+aqKUA7GtLT7zSa0w503FkkWWhBr+E8O4qESnOHhAcvps7nXA/bn+fGtJBKJLxXk v50EXqNRLbA+3Lx/nQre8WiemnRB6g07gzzO5yUlcWhrodm806dMh2w5hVIn2MVDMGFpB5nC3YNZ R02rxKWlpTMFTyXff/Z+s/PuNh372SIfIVGwc/T3smJvzLghuf+k2XUNI0Ki7ik9stMC5y7PE3M+ xSWBJKUmHQjaUpLF5RJPb7L36GyccN9jMNYK0lxvXO1tJNY1PP6+KUn1VWZwWYL85m1eVY/OKLFz iUPzAwtPkcWBLK3aHnzQfipn36Z3KWvM7EOjD27JmNk1V29P9doWJ49lvZEfOk835voeyQ/9lMd/ VW8LxAvSSc0pgoJ+gPsL1ofO35ohyrXbDziLb+Wnqh0dc56aFK6N7m9aq/uiuKvxcKmWQQynlTs0 1ZwKGN7r3LsLu/5A35ZhE/VbKzrT8g07MnJ8h6xiy6yyFVrK2eVOcPPO9ePWsecJOLphmre3ZhAB jgWiG/bG8Vred/MS4VQNTjT1A2/kZOc9Bclo3zfFl1piKouf881NmS4vv2zTqBX3uRlu+n1Zifpa /zhnyIp/qHiT27y5hs2MyI2foRx2lE/ycXU1EIxpJzPeLgr4ei9XY4+n903AeH7bXk/iJ/OGhzd4 PcL7iqB3opWPL157cNj1xo3lywRTtkKEqVprYE/WzgMxcnBBUeW5HGkuVewVIT4u2zrbJ8aJK7ew fs8cyVob//h9wuub58qM5TmWLxYQtFZir50LnOo71m3LNupEPIltTQrxEeFy+nibffPWbVjJwEXr 37x5nSRe4cDvy28JMWELhOtcd+zi9ap3s3WOsR/vVIqw7CV8UZsez+1baQEc2iKBINSGntYdyWjX jmnQtPzmqIO7WAUFS/WgdagT045d4lMQkqt9e2bpLssZs3pQeoMnYg/s3JSngHPo0VwYeAqXWK7z Ht1bO6+333TGTIxkwOas62zy8ndEsMTA0ysWAwO6rMAmPzzS9bCT9lDjni9DRPHa7w3JRoCA7bfb 966KXmjY1ZGHNpz7KmRad9OlMMWog0UxHJwpq0xj93yVzV5xnP14ov1jjSccxzF6OfOJ8pbP1sgY OIQpOe5ILuPMOWVWPl1F1tzXc/YyI6i/KgOe3s8I+wo1GrUik8ow8vfsNrXzmbk6rjwja7693Mm8 w7rnmnKHBLQm95b1uohq8mx9tpc7og8v3cp+cdX71dw+9oHnPChjlYRnt6f35oeopI/FM7zJ97Yq iHYoJIk33L0yRUvUgdUHY3d4KKt7Webhy7YuzrluQ1JD2MVCoFG9FO33MXdPxSt+26/B09WoO5gC O1nCDRbOADOFMJ8nflp8d7OvKgBemr/EE2d/eJx9ZiFOKXNr0nWbmpqZfpdlnwT0rlwm7fGut2+Q 83tEVeE8dneBL4dmE9PEanumOU7TTFoPdeF4OselLhPhpEft0GqD7PAM4W0hwFbYjeLZp3tmSfqH YzuWFWeWur6aGxLWmJoWKnmdbdtOEGIpbSU9/+4QFR2zwAZzYmWHoo511+Ab3wgPyT7e23G3QZgg H503tW/qzlVom52BVkMRh3IKi8Rlhxc+M1e/P6PKdaHBK8+LYpBf1xjlkaDuyo7Orkg9z4wli/LO VR7tBHoDxios8nhDeGv4eTHNi8BMa3fKiDSKLJP0WFcecP6A38iTe7JBVhKYzoJmBVcfvUVCQZt2 3cnQlriLr1peldT1ob41fBuQk7KMDCA0REVLvR2VG5K60rRyMtzQjncxQyZ1m4FRSYbUI1Ds6761 i+VETd7cIUedecObKIZFca3gjSQt0CZJled9OR+UxuUwtTqLL8tBs1Nmi/GWpZGrl057IbtSJNTf 7EtDX2S29un8ruAdma9Nl6zR5wi6qrd+S3pFImqr0eIq0XLBr03Xtt8Rk1meaucl2eqpIjttaPHq wJHRjgPnrpS54KTdI8vep15PbOJ6k/fJLJcB7sGx0mbVCuEVkeQU51ulAZ2b3h82mrKpxn9+xLII K49ZS05zibrr873YE/boBGGZYmb8AKYty2nUq2STnht4neQ/sXD1wby57T0kyQBvU0gty077nolS yZcxyJsvgh58NHhz132OPaf3pnxxQwkdeCZR/DVi4+eTRbKH6wY5UdGar5I9PveIdq6/wE4Ocwwp THO7U1M7vcpxykVxKCbY2hS/4hAPxDiFXRqBb46q8d2V/7YHRHHFcrdVpe87P8xrsZfseN4BeFQj uwRn2LPMVdp1311D1kK8k+Ksj/GfTvJ/vKDmu62+ADLS5h9masnfS66AFr7ll/nkHFrxbLW3Ro7p TrH7PG+s3qxrS7ws6K7AnekudaHqdraHx5B448Mu3hEsl3XD/K6WWS0fso7NBO1wjtIDgi9P4opF VjvU4vsaNK6vDV1elh12vTXKXd1tuVbfGjuZW0+bMtV0k8rz/UxSo4QaqvjY2A5msR12gBgFyf06 yFs49XPuXfOqeY3gN/FSkw3pdwc2Lti1QL3KhXJ1+Co03ZpWX5nvVyv5ao6ZYBrfiTm4D60oLY4V KwxWL+DcwRq4UtK++WBv+6d3IB/eeJxj5x1NinNP65lik3zratmRwXMgGFg4f/56aBWHfFjAsOAy ZsWDzQVarZ7Xl6QL+tUrinnXBtb0Wn30h8x00cwY494tcv3ulUEgX/sylfhmdcTj5jK06RJoNZWH M2W7z2ubj2dIVdB97F3NZdAKCXTjMXTWTVNpfCFAdlO7Uh3v2Pwe05r6FXXUy+uShJ0oF0rz4If7 xs2VaUHQEZbz5g0ZcuUtWcp7c1qD4Nwmg/3zHUAGPCBakWeYJqtbccJqt1um6FOeubUXLsbvyI7f LHOdAFpu7ypqf6eKPnwF+Jk6k36hy1MiN/kbfHpy/BKHN8h2oZs7o5XDXqQ7dbIEg6g0CKV1qKe1 8rzoHg5PKBa7oyUpM9CMW+7WtVP1m0/FOtPYC+6EgUt8cvIW54CpkWuad9UyLiP9UYt5tOJ2/YJW Svr7GgVF/HId+3Qpm6bzCa2RG6YEY56CZOqbZcjRC1OUQvDPsc47Ew4pmLy7kTU8NICz2J9qKxIm YfdijQxLa0r9clG1O6+uKfh8E4t/FgccX83mQU67x9bY1SobfZbsuHq0o/6mKhjDTTX1jXnbHB5l H+Fk51Y3FIiP9Tj+ok3NQLcrl60Us1ZsjnPPiXe71dO50+9ZrBIXXKXKGjhLOVxqC0hwWKHT6WKU w2oKJNteWWcqnuFJMC29M+i3OnBl0P72W1Mu2twt/1R64OrOle/Tl1675iubZoeTvES+tmNkR9Wj Ea3v88pVit4qXXpgs6TboLh24FnbrO15sVwHjimFHnwjmNzksp7TSkB0vUXRYF8nxb6Z262fW1Ix LzubZf6Siw9cdqirQ+c9RkVHfzFVDLh8N5wQImo0x7s29TDrRTGvTfwEmYMEI5ZNfnoZKrb3Rd5k bwEG49m1cJ/g986CG2Q2VIzkDN0fSOfLzB00sb9ffs8Rsz1iblH0htt7gXYFmO5kteYdHuxUOTGP X7nzS/7S3kKOpG1BKNaPLS1hn4dlZGQuta6s8QYGbVB6SGTnjWNlO+tEPUbMX+lbli85vQijSCZa nnAf+giiuS3nXvX4nzpimYFZfZvsD/xiQsenM7ENiUd1ufzefKyd3nXgQwSw2YmRn9/zezxe6c9d FB/ulAuG2Voa9P3N83OrG98nrMzKylqnnU6O1LoJTyMuP3f+/PlGGUG/NaPxOd96a+xgu1fHhlu7 hG/sygnWqPnEapkxk33u4+Gh3KRH5h8ef/v8Op1yXnyeUujGge/tj6fkus169orn+colPsdRe1Lv 1j+XftWE97FjL935eUhUqiez3vvRIlP79FDrYSmpXoFjJ5/GRBwd7l9gZdZ01G5WQYSsysD3ForH sBQnJ+f5NVafQ2teqsajVHJSNbZvn71ixQpHZ2ftnh7ZrtdyvX19+qnQAfR405J1XG99NKujI4g7 n92eP4sLhZfc6kedSkxqqaC8fzDLvu2EtIuvoJDQ1KaS43e0rirO6TUUuNBSfuZl8Yk5ad8S8w0W rS2UZq92nzVP1kyTK+VDZmEoC1vwLjOOao3Mz0NlbTibgu1QpgESPC5xhzzNfPMk3kivTX6P657f tb5edipKoOye/raLnUIYzJso/LSTw5QXV+vq9CTsmuT19IS+lsRFbr0geskvaN2+wNevd9g3P0vt bC6UHdlemWpn2bsMus+9+2tp4YNXghTMl2zu1HdNG6sfuuX7Beq6DUiofemy7f3Mpf7oQ3Lzh2kW Frm2t0Dap7vphtZASWa+W8OKYBz7cpdXvXzbLq7fsaM1Y7qVe1kYyb99BkgV9d7mbnn1geLjjePc nuGCHTLpfppfo35uNYiK+SQP5nA0vM1pxu96refgPtj/NR5v9PrxMUC97pBYzUeQPT5y7oY2Ya3b d+8YUEN9l8zWyrREk2JRPz7Ji1blqXZfoRvBG4tvq7nnLH6esO1mENl62Fvi4OeryeRekEXo3l8g 7Nu4i999RvGtLK4D3C02JMsTQdpHJewsPESfA6FUTXEfKna8M4Xdut5uc5Za+g4rmYZe1oHwD3lh wm16j++x4nuTWU0jS0L4xJ5+eND+7WWuQs5J787XMzbPhS56idVMCURppR7+8mppRm+Nz/Y8fueG FSzazo3CF9ft2wiYvpRiLQRZ6f6uxnc3VU+e5Hd/f6xOkLS6SXPRlbnqKc8tTroN+HL6WWYSTvt0 2erq6Tbs0D0faVWbHra8OJUAwtswiaWRa4NKfbwrfEUVbrfbxceXuTriCuPdwu0jkmozOHo6FMtJ N1Sv+RmnzOU7KuN2RUsymPzmPreg9azdnnWPLTOHTuQc0vn84kLsK4PAxs9sUbaNb80qkgMMI9wu QuXG4uLiQESyuxqLLJOH5bK3l6hHTosnrkiXBvlz2E0UF9/JuUci+Cts5rm2s9o2sOi/qLOMfnFB 5+teXYeGtLYTZYlnRDQESbedyr7ISy3I+iYb1PkklesG6fbyKU2zPxYT43c9PFzm+tLqW1TCR9d6 Zd1j7S1JWZXS1eHa8tZHOM4uU890H1KqTtJ4YAId6eYUrCjUo5CruOvZ7bMa7VVH5U7eif3c27Fp 89ajIOYqCDuz068kLn6dAGlbgGA7yJBq/eVGhhVNq2cufIfZbBGec+hTlsk8aKVXZqhbdZXZ5cdq LpmH9GoD0h1Lfab21Q0JRqK0PtZHxGt6dO309n7WGbM4QDMKpCtY9UKN4qM9q65fz7oopnbaD4yJ 8W6HymnxGSaL+Pbclqg66SIurttVa72/OnOEuORWqNayUzYdtj11z0+ovM2094i2vFTQFVfUZ1sa k25dulaquF0kXfpe63G7NOAdHr5V4+I/2Oy0UrBAwee1gpDXaLpfatWPdx1OwbRJ4d+9N+5LLLyi I6fL/gVn6PvGvz4ct+SCpEaH1aUcNvH0g3raGRXBgXZN58tuZi+d5siOTsiXF4zwi9r0YLlUz1Ob 3UNXRGf1rMs2SPr8wqa5wtgMpX4zsCNcbCC+THvENpOLc/U1qIvyuYomrP17mu0jXd7djufxSfLh IqWq8ZFZVm7iqc7OzeZeOUPaeT1UpFBwabn0x5iIjx836K4YzHADvtRw8ZL5ubEFie8H6rRNuOKV Mq8PGXVtWVnCn95386UaSAHzeXQr34U58Cg8Y+fnVuXz6Pv8Ijo0P/Tp2+spg4fkhQpvsnByfry1 JB2l7amZzPLy4tLOF9suHJ0+5+AH/BotnuGBA5EfgX3RbZF/eiI3g68gFvBC7qkni1HJq97Xq61v 3zq+V1chYjGUybVatFZIt1lIoBqeVam6WDZ13LypKNnk3H3FzUX3ZGeOz6f4zI+nVj8u5Tq9GFfi uox8cHBfrPryzDWcz+2Uh1VivOsuTqn3nSOoacVxsdjE9q1xaYH6jcq40I6saMsD6kkFwRoP9E4l xCieYkuWyTTbFyndruWw1FTNoAAvGUBOu/hZ4575M+KSHs1XBwyHrxVssuO+d2jGpkL+/O/DXOJP JNvW55xW9DoWKKwz5Kx7PmHTPLuUBSJG92doybPo9i/+uCB0fnQUt6o/SlwgSeNMTlnc/qddjbkn 2zkWv1K+lMnG5hsWtcn/REw4NsPKvVPJrf3cfsME9Yadj9i1btl+qg3jx1nVyi9p1Xp2Y1WkY0Zf 56LvIq9uqrZXueR23ZrF5XttJKXe181aPuojlCl4vmG9fVZtxekBLpLk1nCye8X7c7XllmfCssS1 8dHqds1Gi/h6KqYMDxvE4IPS0jALdqdgfblZAwLuHr6687J3hai4g/gJEk/BY4kpfYVfRtpLSpKC +17m7ZaV9uPjl/Y7meOTt9zLMPx56mNNeY5VIGhn02z0/Nws5qgSjieWS7pX9H50LZS+qzOl+YN+ bKnR22wj2fKEyA6x2+cyK6Q63qnmslVrP7qiMEv9gegISfn80dWvJc/eYY1PcGk7F6u8rPBLauH8 b4OS201lj2/i6bbtz3SRr/tiPMfbm2VazJS9Pa25zie82D/1VH+qdDgzRP5SSNLIt6iaLf5oql3T jd7k8O8tZ9yUa2pBgKb76dGzOBCtpbVdUeKtfdTVU7DrVVOviOTyoTPRF25h6waq8H2WC90lus6V 7VQQigC5A+djblaRGdOeRXgYZGg/XLdOnWWetN46dFCoWmL0mxVrpSred9Z9jc9XFioQIhS/J8Uo 8zW8Zl2w8EzP6+Gh9ve6r69sV9rbvT/Hf4oH0Mg3TYl7bfe9Py6rPKJjb8v5XFd0vfyx7HfyfuGy TV18d0vivBINcdV770VR9nGcrsk5k784zRaTyqkUZuIaKWYtxoV67LtUceXJI1POiLMSLY6Zl/vO tRmxMHv9xY8IVZ3MShPXa7v56F3IPp+8vTK5HbPy8p1YBQPrQVY6Y2f9NZb6Vk+7mqldzcauqtWx l4giL5UyMnLXvH2fkNt/aYWcr/IhQTVJKzZt97I15HCP5a0ZvN+bMSXzH5g5DYn4Wywh9b9rfjqs M+DUWUXqcx4p3e0cv6C2xL9247fjgy6cgoHikGDfDX/ARm5ZFNvrGHluj9GNhFMHD98tO8WxnEQK xj9vOEvQmyGvsDRHa7N32fNsMxBJ3jcLlyw1MnRLidzT+JYyogXSfKmiuqXL7wygVVdGY81f4mU+ dHAu1FB5XF4Z6vKiWs5xh+PFPIU8hUSM80qvprmpQ1xCgk7KKwUEjxJKjLL2v6rue7hIWYX0fS7Z YW5Gn2LOJu2v1dXBTQ8d4t/sfGVCkAwI1h+wj2yUK76Vm0KyElwmY+a69PDanLzio65Hgz/Yi3rM Gwn1uyCJHSz/lP69yNRW+/Ulr/q5BqmWtpp4L7XZ0Xscb5e77OJ8TgJDJxQ55SLuYZbrp2nqidMV /Y6J7nmlXMujcR8t45qaJlebqxiqazWHGJrgZHh7ryJrqiW/67eZ8pueBmPmLzqfVqgWfXjpF9uw p62r7VUJ90VdVNqut8amritLmpq8CypMlSwP4OS02h5yVFhQkX3das0RjMOdDvOv5ZZymHredCuT xaLc5s4u34+5tB3fl/gxYNMrZWEnYeGc9+etP+AjG4w+LAJ5PfCRjU5OcfYdH1x7XjvEntF4+axN 8a3NFhW2jJkCleHKZ17z+A5XG20c2ijy5YDvjswdG4dwI5rv4tcst+h/trJmjS3x9IySxL0hFywM 7H2XgQA22FRGzzvBtCfoQEjYs+6p7LwDkrN5p3ux85qyrlIpiJgXFShbEEFSJBu88tTN87UwSjRY Omf5q9cPXfd/l3pwspT0qGDt1wNXDbvDHV0cbSQ+4dkL+epsa4yVV19eRZGmvNSVc5W7s0hk+Kqi 1bf4r0Eee7MEA5Ns7U8lJ0NaokX+snulwMl5T73m8YSGuPVeJS7Cn4uJ6Thyf+vi3swRXMmxV6Hs 7u4Gq8+Vcy7UNauh2EQneOR5srZX2OyICyl7/vHwoE4Jn2beiQ28wclWhy42qtmnhc0S4SKHHQ4p OhVDuXBYtLYe5OaUC0aa/n4+BWT7R0eFi4xeZM4K9vD7rJ+FdejR1Die9LbGRWQH0Knk5CkJ7Cz1 jZ4XzrJopfHE6WQOf2hIXfnlnvrBLqMb6pz93V4lcTo5HDNmgXSw7t0Bj6VFsTIjy1xdgUfy5czd df2VskFvT4h/2YbExFjWBPV1U53ZFzTwbT5+loM0GAZI8xHhOnOozjrAurgwyCe4IbnBV7ds8bos max9m1TvXZq7pMnQ965jqkvVO1MLaE7KDqU2krTGe7fjYjMgnJqXgULo1s0Onf/BrL39aW5S8/6H RpUnIxs/LCaaY0um4S1mr1XjSTvoU1t+b9pwJ39k6J5TC9o/mOYuyntyPF/ZXsF+VsFTryeXKgmm nIELQfbE0sbClj7FevfdQRdb4aLN22qM3SnDL+fMuhi6VGtm9yz9vTH7LmlHrl2X4VD85OUeYDqt rAISAqY6TiMrzKpSO3BceJvv0GqTUqLkGb0Yd7fePsPIGcZvnqiHFiVElt0UkiTyNlfM5HdlCSXx Ft0GIYDuopfl5c22+8x9q4Jb2FtfKjzLbThzrHRO4feElMamo9ddD/fxVo00Hf1cHbl2qezqcAPD VwW+X7cYb9nnrnJFTaBY9oZy2RP9Uynccg+uFTu6Ftc6pjrVfG690BjYYt6a5J5pWln6NH9lYepq AzXN1I2fPotCI0r+ug/odGTSR6107lXb0RmX3No3JBY96z4vOk12SK956dvrPgmefY0xD/bm7RRa /RSkEKpxw4NFaxZl9uWuWcSXcuRxd3T5Mfbj9ds6rNZaXD+4ZbPSM3vbz6XBB/Z15Ql+UDNT4awW jIqKORsYvnGXxoL6c4XnTLblJ7c0bTNxLikvamlM+dY/rBVcl/zaKm1Yd/958yy3zrZItW5tM5l7 +3I2sV5lk8/O2acbN1d2yKQUxY2f0d91JEgbK3mmwnfjcV+CBAgPm998Kz3QXiD58aqH3faF/Jb4 2Y4D5mSrJ8HY0ph50EIANiUk59BVEAxwOC1+sfuuPLClXx6H+Ob0xFcOfTB3m59UZl62ZFXZYkxZ pfimngf6GdIx06AFinhz5zNzvIg3etcIdKkc8fbx8T0TpVC2xCAvOfol//lbaqTokw37bes/tVq4 vtROwUp1L1pGZjng9ln9K4dmVoKuYkfPm025DXmPjygWed7ac+aRdHZH5auagcvWicmfWj6dSTo5 pSAp7cXnUpmHn9Ujv+47q7ieg419udnigPSLb46WbpA8KLxaLsni7EUD2z27TNXq8bZrXEekzcoN mvk5+cztBUvb8/hzh9c5VLDye5g1ly7gM2/+uvPBrbLGOoNKow43W837N/u+vS2Of5TPZ65ZQ0jj AFEKah2WuODwq7nq9pJSw+TB/tsJtfci77Ne2G9TKK3Iat0Y+GaFaTkxceHi7faS8vLcppYm7zxH huZpe1S+l6zvLi3mKVsKdeHoswuzxNWugLE5roVav8xq4ZOkqqMpNmeM1c7wXApTtAbO5q5bGkb4 tp1pi3ZEqBkxcodl1bLW1JfBrd/LDOcv1t+exDEbL3m14tYGO3Ytmxc7gZM7Ujnr6R7Q6lUCIPOV c8nWKw4CV92vGmx6Xldu+amv/sy0VyAQsed5rqTg8wSkog2Rr5PEB4dIvny3H0gn1dRtiVx5uZiD S3zjrgX3zWbe3ps11CNpv2ltAK9VyR1DaxtI2O++5Lu77Oa0tuGhXPYiPz6db3qJRZu127+fcOr0 DThrVes773WEe1Owiwo5pMv2fVppsAFBh+0yxeazesuHuzsPcJwoTAxBzgXwXriDVbDmiaDuSj4T Vmez2IQjWpewuTLT+qcnfbyn7hvg/+LCmSUv2ec9uac/v0ndyyp6m/KJA+4YDj+lUN85U2prs4pw X/usOq5RlirIW28dSfdJRpvGFutwnH23u6F4Vk2Nr9IbNrZXykJ9Vx0s39/N4p5m/Db7PXfhhZy8 pw7VWS/FeYtucnARS2y3h5vZerm0UtQzq8gqrem4Tt0HICa9fFwRWMTdG7ey5Ykvcwieqx6puLRo U8md499IVevUOc6uUvLNaQS5taz4Pjbz8pAwUY/sbM2lle/vz3QfqVTfoR0bvNNxe5jJ4L4Y5RKl ZUEowofdedncUMHql/TpnAGXQYhdc23uZUkWsiJ7LPDGXvN8z7zVeAAUM3iFVEWw9rs00n3LeThD noGTi4SALClqixCBFU7dw7r7xsFFPE9P8nrsvWVbe7wv5/TSHB9v78SdUIOxhnEs0SpZH+5m9b4m uCYntJ1MvvPk+Jm5yis3PdH1zzrgkcVryS15SzLyPl5XvtY6gZNTx/YOYDbnmbl8IJiu3XUvqsxY Qf6bP8d8Ti59aAVvSfdaE40TN9Y0VFVydwdjnt7nrlkvJfVxqOfq1sW6Gtp6UW/OQguZeiT7xgWD g50Xjup+3Zt8OKuhtfhGQMLaPi2HDYkGignCgjW3IAG6AQTolUmWy3B6wn6bzTPWaZy3c09LRvlM U/RFRwt3N+q6Gh1IWbD1AlZyn0FCwl39l6C9vLmRlzYevJKw4qOPOE9ZW/pCV9dXymsFa8hdKhne PvdyNZT2jwSEW5ihHetmUMs2R0oSIhNQUaqrdafqfN5640B1utQmfwPtzASHeCsX9eCdRl1fDQf3 JUZ3KvMu5Hw+D3J957tjL1zU3x/yrUI806zZPsNk8e7bBlunWi14YMrLdy/VniBTIa5+cPByKUh/ hduLp+VdlctNEN3ja8dbKG2ol1o7t6UOJRi4UHT9sh3OzhKNjY0GeWfZ1q0QPhLsg9k9487ZtrYH 4hl323N5LQbrZYmtj0qVLaQf5RsUOamuX7x2+teSrKfz0jo+eqHtboUZRjyobzo5/G73+wezBAXX ycurv09fWhD+4OMXgxht6YYPxQVaDmXGVRXPbAihYj3WdaQwkiAlxubL95ssVuu5UJoCKFRBM/cu zxZp3Vd8Ip/2CR6oNpV0cAapxZGultDslf5CZ0NVws6evdIZ7TnQsHLN/pIgjO7g+8TVp4yLFrR3 pT+ovnD2YDp/kkW3XjlRxb61SwDz5mh8fFh/d5Fj76fdIUSlyA1e79aFHloSlXSpgDfgctrhT0fL OC+Hc8xn10tQP1w69dBzuTf1kaw3uHdhqqtM8/z2cZPRnhJ2by9hVs6c51/hpk0iAaKnXU6T9OWP 2Hh9a/srXMYySk2BYYTwgkV6mZ90C8Mf3DUPZd+flJpod5s9c+iLsnPq8SsCvEohUTiD7QuUQqN3 xihLaGtfCicUavuvfO20MtDGgGApsnm3J1kANF5RUfHKb8W091m9Xou+o7bf8DDKGFQICZ4xNDBQ 2zjzgKvVzAPVFR4eX9Ot+IYGYjiXh28eGc6ocLFcsURsa5Rr31oF78q5J+ftf59a7CW2v6LsYX5Y 5jBWRi8IZR5pXGTb36NybV+i7a3dCQF95rUabSvoA8BptYG9Zu4OmRuuGYv47UGg++VltUdax1DP zEVr7WstbytYRCn42JbEbavLYnczfn93flaW/eBQy7sbOro9Fg5+fDgZgd1xIcqJBo1SPZpY0F3V h7FVHoKCBqpAu49eq7m2hn+3zIFw035b8Yuobr2qdPmmd1Y1xak1h0V33915/0aY3Ml1l2XMP3UZ k21yn6z0j3obu0/iDG+MapQ3x1xOzk2RwONMU8hReHPN1kfKI/zCWmnHFgK/tivm1B2tom+Dfdnd l6VDnRbFG+2UjH900WwXDydnytKQ7FU1h1DRmnXyT2aKTt3zrKi+LDHvTB5/z+cj7LuchvvOS7mh rLSEt76Pd9GSl1/mz3FWKjAw8EkwRnfNnluL3N3d8cZvjz0wLQ3h23bsRvIaT6mwo3b9949nuA3d 2JGV++pS0Gtn6edrO+sPXNtyDv/kaZHxW6EzfZ3i0F4BeYv1qne/PbuywUs91VYkUvHMtUM5p12B C7RteH1kDi/xdew+XGLtqVlpmp67ZxSEcp49v4gb/TioTk89Gc0pmynlxMPJslGuJXbfOSP72Zyc z1kXCzh9rI/w+HI7PqMmn1QNXQnBMpsb7RlCMP022Fm4EBhE641W+tAgvk9Dr5BZkTKc1mLPTXhx Mkyyct8jiYC31wl8ivLy8tiibG+pu3rPF0hJSXFL2BrlmldVVUH1rXH7k6yb32MWFp26nVbBulZc o73gcmPOYJ92+oDFgjM81+v727g4OTnrY9iE5jVXPQp9cWGt6o0dV7cnkUzeralN9t4HRvmbHmv/ hwet6YP3SCqyYdurM26mDA8oyMtHHdzBGsh+6NChGbNmvbSGzuoEMX9tnn/o2a3Zhz9WHNEUXx+7 lzR93vdI83L8KuXds3YDTClEqNNvr29zdHExTKnMy1sNsCxFRWl+1Kt5rtniade6rKu1ZdupBcTh geptyWn1H+KXcHIGsG32ed3pGR8v/vz5vsxpylu3viCjDp3wsmI/UvHV88LF6f5SNXlliRaDvbUK bFNsPpee9vbezBoNOnXs+HF9yXzRVaumewYKb9Pu6Zgn1c6yfPmlkdLza3YevXsXzTZlSuPrq0/t +Edakqqthwf7TJfH74yc/sCkOPVLR2+vY8ZAa9pXmbyhnmqVT0+Oxzu5FoZLN5cntYXkdUvceVZY avW2Vqg3y3S/9tOi1ktWg3sP5EV4EGueBZjgjdplv+TPwnSPQFXb1e4DcapDI8lLDF0OaPlo5y32 65d4aFkd3piamOHnUfQV3WCnaXU7Xnfge8vS+uc3VWM2KykJi4m1pO6ry11nn6blhrUp6yyULSy3 zFQyMzOLPt6gGr0dqnhbJuMavOv6Vn2nivjM4a1e0+dAV012NxW/LHxWIxg9IhXm4JD+8urqeZX2 XLEpNtJLMU+CGovEMbY3+nwKgtbt2+i/XBpYp5rdtlXedRV3tNKgOxYlHVqj3If6DfKstmpMCWR3 7mrYoKHBw+8xaJVrLiIiAok80CKh8ho5IdllvpKbj1/hSNJyNSurKWh4IzN7+eWa+Tknvb29yfOU sl5MOcNDuGZYGA4dwn1Zygmru7pL7uRcjGHBMkhVJA+3PjaPHyHbPtsIjB7eOLDAY/jc+W3PgUxn gxzs+coIj2GKbp6fPhgYqAjvwwPTROdukxCSpYU93koHaMbre9tf7ncfPD7rdVI8Pysr2rJKWEra cpAbyFrA7ZugBW1tbejO1NF7UzdxsvouSY9ZoFL5bYZ3/nR/2daXn55aDLbLsa1YoSGzSlAQmE5g lBTkcxRYK76tOnZutUtnS9Jy177Pwrf2JH42wINWrVZALjr7iA07i4XxwifC26SCZSpDTy08Z1St 3cIO9KKu5Oasi94+3qf9BZ9Jes+vPrtM2qJemXRiTud1lYhFin7bn0faQrd9jGZs3jdsdlK0R0C+ /+nqycEb+3BhDlVbaohpPUCCobV/q8Wgj3VG/cXXt72Oj+BfMsu1I0fY1fUb+jL4PXk2lAQIiqKa ormulENL3xnN1W25R6edOr/mqp8aQBIoeX+GVva0yyoylvc/PnrOppc7W3yJ+He9gsvyTcWqeWtB f55L87ByWrEG7W+verUo1jKz++BbIctwD5lLFpXvOraCgbAOUly/7Gy+wVODoqSCQBdU0sdHke18 pW6WLeX1ua+vZtg2B78IxgQdjk66CjngIsj/SRhaREAeOKl8i4oKSfLEIoGAesGZ3+eueo1rD2mL wxmu6/rKtd7RUaIt04M1je9yo7lRYhkkgmehJhLLH6C+2UMRBCsr69Rp0y7xyXGcjTy16aZ6VA2h Wk1EBG17gzcIldXfTdwaZJ/RE5GZmQneW/YWQg1eMdh02BkEP2fT0iRbW1uh4KfuccqU3ahdlPKe C5VzC6WmlD8EL+/ISLfJ6AHuGUFcRLEZGGWYum7cbo6b51sS5sl4+sue8Jc5+iW/kxIM8XwZ4Pm0 ir66zstbyQo5Z0/v84vTMvV19+WZ5sUeOl8ZMEzTj2N+ABsK5GaeWxWw/p7qca8TV983nzXS5790 VLIXA98s8hEKjy9FH8zJ2VBfsCOd7Non7GhEgFDULXRrng9+T9i70VVuxvc5031LUt0Gnjw/195Z eGU6GRrWCCA7iw4HJARcUpQN91ju3suaMTBXVD8TBXyevFDhjdH2E0p8u/ltvjzeb5mV1rYxzX4V O/AonEFRBIFdAvmjG9wbzPwVRovfKgbn6AlCBUdea+854UAyOZuP4+nJ0DBo/DUvcMznsvomdN+I dbEot0e4hL79tfRi0fTFXmqzC3YdAwk4zjHnoMbxJOxqdRkfldP1tjXGR1suNJTMCSEe76lm98lp 1oPk/RZ+2m3P0DQXVNyT/W8yXcihJN4kBYUNOad3JCrguXwsop4c3+DoYqPKxR8RmladyV/7KSCT 33l0DseOCHAZ2JeWHWM/briIPyg+7ehLMcfqCPWZsrLq96amp2+fKwxQoJSmbWZ1cBL62N5Xtt4x t6WR9c2yG5Tg1JMG5wLZuFDrra2/bNu1q6T8bZGl2Mkc69qNOS/L/YJURJfLbHHsFfrUGHoszQHb qr0lecgmwVFYt2Pzk5pLU5dv+RjgWyk9M81lATFJqNni+fuKwM1JQgEGWwSlVwRvHTH23W+22Cxr r8SelIh5Sa6K3pboLPesY73Td2bLBgtCn6Zx1vD6RsTwX2RDyx/+JtTl8oHjwYpvQacHk3k2yuUr Q5TfUaZSfqU13uvTMzPvWSevGEm5zDYY2KamyNZsLynSKCJ0XTjg/EV5a+dvFyKK7gxePhsov3EX lutcYHLwefmN1gtOPX8uFCUU0FsoLEK4tM14i9D1VQHnw+W3amCfN24RKg/cnCAcYLJt1Ztw+XTp U/jAzSsv2QZudtiWmsJ14XuhcG1qjyxXxNqgrtt3XM4f2RX6UU/p4sg3XG8sa7XNRyeRgeqI1plb NqgHelltm5sbuOzY/q3oVpGs5Jjpn8J5fDeZoJcbb3CMZq+9tMQ3KL+37OVe7nkOpIrKlNacp7X9 eZb1VrIxr67fUlk7PGBADhBeuSJhxvfsg9pO077EnzbQ7VKcXsxny9smCtns/TFs2dPAMCd+byy7 /61Z/vTQAuII9yCbnNE343Pbp+XFtdv35JY/5eWfF+Hrk5RGkgmX6e3tn9/wqbOwY72r1OlPta3n hobiU1trrWoHNGVa/biMb1qULnvQ2LsDHxMy9wSF90q3/GmL8PxY0pMtKiejRizbhr2uJbfJ+mV+ X+8+tdXT+/WsuMATB7efmz2Hz2ORr+x0dt3LJb2Rj+9v9Z3T9+Za9ZZQq5rtoaeU4laJ6JnFhmmc WfHB1ugD3v5dcIqx8PXs3ZmHtq8OOTTEOr0m2/HKN96yNv4TA87T5uywcAio1z2xtLfZ0KHapT08 jcslrbTszqywMxLVjaXHUZkoW2LToaADXOJ9xQuKbnyxyAxJGzJptNh920lR7MvOB5fOmFw40KKo Wj3P23jNk641NbuOCqYuxDftSle0E16T/tX64My2VMFntkLPikME1PI+39W9L/ys+fTr69s4+pua dsUnmLrZ5Sif6zvDfj1xf5SkSZSKeDXr7e+DI5nT5rCwPEZNPctZY2p8UyOtQUfMwyYlw24gyfZr w/74vifDndq9m45vEhFctxH1dHiA25cj6Fqki3+EmdTN72XztupHhPU56fpIBEndSDP8frnv1Pnz g2WljzWbMqI6W+o/W3a+rG5S092vW12dRHpR3RSU2XKfp5yn2/j2gWFiZmpqWn+Fha3j/QXXFp6f f+FK743ej22RC87Pd+tu01XMcf1ekrA7rN1yp2KFl0R1yRq3b4tFhqMKCrn3lWaysLAYCnr6zl/N q9LUHRlvavlJW1qr435JvoaDVub8lpSPFWrpCiOdmTdNjM6mV+1+tCNdfzNKfp7Nca257G9m7nry uISgpJoflh/k9cLwSJ1GdYSRFOciMw2J/YCg5LVS8zfXRNYQPq3d6Zw0LJ1DNFxj9vxzXo3zcNgU Fs9PR1iwbIP1lREPs+fl+xxefZu8j5Oc8eLF2qAok201S/Zcjt1honhL7MHSE1ffe6vnKGY3+YSL z3Uc8tvGNzRXvFIx+juvuDGg102MYNcwbzoLy0HPGQKlKRkW0uWlYibxpNLUZxIEmeKH7ZhFgk8E zy86FxUVHGVa8LWvsudy94cFHm7Dd1hZHrcfGuHt5dylFj4zeZfKjJvkfToqOjNurvWqv//O+Mhj pwcqJ9lZWO5ysNZJqAXvdCwecY7JjbGWLPn6uj6sW/AYYJ8k53rPr7MNH7GweJ6zmjPjcFhKeLwH KwvLU37D9eBnFvUTLGzgz2Ps1PnQ14srPKE/d2ezTgV/PPVnCEBf18mxgFdYDi5lmwF9fTn/914d 6grKHFR4eVGsqLejdvHChZH7LVIU5kl3nZUZ7q2VqVfbs0dEUnI/BoP55vxII+HQ8ZDQULE7PODl wxcPp83iRu29oymSWR2v4LOksWS/ZXFHbV63z4HBjSByfXdV7uT58+cXBbs0vF7xua6u4Xu5pZqx 8U3lCJm4+nAX5Tw/vqKCMElzKQ6IQO2pZ91FxcT22Nvbv1a3sLgTDdJ5rgOuO2+rxc/1jdd4sJVU 5RgpKiq6aOHClVt4SBaXT58+XdfZd/7cOV3jlsebd+zZc/3oUba0lywnFvdP9+RznLVXdsiw92wU iOCbcnkt3wWs3MSmy4XSPFtYX1ST4zPlk1zgxXX7rgUHc18ICtq/Sxz9dveePWVabOjm1ySW5vUs feJ4EukreHIrSBp8H40MDzQB7TUwMHhdsTNSUWTlSrni4uK9QTMB7eTprHWZOzQ0bhUUKH+ur2fP 5eHh0eM+ka5tGd+nHa/W3d299yLZDLpgxz7otc9iwpxumROHXLwqc9eXfm1zXT1sTj5VtJz/dpOV Rhs5znJ6YktArrH/vEcLP3Q38BkuDWDNxis9SErq+frVpMp9wDxO+5GGk5NTCNFc42D6gwd7Ahct XVpmGnbjxo3H1lNtDiUuXL8xbTmrnhG5peOTwm6j0lqFd6+tPtTKtR2zl3bO26dYp9BgmTn00OBV cEdK5+ynrwFjzoeHL8e7dzXszI+QPeBQaRdENP+w6P46CQmNwP7Z4ubm5kc+uzXOXK2mrYrdhScQ Gj9medkHcWafDjnhzC+X8CjLQvfK124Hd4/6B/fvk1stn3Eof+WDu9Mv6RD1/Yx8G1nf5WmCg7N2 TIfK5yzc9iJ8C+qJiWEBdIqUSz+hZ3igLai8Ze6gpppaTGzsOgVFxVv37u16/vz5hk4XmZHI9HTN WVyo2Rr2hdI9N0CnB3ra2mwOlCdZljpkdIaxLgeWkyX2oXk50W2gvPphmq+Osfz0s1kSDq2X7927 9+7du6gXL7a69b080EqoH+zrBEP6rtZf9s4D09LpuZKSkgTnLqPPnz93S5i+rW0uS/yQaOi/S1U1 3ikaUpLvRubmxc/Prb4QGspru1Kwi581KkJDQwOvmzsbujf0Q5pDPBaLvSPhUHCZIuHae1dmsP3p 4zhHkmVV7LVrgo/6voSGEEwv7tGfAtry28jSGOPU+cUYyL7GQ7NL0SoRy++vIxL3Vg9+IU2RVVNT W7t27baFq7bv2LkzAMjb7l27rjUWxZiW3tFaojYXEjV2gN0io8+guKTke4pZRbKVhPug42v1PXsu AEW86cU+70WL/VpxcRXTktiZ/Yc3QgYhiqbzr7wHl539ZNHf1Xjaz+9iXm1AXu0bt55KQ4ctj+9C m05NQBL7zVHqxatXu21sEiuFWf3q7dOmFJIskvbr6OgA3XyQtu5xB1Q6rG9ouBaFUjY2Nv6Q7gSe pOSONl2Anm1edk9h2rRp9kFss3l5iWav91s+uu5Q5bQJJKv99bIjN729Z6S9ZFvW9uT4rCNtvDw8 eIsKspj63ce5pz0/6XTU5Lx4+VJVX//6rdu3CeYf8ACP6WBvh32QgSTbM3RxZaW5w8zHd99UVsYR TEtuAPkAzQZGSbYmP/1yy/MTdKBSCFb/dK4fn6mDiGdtmITd1r6+vsCoePfu2yFonaPQ8TssnJZZ HDe/fDGQ7n6nmtpT5QKNfYom6sKFC92UpMhIubVqd3Zv3XraIvnTdKVwqX0yEW23yqF99hcuX46t qNCEDMFViamPra82hBbFqNy+fl0hc2Sorfu4uOsGMG6vLd07Q3fwcxy8uUOmvuv9Q/NQjlmzTqba Pt57tSmspubQo28v1qbaNgYOd/h73LhzR/ncapW5n6/O5p16dr6Ey/dY92/nIhoa3kS+ePbsrA63 Wth+dfUbXNqOG3y4xEv6u78uXr78DsXmy41bt26VVkAmdLXy5R3m5nHW1ta2bY96vmnba5I2viHx u3UFhISE7FZVjfzwQQOYN9PiW3v6B6pHljc9ZV238Fb95eUn5/HvVVI6swSlyX36G2v5sVsOBoXh cffuYRUUFCB7/7UkThW0umaefi+aE8vHx/flEs4QKG3+FPa5wSd0gsUzB63jndoyBu4Yc5/Yt2vX Am5TU1Nc0du3r2JjYwsrC82TKg36XTOurl12d+ea/ujU1A+2KZoGWlpaB2OTk99rPjDZ4+3Hdlf7 RoQNdHsgTlzcsmEWu9mS01UUoLKNHY6vZAGHDBwckpx623U6o0MtsLdv35ZzQT+darh+o9G7Gzu3 bt3aX+EU/+h7yJOnT7tfy82bliu4cuUDszLso84Cyf6GSP87KRkvPwc+rzxvFTZDoToqJqYn9eOg xsgnthORYGyCo29WD39P0rin9/xsyWzyhjXO9dUjw0mHdHXtRoZ6XqJnVzrVh/X3l2beAX7m7LKn h+VYrDzlTs4VkZbWSkhI2FC7cLXy7HVtb969E4oojPHzm2tnb3/r/v3d7pkHzq1Sunff4LHFlMZQ XovkDcBuvVPx6Fe1s7VteBawUlRcvPQyxWZd3NLDR490Kc8Db9+5g8oPly4P5GFdzbO5DVAKSZXH cGeE8BZ+1/YjgMzMxgLJtvt3DrKv9CSvl5PzglyLVXzp2iL8ngMH+Lm/Nje/O6cicxOjm/vsa7dJ fUHYh0cuSRUWSReEpzzk3Vy9+a2PeMYNFZk++VOnToVIOtwJd/qyVF9ff98e1EfuKS18jd9y6oHW Wqc4lnkGmAo8qu1w3K2tfYd/pDfvtI9PETASMfzD7SdDKDbRF4QllyR9svMsKdkLbPR3Hv/TpznW tQUEB98YGujZv5f34+4pjbxboLdM4x8ZbDH3PDfnvoNQ4+egA3OdtDyLwBeD/JDrTU0m20x4LXrV TkyR37Tp9qNHj0od9+/ff5DiebBrDprcNRf8V/B6hSfZs/TrHjk5ufiO8IRQi9TnTYEseZGWnllX HaD/TsxlzWYFtrcr3mNoG5e49mye6iTLiNlPdygqnlC6wFqgUM3iJdcG/Tebj817yjrN5B1AAvu7 4z34uL82NLwuidtPcPqmdz0q6r0638ftDJg/CXbNL7+r48XDyzul50RVgu5JYIyFtrwMEgdOqiT7 1MIHRm8EpfvqzknYfPF9+/btfbuveyFzI/6oKzDs85SHVxAaY/WDXY9qba507cy/FRfXYlN2auFq vH2z+paghV3+7l0rzcsfKgGZgZwuNCggTFLfh/o4A6HF7wEtuntK+DdR3vhXfQ/uT7K48PLzLmA9 Kq9rFoMoqc46BbibQw4iLJ4r1rOwenK+Qs9eekLHYWlgVGWaw9fGmIiHabNZ1ntzAox+0FUgIBD5 0IplYVmhCNolHzUOsQ8COFkAzvl6Pa2VqcBALeLlXeufF5liU9/kNU9mRkjn4ynznrXY387I0O78 kn+uvGXvrl2BwAKc0t5QU5Fio5HumFBTU3P+7Nkr17cFNbV/emqdoim6du05ITGt1N2Zg5/Fhbeg graB/wcO6ZFJ+X3jc4D5ixYvvg642vT4yJQVzotYWK4usHAAHa2HtjV3AYRG35vLnL+XGRa/fXvt DC/JpOndzVt37pS8T9AV1sqwj0pL25+SkhIi5XTPHajcy/rOm1FR8sC1OQPnLqwlcxvj0KrJRz68 3l/6e3CuP388iEPljh8/vqE0HDp4+VZ8fBCIKL+3lA9I8d5zG7DXSnfc6S/1zRtEVql2X+8fzGLj k3VPL7zLxnJ4FWD8+sB3FRWxi9fuBfHaZl6SxWxfriVLRIFRAQ77DeSoHgNFCOXg4LhvUiy6ZRcI A7A43AMQMqxncRrqLn1gWS0TdyBTG9iqHuEt/jL9N4CVPvpd2vit0PWYGIj4K1euFII8s8m2+T3G SWr5ll3Ozqlf8kNjpF2+G4EIRa4HDN/G00kHWVmEtlg+6r4IHMX5iIh4FdkhfLs+94lVSiFRmcPd 8Y9KGmfySEcrh92qzfNnd68CIZGgoGBXZZs7yaiqJ6PnEeuBzoCICP4Z/NIDWCWckQdgeO1sqH8Q 4kvRN5fiDLo0DLgVX/t4bAEm9C3wal65CxYsqOsZmCIbAXQFRMY7d+7c0AlGcLpmdVBG1/UrEbW1 /d8sRlhY2PBQLUCtsMhouyuBNAttqaysxM6WK39oDjmm+M+fPmWpLN17wMHqwZBVzzoWbm1IyLe8 FUuqECzCEwxececDK7v5IQUEGC2VaWogiN1guMHExMQ53+4FuyAby0YfU8CJwCjg0wGb4vYlKgLb 8OhihLSL/Y7yZmAdQALCphttbPL0xJxHbJu2b/cVagSh45SqeSwHez+O9rTOPu2BVa2i2L578g7V bknfOjshvCAygyzwi4ICyGWz38+H4r2a7FP9WfPcr4SE8FTal5t/ABYF2BbhaRHdz169Om8cIopC 7QVJz5MnT84HBZGi8maw3OWHFGnHjh1XQAoVp5W2t1B2JP1DefmFwMBrQFtNGt9e32AT//3izbV5 Wqgg+5YP1yGhio3dDrSjs76wVFVF+jrwxVeS9KGgHliu0jb3nrTHhke6ps5/iu6vqC7OZWUp0A/W fMTOcvd9xHDXahCHrQdhEBRCVX4G5kIeqPWxdx7anlUg4NqXaACF/f29tf6Lly411rVjYbndsWQd y/rNi7m4boOIXDV6+04XlzTgJmSNqjPc+ssK3RV7WTw5vXECLJ5nnbuL1faAYFY3z+9mXJwSpF7N CXldwE1/0OJheTydZrc+2fzzfHeQ34yc7fViA3cB9HWLgrL8nY0Hj7L8v38/+Weub26jb3vAXMfx gJmOtaH+ATNLQ5SNvSEzcaDBPxKJBP3FkAhoxr9oNBZDIGIJLBgcgYhBowlENJYFDUBEHIsAmplE /OyfnY2tjrWAAIuptbOppS4a87PnfvX7/0//Sck6mpsJ2Otb2xhbWkgLYlBoQQF9C11LPWMLQ2lB O1sDMbKgAGCRhZ6OmaWFvrSghaWgrAyH1Ap5Fbnd+3YoCABZEdixZ+P2LXICgmLi4mo4OXFx+d3y Aqp7NwlgUBhxcQVlQQ4BAUEjW9vDEuLiDg4OKAccytLaUHyTtc5hI2NdG3HwqDj0KHhNHDSHwaD0 bPUEISRiYgJy1vo6tvp6Ag7GtkYC5jq2h80sbc2MDwmsoTVIB402KiIgJgbehKgy0jc2NLKVFsTj sIdtBRn7iAHfjPUdNlo6SguiBdACBBJRADwlCJDo2RpJC4Lv0BuAMxY20hNQjgVyC1FKe0TC0czY wnSiBzEUCkV89FfQHQEpPX0DG/BXQMrG1slMX8DW6TBgqK2+o624ro0NeELUxcbW2tJUXwy8oa+r c1jiEEgXJBlgJpbGFhLWlnYWejDU3NhW39rMGPyRwIzqk6QbhEB8FAOEU5yGVMpQwFhPWtDA2NDO Wv8ARnCUDirssI6trhENJCAFvhkJAKgSYAxgigDHdpg/8Ec09AHiG4czByQcABPUsJmZxEqD0X+S guKjzYsbMmDRcdS3QZAwIsZSYYyYSVgBHJmMIo9ixJBR+PFf8TjUKDngQerHySmBSYERQ7zE6sHU 0DDrmhkfFoM+Abm3Nluz8jBaF0/A6x3CkYgigghdMGZGOsaitgB6QhseiZVo6qDQRktPx8ZIx9pa x0mCiKL+sg7+wPiIpYEBMMoSaBQCHRVMAMBP3iHsn3aITEHhyQQ8iSRAxqCwGDyaOMpkDA6PwpLI JLwAhYjCY9B48AkCkygoNAlIP14Ag0WjyGg8noSDfsBicSgykYAlkgBfUGgikYIeZRKWSEYRCWQC ToBERGHQRDyGCIFxGBwKTwCt4SECKFj8KFIcgYzC4gloAkkAD8jCAWoIEByPxqHQODIOixEgYEEr BNrzADmKjMMQyHgBAhpFwJFIGOrzFCyKCJ7Bg3YIKCwFjcH/coiApIxTPRsrOx1rfZjddN0dryIY FEAqJ4BG4SgkMiAY+o5GkUgUHAl8xuExFAJGAOIJ4AryF7yA/EZ/mDCuFepjBAExBjDtJTH6W9QW xRiahn8TY8BBa0CM2rAYjWqxsT+I/fim2EQIxH6kQ2wsoWJIB8TG9Evsh26LTcAbsR8YKDaOM6P0 QzoPCb85loLD6OuQCIcOIcM88eDCakSgj6s4fWCBLk2qMvDw29noj7U1Y5BMglMA+BtE49A4DBFA IOcgYWStbyAtuHJMR5zAszSdJJFwGCxM8b/Ej6g2UKlf4UeUHwfgzMIP2xAcCY/5BX7EyAA4nkn4 6aYKTflV/2FbhiFQiMzqP2IS0cAC/gI/bDQBejyFSfgR24sjo38pf1TjDMaKQiYwCz9i5X8p/ogX wGEwJCahR5wJmoAh/Gr4YW+DpeDJzMIPOy0cmfQr9DSnhgfSyrTuI74Ri/1V92nOE9hdLF37kLhj wvgD98/jDxIZRaGQKfhx8QcGZAN4CsgLseMDEAwFRSbjgGaMC0DwQL4wRBwGPzYAgeM2htiDSECR yAQMtQXG6IP2KEPggYDoMQcCYgg3fh0NkhlCvT8LNcRwAqOxFg76xDH6XYwGwAnAnpBMMdBH65J0 9PQn8ISMuP+aJ2RAMgnOX3pCxo5AlhCWDjQai5tUF34f/6SecBx+RAwxFKahn8wR/oCeJuw4Cnpy R/D7+Cd1hOPwwzqFI+KJzOr/pI5wPH6gWExCO6n/G4cWNhA4AhrLNPyT+L+/1+tJ3d5fRDuJt/uL WCdzcpOgndy34f+5b4NdBd2tIRC6Q4NBDK4MA1QED+JvkAmN8WXAH6PQWAIeOKaxHg2DBRkD+AFD GefSiCCSBZqGHZ9QY0CQgQdBFgYzzrvh0MDgkdAkCmWcj8OBqIhIBrRM7ukMDND/2NOhaY6N7vFw DMmeHhCmQ2gDnUMGEyZ7Y5GOTpiNzpH9Zcc3pr9/TMkv3SFjp3+tLP+emEl94/+cmMk85f+amEnd 5jhiEP0FGfxkETwTqJrMmY6jCrEeaCJpsqzu31M1qa8dzyvEdOEnTbaYQNUkHngcUbDZxBMopMkm IP49UZM66PGsgo02moT+u6yazH+PIwpxGEAI/66sT+rex1MFeysMCJ9/z88T/lUOSyYRqC5zzBQ6 mgLMwAQJLIVAxpDGe30kEKDnrkQgsDjakwzuHslpx8ycE/EkCpY8PoEFyAATCOOzWAIYNQwGS/xh 5hxQD9ItKC6YNJ89ZHDoH06dA++Opnp3NJTOoqm+nur7aa6eZKALBI+sg8dN4OoZMf+1bJYBySQ4 f+m+GTtCzWZH5QQN8qnJ5zV/H/+kHnscflgiwf+RJp/Y+gP8kznpcfgR0ccQMMzCP6lfHof/l7nG H6CdzPGOR0tTYwyZRJl8Ovn38U/qYv9etyfzoeOxwhYJi0FPPon8++gn9ZY/4qdaPizgErPwT+IX x6GHDSyeyLQxn9QBju89zY6jKWQs+fccIPFfLCKjUUAggZD/4AGxBBwgebwLxGFQJByZ/IMLBEpF ImGBKR3rBwkUFAgP0eRxbpCEQWEA+h+SXgoe+H5g4TDjk17wEQPEAUsZ5wwpAC2Ii8n4cc6QggEi RCRQCJM6w0MG0Kj9y5QXjSKScIAG6BMFcIAwSrwYFgX6jyGNg4LolAxkGw+tr4LImbrmDqAkIg5H IApgUXj6s9CaKQZPAM+PDsJEz0zY3ISYJ6ISSdB1CPr6RAMiEODfTdAP6dvrm/1lXz5mdP6Ykl96 eMZOQytnNEXAUgi4yTzcv6dqUr8/jipYD3EU8qT5KBOomiwaGEcV3QoAg/ZXqZo0RhhHFWyCsEBl JpvyZgJVk4UQ46iiWUAShYgl/90RnDSwGEcVbIDBEGImc/FMoGqSuGO8sNOsP5pIwv/dAZw0Ghkv 7IjvwaIniweYQNUkMcp4VsF+D4RIf1eqJg1dxlNF87p4EhFN+kXoQq0kxP1BJeFv1+yNc+QTz1RM XJVHpQr/I1WT1DT+7+giTMitf1Xf+K9pIk4+ggh9/wuKGCqLdRyNbejVotSfHW2NdU0R4LgYmgSD /6i29Lf6aXlYR9fY1mlUp/6kzz/GVUiHx1NPplPPEK6OC1hpVcBieGS6Bq+viyUSiCQM5heB3wSk jAnyIHroSBnM0C+bg2wMCQsVsY81LYykQdOCEKMZcRv+giOUP+AInSE6aD30ISxZ/5eR8P+eIYyk jZ8amIwfULU6XegFRkv0hTSBqhgBanXszGxdMGhtF4Kbm9BoIf4veIZBo0AoQyYRgMSjKGgibX2S giKM7gr5CZSIRxEoONIoFCqMwJIxP4XiiSC2xI+CdwpggUcZxQZcI370AxaPAqkxjgqivQI9CAJl 4iguPBmFGX0QWEPs6CcYAh7DgzyI4RnQBPS/o7WpOwUIeBSZSjyI0EcbpkNAHIqjdYzxQQyG2h4J NYqbgKKSRsWEpXYDpHc0QgCR1NfoIIh0LMg8xgAxoDlqb6HsEg+jxWBh3qNRGCoU0E99AwXlOFS2 IzAqbdQXaTyjwERhiHBbZBTcPmA28PPQr0Sk20S4YQQEHsQRULRxhYGgt1DaTuUIDhkVPGAI9UkM AeSv1PFBYGN4SgfjMAzNAVSwLCBYcZQfyaPDqBwlMYKAYyTTHqLhgJhCH20yzE66dOOAPFF7AWfJ G41tgbLq65jv1bfWUdWxsBHbZWmuYyGGo8fPYzUFJOqjjYL4l9omlJuTYZWYGErEgewcQwMDaii0 8UDT2hoLpSD8284g7owqCLpG7caEQEYagEzTGpsYOmoqkT6hf4MvmIn5AuWOVPUnohDRhrSaKrUI FIuGBQlkEMjQArkljC6B0DQF+grGiiYio1+BGNNopjcBUiMG8aAjg5+kE8UgkkBc8ATcGChkdX9s EKg/BKMjpgHohNEAdMKRhhg7x4AQ5sIE3GJgIQmPQswIHo9CU40GAoXqUekGGJF8AhGWIMiQ0chA YHSi6TBgkKgiQW+RDNvbMajpNgyhcYytA2aeMN7Y4VDo8Q0SaY4BwQsD6MTBEHoX4IbG9BVBiDBl Aub9QpDRP3fxArbW4EEDS2tz4Gihj2Y6tvprgLpC5aZoaKoO4p+Ija6Omf4aYLVH598wWGTWixYb TNgKsIHQnovRrqBp/7BkkXFxwe+p30+RAINDxOJoo/cvsKF/CxsGB1lmMgH235TREUfYQ/ptdIRJ Qx/6B8bAHztx4I9B/3nkj4W2OdCDf+rX/zL+xzAEeP8i7hztCLMjcQz279H2r4Ji7K+CYuJvBsU4 HBxXgMAFjlyplooGABEJLbQCUQw9agWBCZEamAGrRPO6dNiY+IgOBqEU1aTRG4ViAiqMjpnu2xDq xjk34lggYB61jTGtQYE3mhbBUYEIZGz8RqJ7LFpPkAbH9BlBTGPNj8xTgnYNUm0ECcMYjMBQIi1i htCOLsxDNh8NB5fUR/Cw74IewlCfJxLg6ApHgptCQBDnkIyCDgZMJlKDBQKFIbKFQvTRNgFRpPEh NeTH0XQHRHsfsIPacRB/wD0eg51MlRhabgL4QrOTDOkLcG1U5wUDCchYQVkM3cWTYFqhVIbmKRHY 2GQGAUNpAjWNAVnHaOMoHAHJZyby8cjQjU1o0PB7Y7w8jQ1j/fz4AGOCMIQercAMBKJIDd9AtAyr G9IluqMnobBo3A9hEhpmOQIFXaNlESQcrFFU0aJ9IY3mExMJ5S8iB+KfRg5YNLT2Pho6EPD/OnQY JfIvBwx/huOfhAlkmuD9gzCB+A/CBNxPwgTcn4cJOJChEelhAvXrfxom4Jniikc7wvQwgfD3aPtX YQLuV2EC6TfDBDJijxiScQIBnuqYGAqtaiJTO1gkCKCm42SqXxv9AnUKQ/OFyLQagpIO/GXeTvpT owUt8eH/X77zN/Md0j8wZPifGDLinxuyP1v9+l8YMhJTjMVoR5huyMh/j7Z/ZcjwvzJk5N/Nd+Ap FBBc0ufUSMh3LJo2BY1Dw8EndXKOZslAnE1LZeggNOOkDQLGIPOhSJsgO0EepGL9xSwebfKXnudg YaKgpkhIYEiEUUFIqQkMkQE7nTwGMNwRqE0aDYxdxlGzExpbfmCb0uj6Bi1apZEJdZ+ARPnUjAgE 5lR2QJEqTC8ZRYBWWGhuAvoGnAY9QYEAcFaEgV8DvhFDn3NFUofJ5sZ2Qn2jhe70iJmWdTE2x+Cy aGjpkDGU0cF08gkYOLlk6CGeDDMAj6xvMLAJIoKW45DgxAVZIcHRU0QCkdYpMFq0gJ4OQo+dF6VC KTRHTEBTG8HDqyYQVhyKPG5Z56dTnaTxC0BAssY1Nx7lhIT92AFooYLadXo/oVGmdR7mxwTipYRE DfS5fer0Ao6WV9KoBu9ScYEkFdE3AoMSjVc6Oogq+TTRoIOhUaSKD71F8HEcXhgyhjwYSESjxjYF /DmdmXSkk82fM3aDvtoA93ZMgzBXYLQTsO4XwRT5T4MpAhqkrf8vA2RWBji55544cCL8JHD6k5IC MSxSU4DTQZMO6WAxh7D/aU0BZnR+CoeFqoh/KORipPGfxDxY9B/whs4aA11dfQKGRDCg/N9lDSON vxNyTSxTxIllCsuceXsMMLIUCoEIVYZjmT62zJm/n5RG5jCZ9BMm45jTASIIUqjFyD8U/f5rHjNn YmYyEpnDYvJPWMycyRsMCTpckUjCEYl45tso4t+nkTlMpvyEycxJekHcBGIiKF1BE36oM/7XTGZO 8jspjcxhMn3dd1wPKMzpAQWqLUMTyGQc4Yc0/t9yGYf++zQyics/KbfFMWnBGg0tE1FIFKCRzOcy kxauJ6ORSVz+SW0DjjmeDwvNiFAwWDIBj2a6WcYxx/VNSiOTuPyTpSEcc5wflkiA5uj/ToCOY47z m5RGJnH5J/PWOOZ4PywFA2L9vxQq45jj/SalkUlc/kmSi2OO98Nh0CjcX4qV8cxxfpORyCQe/yTp wzPH9+GweBT5bwXLeOb4vklpZBKXf5L14Znj+3A4Ikip/lK0jGfSevxkNDKJyz9J/PBMWrXHgx78 rWgZzxzfNymNTOLyTzI/PHN8H/DZKMzfipbxzPF9k9LIHC5jf5L54Znk+4jQKtRfipYJTHJ+k9HI JC7/JPMjMMf74THQGsxfipYJzPF+k9LIJC7/JPMjMMf74fHg49+KlgnM8X6T0sgkLv8k8yMwx/vh oUMi/lK0TGCO85uMRCbx+Cd5H4E5vg9PwqGIfytaJjDH901KI5O4/JO8j8Ac34cnE0BS9ZeiZSJz fN+kNDKJyz/J/IhM8n0UqDL/L0XLRCb5vsloZBKXf5L5EZnj+whoHIryt6JlInN836Q0MonLP8n8 iMzxfQQMBnjvvxQtE5nj/Cal8d9yebQ0k26VocpMM30LQ1sjeiXmmJIKhooKCrLlm4DsdhqtCqcd DjAhdLQIA3nzNzZyE3UZ+sNwIg59/zyyDYi6Y5zMsGMc2uE0wTeovAcp84OBII6jlbdB5ZTUjTk4 xn1jtB/pG6Ro9W4MO6SwRLhuDjkHglYhB+1Go9YsUQu7aCci4MhI2ScdhqZX4tOhNMbRKhbHfhvP atorPwHjiXR6oQvTRksSMdQ95AS40pGAQ4rkcMhxCAQitJmO1m3whco+2m5vIlSwSKvLIjCWttLH BOIosvP7h9H7hRyQ/58c/EoOCHgUvFuR/sKEwP+fyoD+xDJAhPeZYCn0zScMUAL8CeIB/VAVOni0 6hkubiUwlF3DMAyKoXoTOaaE9joOD9szIkOLOJgWBAi6TjtgAT5OBmIehSoYSAUqATliBmClyd12 BiiWVlJKfZe2mxGN1K/iqQMLXYCIFKZS4HfHbJ4kT3QaDHIEyZiyYXgDLzKcsHhDB1GMSgUMAJKP VFojOoAcRgOdIUM/Jwc5rQZgpQkAJF1Y5OQNIq3kmbafE3wHPUZ2oNJPwKAPNVSZC4vmj0KhBO2C ofUfy1hVTTswA34QoETDH+j7eKHzW2ik4xD7QT/kh14ujMXDpoTMeBYIIv/0qnUga7Qdu/BZMbS9 paBlWHl+6SAJEyoFXCxMQsO19NsZC4hhk4AjosabDhgEHU9EVxu4QnsiIPjLcLINDESO4sEiBwZR GEUNPlyJhMgOvC0agTBQMxFs1Pohb6FpO6NpkQUGKaXGoWgoKfBxNLAUwgCGDmxHgGO6ikXBB0H9 AGNgHfzqBCD6OPxqQBlujmAcUGBlacXiJMbN5TAUBx8mRZNbunaBX3BIKTN8DgBiz+kw6tFF5PGP YpCNDmNaHVPvTyIwfB9DHx2MQbZe01vEYMeem0QeN/50MkkMGxLoHUKgtH6PaQ9hDR3zRDxUYqin J9JtKx0oRoJ1EXbmYhhGuwAda0y3m8Da0OwOA5BqFGgb2BmeRcOEQUA6a4kommVGjliin6ElBm1W p2s0HU5BrDP9fUQFoQP0sTTasXTPgMUhe0dw1JMiSOMAELuJKCIDBLAa3nZPhvWIkdtieBRmLLMJ iC3bTgdS4L1b0AYf6Gl4Swl8PNSY/Ry0rfbo0UMSGHSdJkfo0ePGaNuEUAhNdDeF7AAiMBgb+hAy uioi/fwyZNTHnLyAnFkEE0P1UzCNkAuD+wCdGUA/k43aUQIG3sYEswJP3zDGwCAGG0KXRQT4S6/A cC4rY6X6T7f+Q3Wlo6ML5IgAET/Jzo/RFPa3dkCMyd5G35IWHJUxHFVJfnMjxRgfR2uGDJQDTaSe T/e7zej/2Axm9MYXAjUo/912SBP0CmgdhoilauNvtjPG0sPtQLvVSH/UDENq9EOej/yd+IxS5AJ4 6s9Ok51RSvyXh5T+6jjd/8HGXeLvn1SKh/7AB5Ua4HR0dfV0cIT/c+dyMpL2j+aofn9bkRgjSwgU Az2Sng5W579lyYTblBlp+yOejE6GMUzaQbNhRALjnuSfbZuDjuEBYTzwxpjJTecf2E7G80MQ88C4 /e3vHFfmNNlxZaR/cFwZZAOgM4mwZAIJw2AIGGD/jTUgMWc95HfUEukrHkv5E/UkMWc55LfU5I9p HFUX0lh1IaF/X13w0B8KGQshZJLKkJikMuh/oDI/WaUn/YOje4DKYCkgI4AGA0dXGUbYf6QyzFk4 +g2VQfoKieQfqQyzVoZ+rTJ/TuOoypDHqczvexgsBeRgRDJwNADh/zGV+Sde5idFF6R/cEgMpDJQ 9jZqwBhUhgH2H6kMcypIfkdlkL5iyZOfPTaexL94Zsx4lfljGkdVhjJWZci/72Ww0BwuhUghQgiZ pDLk/9DL/KSChkT5RyqDoUCHU0KsoasMI+w/uk+COaU2v6EySF8hifwTlSEzJ3b8HZX5cxqply6g x+nM77sZDGX0iCACDsL4f0xn/omb+Uk9FBn7z3QGj0FRRoeDQWcYYP+RzjCn7Oh3dAbpK4bhoqzf 0RkmVR39js78MY1UnRl3UwkF/Zu3ksAHyTIsUjFA0ShkLQQ9drEXAx2URUKWTOEqASLDGjV83cLY GzAYIcClwsuHOHiFmXpQGG0pnr6+iodXOHA4+oFEkIckwEulWORGC+oSC3RrCNIkQIwdPUGYhCyt 0sijw6iHT6GR+1Lgs9SQc7xwGOTQKCJ8lC2OhILXymnFFIxLhQiUiFxIApqjvkAad77/uBPEcGh4 Bn7MoWI4eOGFfqgYskIy/raC8Sf9E368DgABYZAzyfBk5AIO+olsP7mWBQ8vzYy9l4XGOYaVeGTR W4x2RjJ1DZlWGQIzfSJ5VGLgBH3ZmrqYNnYlGwNfHsFwCjdyO8roZTUMXxlHiQ4mkOAlVGpjRPh4 KwQf/YQshKoxR2TBZ+Ax3sdBe4yhLQwRLjyBESKQMZTRoRD5SFNj+oigpLNiQo794sQtys9nOSf1 uFANDXSHKmSvmORxKf9hlPqT2lgy4R95XAoWRZ2WojtcBtB/5G+ZU9z5G/4W7uqfx6h/8ZjScf72 z2mk+ttxlyBQfj9GpRBQZDKWSCIzMUZllsb8kxj1J3XOZPI/0pjfvJXxf6EnzNna8Rt68tvH0dIo ozAny/wd9fjD6/LGnfmNQf/OdMfo5ROjER6BiWtQPxzK+O+dCH3pHQsdNkn8k6XuP3RGVHbSZxlH uSlua2xubGEoYK0P+GZsry9gaylgruMosMbYQkBY5Nd171BQg1TRYpECH3r1IFIvhCMhlXQEpLAI RB20WkUyQxUm+MIx9h5BKAKEb+5AT1wyTCsTRUBY+JjVv1swjJzcC1UMU3tKr4qFiobpfUXT+goV xRDhO0uItDgQj3wHfSEgZ/XS+QnXIdNv78MgZ/vCge0vq+kYFY8+iPRDWMfcTYdD/XC7JHIhnRiF Xo6LZvj2KwqwBhNTwHANGsJvLGrMd6R0lYxUkm2HhmJ83SG92JWxjpNA/UitkkTuFvmNPRck4oQU k5CUBMTDaGSQiWR4JOlgIizk0MWAsOyO2o3RnJCWEdEAyOYQ+jPQmdNExnbIjOkgghAuGqNThqdX 8JGISDEj/BhSL83YHBlD5ROME/nOQBYMw9Ku5qS3BHWQlo7QEdIZMSHPxrASrhWDsKCR1AO5JBEP KxsOS7+qj0xBUctlqbwd/TqGXAhAYWiCWgZLv+2HTD3Zmp5akiZINyFW438sEyfCpeWMDUJ6i8HS kcLfGamCYUjFLpF2BxMWuUiHCNPKcHPkD4xSos+TjCs8phkrOhhD0wHQLpwzwlcfAuQkAv3r2POo cfQaYBr7oZZI8IU9DPWAtAtM8fAB8chGDzR9bwm0HWTsQ2T4jPcxe0sYb3CERx3DUPrHUBCJgIm0 mQCoSQJ82Qa9wBPZiELnyQTMU6In2vRpku30z4xA+i0gDJKyfcKdA8DQ0MeKcf4F8Qv0eRo8Mg9A ZvAA8P0hyF1eFAZDN+Y6MXgDAFJsCrVIm2OgMEw/0O92RaZ5YApxY65uxMPaRQdjYLKhFpFJHXrx KLIPBoaMIRKBEnEMB6nTXDvUa4aaacLYKasfefgLlzPxngDQE+y4o9w5GC+vYjjhnVZNjPACnubD IrxAYKPXno55CgOfj45BjkRnuGcUi1xgRUQCF4aLfhkK12l7WYgMIQ88m4gZM32JXMcKewEYRI9L GO+oYei+M/W+N3jWE8OwU4gOHnvDzdhvZIYQEI9sdMAhF6ARYDFivNYOh3xhmAfEj7+ImTq5h9Rt I7OAyMs4BtxEAUSdiQyvjf4CuIBBpk3hiI0y9iZAWkU9XdgZZr/wDNPaSMd/AiVMMDAgbIObos+P whPK43fKkFDwbjqGHTU4hu/QnDke3o1Bv80Ng2eMVZEbleGZSvqNudsZwPQxpgnwuB1YFIa4lB6E Y/H0DW90c0jbroSmX/MwWtlN3ZbFYILoOAFRcIg7kQj+osIbM17HJ7UI6AktAn0T3tjAkZ5QwDHL 6K1QYzdR0nUDi2xUoN/iDfGZMeiE9svQw1E8ihYdwvXxoMUfwlogxj/sp8HCO8BwjLv68PjxT/4y xp14PykOA22bpY8zHg4fiPCVFvTK/h8DD/plJQx5GgY15qILmLVo5NZmatzEsHuMpldiWIgcaN8F 4mRx9A0oDCaCZh/oKy20RQYKHPSQ4cUcNBw5w5Ax1MFA0A1kfw7sbnH0mz6Q+zShSIMAXxYKbwX/ Le5jf7KbF4tsYKTGi6N6hEZh6ZdgAELgvGP0+h2gZSQMilEDSRTY8YPvZEQw0AyhIhnZbku/WJIO G7OTmA4eFVwSZczGYvpXxr3EdCh0OBAtEUAu60FCURIeuX0EQ4sBaNrAsJWYiEERGZ4hkFCwPaPv I4ZybprRRqhlgDHsI6ZD0TS1YVRQ+tcxO6MRKFS7g2W8Dwf6ieHOFZin9K3RmB/6gyWixj6Fhe/9 RC5sHT/NMU6f/mfboql8xPwQSozZ1YPYI+rGaMZt0RiaiYAcAaIzwNIjPpuAHl12hK9ypcv+Lyy/ 3sSmC80gPoy+E8kq6C6UFt7hR68WHRO7Qbf30JwfPeojMQQaDGHemHCRGhUyrM5BiMdtlKYv9jFu lCbBmQPjNl56KMmwfEobHuT6WxgwhkAYCNqlr1pSkC39pAkQM2zpnYiJjLyljS3jJmXoIilktz/s 5AnwbUNoePIKAY2hFoFiqNtU6Y0RGdarEXQMO7jRE+Rho5oz/oYoetDH0OT/x951R0dVdXuKCoQi TUGKDF18OLm9AIYqNZEWihRhMpkUTPuS0KQjQWli44l0iTzERFpEmkElBikCYoHQPg0IWJCmKCri d8/ce8qdOcnMybDeWu+t5A+GOTNz2j1l79/+7b1tLtyq3TGO6B3hGGcNA9eGR4saBZvANlUBVjId GkOSLLxOIolLh7ieRZRwCV9EkOBAXFgiglXQxYaLbBcgLsY3pYCTZIm+7RKXLuofeV9rOEMxcWEb Fzy423nkS0xc/vBwg+IBfG/rJiol5A2ViNpAysSE8OI3rQHuaJ36cJBh3X6C+jktlhbypYzBY8jc oqiC4HOLKjphrQrCJ9Kbptu6cww1T/Bmz0xPzQSfPQao33fFRZI0sYRgYbGhzFY1ugqIg+Y6DsEl kQfQvSlSBuuRqFNqAZuU1WEz1r8eQbHQhRD6IgCAlON1lpmhOY+Kxm2uaZx5Q4XgPCrxhqIoq+aK DvaBc5R6gFDF+MAFSjXG9AimZh2Cg64sA4Q12AoojsKG5Gzc84yewtTdpHuB5xC2gGKI9JzAm+JO CAtP5RSnxrSvbbYYWIsCj8dQ/KcBDG9KyCGsOGPpG+KCpLOsXNoEa7rxrDnzigt2ULQTz+gOqzc3 bVi6bkhPKtsWoJxVPAd8TzVJZaqIsoR5HoRTYjo7bQAHsrhzupPlIKfNDS8AC7jIduoJ1N5oHOtx Rb1ZRA7ExFBVpiuKFgtAVHnmO4o6RRJnhRAKthLKBuUlY0/wvCn4B1sPKeKUHgrA5EZAQp6XGjHA kw5kIFeK2+NwpyanudITM1JTHK54V2JKRqaXJGF87kj2JGd4MhFRguRJ2AMQWYqkRobfQqVkeBRC WS+hmEmHt0vKiKsALbYy/J8sogTS0NBuavEyqepZ6WJBcDMeR59CAICMxGoA/3sFY2xqs+lS2CoJ YRMZp4zG9hjYIKHqwR7ZGcK6XykeGmltEAiDAYwHQ3k4UWBYMIIPoU5bhYC4i1AfBeGduNscVMpx lCFIMrcHGSJILrAYcV2ICgnIBzVN4Kc2TAIVG3oQRKKtKoExyqddbFCCHSTNTmggqBAPGFUGZwW3 R5m8AAg0PjjIbaNDlU6RiI2AiwFxBvFVEKcAl5pInGL7qiRgNILESSCuJ2E8BWJcPIRZiTIVmcBh fYYsbkuArCv2nhOMEDwaU/+D5n3dfzAqQXVA8QJRoYxRJBQIKszLwbdAV0ARN6EZZNxAo5FJrwkR QcPY0oVi68F2gU+E72Bwme3RlFBsKcAQmQykpsrUdYFxOZtujIsV4Epi2uexyR/iFdDG7DU4qIhb T4SitLk/QOMXxJJ10q8FFxMmI5g4nVZmjxmHfl5CMWdZ6EiYHb/1CcAGvUWopeT1wFHsXEShNVO4 xFhaignrWFCPyhPBvHBgLvwwsC2LeEABIQmF9qyxNUsk7G+oFGxXHAMShyuFBDvLLwWwDr3bEoJe xHFrBq6yH8sW4E1EflOdqGaSm+DdGxaQ7H3LYQqTtwBlgOfRbhNlhBVCipBx+CLMDpoqeGJpo/tN 5O00S+tu1b3Z7EVIVCC4GyjKo4AubFiCvGXIr8FwnJI1BSJhKgLGUJ/rWJCoyKsAI/wRyKsMUcTH OBRLlbcYOxxap6hir4kG/ZgnppVD3kSKVbF17qp2acd+m0G6mo1VweNwnti+b9aNqUgq4bwG2X24 jDT74FKLCiViKJm0uQGrmmVC1X18w1AYOvDUebi4BRsdB0VzxNc4OpWAGxpm2aDFZcWhtQp0MmAo 4uXie93acbZtrlgWRhjV1KKu8oTJR4FouCwTZARs95MRj4i2qwNICCL1dNBg8wKGQ1EhYT81/msd j9itjkf8C5UIEKsiQyQ0gxCSmy2wKRLcsCXJbFaw8ZewMckU24IwJaFAheYrD10kyXaxJQkLbjZD kiW3YTMSPL2dgn1KEG0HTRzaYuRsCsRpgdzbIP9RQn52j3HYdAm8ynx4cNh9zPfA8KFW8gLSB9Dg ZYJxBfWegLYaaBUg43lioiE6qcACFonYu+YkoreY6S7LRNRaySLtGEvbdxLxkgxw76GVTSLxJQHx PBi6KFlSPaca48TQuyR5sXdJQuB78Ng7KWpBpA+wDWQ2RFf2q4UHN4+qm9PDjsRizBwENBVkFpSO FClgNTrQV9lAqDi/WgQA9YU+JpEDrF+FDXuP9a8GZI/WmPBC3q8SkFeIUzSR6Wl7/KqRjVUpscKF on81KnBmZoSx/NeeAvQwmedZjCQCZSOoIKi4xoI+UcakCjKbtcZ/3amacaJyjNiw/4LRNJNuE+zK 9Z8RXboLS47nOPY1RzsaOIAIa2yYMGkBRfUYq05XmCwbqv9z5nnArFYYwVz/h82DaCeMTmGUHWn0 wRvCpOzLnxeMZSfxbAFdac9bBFKmzjM9JtW/GsmQiHhFZTl8ab0xTin2o4qyamQOhDJgsmTRHpOs QC5VCEtP4UHKCo3JIkbYoHA9xprReaYppi0cRQM8dDbTGuW84lXjwGI7xWkPXANEXdb9rVFECA6g DkqotwqvA3RCYTJqUCUa1dATWW9uikzDAaZjCMewwKmiU2MbD2VajGNGNnSckC85QeBMNbvs4oMg AASQTQCmdERUDD1fZ7R1+29uAWQxZZVdKYOSVGN+yxqdG5vSvPmxXOnxHkeMJ8WdkOxKf6a9I5Al rNyscnfNKlHl1r7QrX13L7dYQIybODUJOxfyERMw7gK0ex6yTCmlkpXBCbEqTXI8IOJbtRFFqAUp CH8EN62PZUywJiLYxETt/c0lskJ4dSLPFrzHdKIC2bREUPKYEbtWsWflKem5BnxUMSywjADcfgRB MH1z7w4iQ/DAQskX4S8IaTrLvUhTuETAwDFXXghyvG6cQqLCJNVRrjOAx7H1hSZ0AMWaVRegADoy YE0zIgX+YwIKDnNv/FUKcNGLApucSsNijKfNzFb1F5tl8LhZs4v4S1OG/sgsBPlvAVUWmJE3ykZQ jTFJOsdGCI7x35Ay8OFlk3gF/9NB00wLIPM2KIEWleSJ96TEohwoVqlxJ7gTiKhmRFAM3QlynBi3 jmmOB4GwQCIdSpGggDtctvzGBPz+WZ/YTC3jvH+lhGQal5qY0iE5MdOT3tFfSLVHOeIpnQb8Xs1h bFinICvW9cXpTuPgJsoo8aLIDqH++caICtQhIrWEjfJmmwFbC74N+kRg8o7GNwKToIu8x6XKMTFm 3Gk4Lh+eXZkbNeeLudUAoYoUW6gik2g3JiPDI4wZn+JKSoxP8cSO8aQnZwSOUiRj4xSvEF62RLmA Q/VEghs7UDlRT0AOC92xB/qdaQRPBnvT0UtNP0soytrfkc73MCIoNpMJZsItQSRDpyJPKhjrB3J+ UHwik2QgI0qAxYFAYjeQ2FFkTMvLCGTiND+0CmQyTScsQ063OjRmK4JlmEQ0AwWnH0WEEoV058ex MWUiZyzyx4WEARHRyJDLmxWNSsahMSNhmaKTTsoi9PVSocZitGBKvKJlj/XWh8JToHA6tiAfupMs wTwyRbP7rgqwn5CNA4uM/2AFCJVK2MeVh7qxROb9Q8E5QGBc84FJkJmAjZgSclLFxmoFZQfEo0DC PHYJ81/GAaKC0mNQWXQsvNc0e/Qn7F9JLQRECuz2h30xYf49AYQd5jmClSCISAXHmgZMUkt4waE4 RqgUBN5SoWEeGdxhDAAiNo5VAilnRKAAez47f4oWLvSPLwDfEMGEJAE6bqNFIkIlkLf4JshJDyrM VmwJX4dJmISRTHnrXT+I9qRZUwnJA7YHF4DEQY/FEiD7n021xGFkSijmbL+1v9MIhoQkwE7jACWa 0wdAgIkMbfPmP22qH80BczZIgIPkL8B8kIHoCz7VkQAMajdA/kUS78HDxrgQbf6j7FlMbUQVmMUU Kem85ZiOcDABBWAiXNUh+9WejxWGNUIoFmK4YSQMZS/FUBiRvZQAEokMsJj3AokZgj3yMucLJZaY B1b3RR2t8foQfXAOWAgl0mYwAOpA2GKC8cvkAfAFxFcvrUktlQvCAj1QHHh0ld0GSHPlkMH9WWY1 kND7ATGISQ9URf9qgDsrsxGQMizREBt0Q7VhgWZozl+SIUuz2d1kiu8XIHOw1UKbGxlQAVlZLrR6 FHCHsLEFKFOseJOJM+naIsWjU9GMO0uQmZRt2hyrIns9fjoXUNk4Q3jhJKZZpnlsaQo4CkJ3EdWt EH0heKvq4DqWZKbNQPNm0zXBkK7ZFg7FpZjnjItB4diOHJpPHG8cFiE7m/K8yjF6myo0T3QBiesh LGJjdhlroQ5JBIog05Bovta8qCnMz4nmampc006OV5m4gqTBtSRgAsI2Yok4ksgZKibEFywciSgr FUfSSo41HghHkoLDkYgWfBsMBkfS9DgP51ZdsR4zSyYcV+k4UvCN0nGkgK0GwJFUGo7kAxyVLl0B n1pNFMulq3LpqozSFTUmBPDuZRoQ5ciUgYMfV1Z+FZaJAJ+Z8aZlOTDlkg9MEOtT5OwHJi4r5cCM iyslOUOgA1MJ5sC0tRDA9MBwjMZqohbDxbli4swDDY62tGM09K7QD9eAfQlwuGq0w9U1YRIB0gd/ zAIbOrAOlR+z5cds2Y5Zijoje7FqRkYsJdCMDGJpGgIqizGdFncEuCRoPBtbk6bGqhxgLzNxqala rMxcDVWJ9QZ9Y9L3aCqsMce8zhRAh6rBAkdgVZOZ+Ck0NVYBeDgbfYKmxeog+yBbXCC6Ggucz1kj L1H1WABqsrqRUFVZQ9Fi5rtIwcsNNJaBJTeAMKKKapcbcFmpilZMXExZDfZacIoW0YJvg8FICGqc W9RUzSWJ5q0Mx1W6ohV8o3RZIGCrAWQBPbAswKh3AQM9p5YLBOUCQblAUC4QlAsE/+8FAgKXBnl/ GHtEB7h19oroGLeXLMQ2NCrKLXEc+1OjwtxgaCKb9ywDaKOXLHyBVNOcZBe+cFkpwldMHBBMyiZ8 8RwXjPRla6JEqCTGM8GTxCKTuWSPR4lTDKnKlI7gcEuTyULvCl1SC9iX0iU1gStBUpP5sstqXmda qVxWK5fVymU1u6xGeVZlkNVosdFVkBOSMdAATXTUBN0Z4vMGkhoLTYQyKTrI7sroZkITZjhOcTIG X6CFGeaMU1VlDb9AERqN84rVOE6N7MsLolPQ+bJ6XZEymuJUFTbrOHWiBRB2Q2Lzp6eLVsBTUWGU 86nR+VWZuUdUqVES2CuiDk0ClAbGoVGlRhn4/rE+NZrUqIChlZUbVlIkZfPF+hfyFjuBBO0DYDo2 Iju7KQ90Sve4Mx0JnsT4hEwTblJaOLzyD4jer3gzicNs57bE4Z3CYcXeNs3mOoVnTDBar/C/92fJ TZkJ6ePHeB3hxySlxjvTYuPuYhtAYFRVFbzyqsyRr8afIXRJQgVDM1HAocfJYgWOVziRq+Dg7mIf Svwbn5HpSnc4KjyT/uwzqW6OL+l7gT7/P/rXekCPnoDxHdY694wjZ1cY7+AcqTHjwjp1coQPcMV7 MhyCUTLIER49Oc3jCO/uynQZC8QRERHmSYkFX9TIH6Snugd7Mh0jjf/26Gn8xhDUHeF9ko16ulmv 3a3XPo7RjvCeqSmZDhHUHxb+xKTMXoNBKhaHZDY4OMEVC9K6K+ZbY6dketJTHLL5dnj/mHFg56ne t7g7PGcbQLrHaMEaQdeUlNTMDKNzRsuDPBmp49PdxvA0cnhgxGHhUZ7YRFe31EnGV0Ftsqo4JFEA P+tudNioMcOhm53ulZ46Ps0BmhpsVAHUiTTQpHsyrND8Qnh34+MengmJbs+gXt2M3hId1on+9kxM MsZovAKlpIfHnRprVBHpSYk3Th+ehyM1j7ewSSvyR0RlnNlRJ//opm+P6VW7qXsWd9w27533H63S 8Z2Dxy7cPNJ3Qqvkoa9M/OWXX7rUOlazr9hEH1Rra5XFZxd/H76m6ytzNzVutPG+jlMLv1lduWaD W7tPDV+YojZ/4vYM8c7VpudfP/vPjPyTt3fp/1Rce/9LO4pa7bu3YMjzW69/+W1c5zR9+cI6cy6u zr5ztSD34rTc9Iil2pmrc2fUmljwx/2jDky+Va3en/M/7Px8h3aNIkbVuNT5yp1bNyb/XhzTcer0 oqR0PqLK6i+6REdWfTm7IHL/5IJ2bTvXHlmgzxl0qceGhsuLRnROq9rmpe11uDxRv+/FxLTjyxOq /xV9fWlUDX3HrHw1q6W+5sUV1ytGO9rFzj7aesn855OKqjT+aO/H9fePrHTlXfG451OJu9Js9JNK 9Jm2rzbNqrGqx769VTfeuZ4VFbuaz+pQsf+q0Re+uV25+a3Eq/OmfHJ4zsWlf+Ucvlr1opQQseXF tTcWVL507Y8J2j+7m06//e68gveiR+XXGvzRsobZ3TZ+/g63c+zSvMUH/mwyrPDxD8a81KBdlRGv R1RPe7BJjwN1V3d5uFj+bF3RuROHe0yfdLXF4Jtf/Rnd5crsQ617HPSM7rR8ZuJb3zX9ImVIo+KN Ww5kDe9/4e+Lf19r6pmdu/nT6vc2UQambQiv/5b7u3PJT9fv2/Xkrtrar0tm1+ULd9fvN6zdEJH/ V98Fg/ocmNn46R/6ZS2Qt4yNmz7w0dcW/sK/VvR62KLt25rf2hNdVcyucWfjoJ7x3484Wfn5HM+E Wgt7bFt8bE3BFvdrD37Q67Xzu7h7hSR3VEKzxCG32w9/bkXv5o6bx9fVqRg3t9ekI2tbfnHvliN8 y4+qvTlqpVZ38/DYsUcico+20utXf2D1hjn1PmlZaWz2zfobcvuJc2dN+3Xe0iW3fo8+lLnAva3u q312bA8fveG7sZvnxH+YW/9y00eqNJrYZ3S7pXn3f+Ya2C6iYOu3nz4xZtj87uta3a61IKqwecFD Tz+yoO+s3mGrbqwdILiV6bnq6LbHXM8dimyVJfxRPP2bsMv9Lqz9uMoCz2+1FOnf8Y80O9Cifkp6 dN+Dzo393Ke3HuNzixseL1yfXyknclbnE28drVu3ZfS9l89OH9JkUb/I2pG9E59e4vz2t5OtG4gr hQdSR7WvPbfliQM/fdbPGXm89ZjjhcUNwvisFSN3Xvtn605Hu09nRIxKenFCTOGpD95utDaBu7q0 YG1Si0EbtaTTC4bWaP3ylv+6uCepYc73RWsKPeEX007MvBgzUBny8KGB5/YkrVi0tOvs0w3yh3fN udQmenwMt7i93vfvO8Jf2afd93Q6tWRRxN6piav/faV3k4HvFa6dULlvzJBlXOYb+YVNz+2a9Pah KV0y3D/V3dZhyQvj133SpVbhG8bCWr6wyebPDqy7uaFV94f/3t79n++Orx+0+8ac+x4avbfahFV1 ZjWtzi8rrnuisHtUtSOj5n/9xeAfMm/y774+ret79Y7+fO6ROZcHVlkXv/HgrL4rl3X4oGNC8cFx j3UcfWjr3s5vXM/7fcjFESsaTAlz5Ld4NHHF10OnjL39Q9u9P8f1v+/Dn386n/vsh87Kb4uD82Lz 8nMvDXivn2vHbU/GHbXbc+qoO7sm95rxkPPDlM/3aLkVtONfTa9V9+rlF7J/rL6247m0LsuW5Ox+ Z0LDdXeenXzwz4mvHG346aFOIzvXfPrczvivCmcse3L/sA/2v99we2bLJ0d/3XLTDwdunVr1SZuE c5fnJ16r2z8i27nqq8xue84d2PX85yPbxj6brD48ZsTQs7cW7tox8Mtqf8xvXPm3kzdm9N7fftWK x3L/O3ncaf7dH/OealQtLzlsRc3La7SRfYqOhf3P1az+zfe2HXv+y5euPSG8+X6nDdfb9bh1T9LU RnX3zNmzb9+u00emhtWJqNh49dw54dmHejWOGzk+0fpCxIrH63XIO3P88UVVV89c1L/7ovvbjjs/ aNo9anh2JUn5+FT6O7WLu3V8Kuy325/vr98iqZLSoWa1MTW2bRuyc32d4nqbryf2vhX2dcvsg+j3 R19+IvvtjP4tF/WflVzz65euFb+1fPeZL1+4Vq3oltRqqrNFwfgrqO32OW8egj/c22B285VTwmq/ P1cWsqqeKBr2k/GrzdUe+euN2Y2anYo5v+vMl73PD/72sxNd9176iY+6tKrnnP4f7VvfvLi6NnA8 7sygaZvfNFq3ZuPCzBoniI5+7vxdajG1khJRU94zMzvp2M71M/e1GX562wMtRmkPZYEPkyr1rbdm zb71HWb9fMExstOJpm3aJNWoWPXFb9zVr12Jmzjx5qTRv19988o3m6YunXxlc+aP/2qj5P+8Vb4x /9fNhRHnl44Z+eCwyCNTprj+yGm8POdK0mVNO1mU/+jClTffXxavDHVubLR85ZaYpEnj3fOeqdJ5 ZMdFTyoTh87Nj8o4PfDwgzmHctrU61WQd/hKzUqR84acfnzRk9snbxqVvEre3nRI3lPOTadHNTu7 4PCmZvFt5qX/PW1r/qstcs8+k/zAgaTE3e+Na+t+d37eyjs1Yw4VHYvdsKznf9q78nCqun9P5oPM JKqNkCFnPscxlDFkHkIvylwyz8oQZUhRMkYyz5XMU0qZZxFJSpmTuRQqufscel/T/f08v3uf+8d9 Ws+zzt7nu9de33Gv72evs/bZmf0Vermv2uP6b+acFo7ptT1xK7xurPfWw8IHug+sXAraChE2duDB CyWnjc6UljOfLq3mqL2oZY25lfrSdkBI7+65NluFHpvolskfjHvThTFV0vF0kqSSTWPLy8mX9i0s 4Px7azNfh5A/fGigOfRWqfcc27mvAoGZ330KRNyDVRL2idg3dJinXWRvD2qAlp6dyY029LkkIf11 1MiB1Mhe2bsKK/h+xu6Q262atswf99/NfZmZ+fJ1OvPHZdpbvYtV3o8rfi2WKiz9GOxvG64h/kuk GCdbuLdf6L0w5nKvdtV4Xwh0f/mAF6WbMC3dXdOcWWf+kRM8/roBk9Z703vzrEc/sP4c7LN3PgJw u2mNk/ayUdyfNCOv5RKZZ/N6z10rjQxR//jEJ6HjlcbKdaXcxsJk+PDh3uhBwTPv9oibctpzcf1Y mri1Sjp06/3MsXde5RX9K58d3S/3p6RxuszdoJk+yKEaVzE0IHklcUGTRPSqg1gdu9Icd/w9Lxww 281ZUqbgTcKeWK7A9/yrZBFIe/9+WNzUvOmwwrJHSAJVh586kY5Dnq7ceGJa7jP+qhO9aadvn6RH UGdf9wt8lBnkjqBrO5w7c6f2pfodVuq5kZnU3PavsFm2nrm5PPGZ8V/v5k3sFd7m1/JHAXM3Bp5e eO/WOmTQ9mBc+uRfz5XaUqGBN89KDMwLXf14UdzzVwzbHjGJQ0Mpexe6Fny+nL1vm5SHB1/rMOo3 bvwNfBFIDOo3EQHfJTjDiG4CZkhEqQZMIw9FzBjIygcZsySHCAQaSj3NDi6XEWFTpKltJi6k8S3i jb9yzUAGJR15RZ8+3ZLPkl5JlIQ7hpyoqYhldLuACMQuZRHFbpIFrVrO8AxGORl7haE19fVUhPLo 1HvyqTJpMW8gksN6hPjK4D17rqUMKLu/K6W64GNeMZvkwEJIePCgHsbjVO71b8XhwVM2GfDXSRbf O9tLlToo0gc47uwgHnK3OBa9WT75sHIGWTilnPMpaSrGPMpP+Q2d7qvZbMsni+yJjgY94tXOOcTP nfG29/wC7OLeRFVeXeHXfCUR+504WKVPwu94qMHvp5YmxwZ1T5Zl5ZS5Wka9tGpprrv85bweMkKy Gv2Jf07141KiRFH2R4OkR9SR3lLFoveUNODej0z9UuPdLnPH7/twjF0hVoDH0dQOMrXITmT5VK+s fpjsHTH24g5aonapJRKH2KSlpJayHRmcsr9DoEwqfU7VKSF7YObdZYO7rTo5EChJCTwyhiab9/in 8GtIFZ+vTkZDmp+f2Fw4N8Y1I4LJWNJ3OlsR+NqpM840X52zCdpYpKOfrPsuVXY+4AgTHdHRD35k g085V+fZsp735gU41Xia7zE+2W0nVS/bya54WprB5Mdtlo9pGo9sBmePAHrdDwKSXUyv0UYTCTy9 Txt8J6svKcg/KjznQNd8SNqcwXOjYBMNA4N+Ug/LF/R9A7dDGZDTneyOpxmsj0tOpGoiijXZ6VTP ec2/Q2h96QS77Wp81yx7rkOG3/jwmNKdcQeewYR+aWr4guOjaHWbxTsCurfnyMSbiUmerAyEh3Z4 fhAOMeyfUuGf67TK5GR6+PSg6crV4zbKdw0bhILkmbMqj1D69EozOXrp1y2ap8q5FxG/4mHqOc9L T8NY3T4N++xRf7FvgKVobEHufKrcwe6bDJJHCupG41nyMn8+aMvnTKDj87QvuhXZ2prlz9Ltdimr pMPsQLd7wo/vP4lFiJLZd3AoepcOxW72JzokH39VkXhmvKDE6BvPRijLf7OX9VIjgR6gi0l5/hdt xRUeB9fsn508RuUC8jFm7VcGHXPOKsJPSGbxDA80qJefdWBl9N5BHswu5UEgtlzm6uIFJFw0k7gA kTD2EFvjjsJYHeiifaJ5AS3jL8XPC3IKfGfGGikf9M2XsLJfY19i1Z5/JDld4/9JsiyIcnRI5o7J 4Xj0ZNndzOG6KqNR5Kvnj2mfmkazkZbAIr5G1cW2uD3X38/vqFbAYdYrZ2NmNDnB/IpB5QgJ171p GG8jJ4uAd0FqCE5MbSR43DSnTqRq1sT7eQY8pZpTj0z9hblGtOQsX9IBtoX3PaHvlVA3zuxB3DY2 uXd4rP202lKPtUKD5g1uOH8a+wiCoSs+1xSSTFUnJg4RZCGL+eTc/O7Y6nkjA9UdbIXdpa1QuM2j M6YIHJ1hKBhF+IlAqejbwTLXudgUiWpbR69QjfmeJpfanyJKkcsXJERLVP+Rlm8HxqK7HYphm4e6 kMe0YNDIeWYYk/rwWSYeiSq8zAGcfOugXuFZJsaI0B4wCQwiTaARDtSeJ49NNUaXndAKvTeVmmd3 1tVv7JL2/a+LFILqbm6Okm0t7As7yLXbuQQU+t+nq2h6XRE2FWGK1j2d0Q4Q7gRyokRvmuLtTJGw 3Q6J8C0Rq6XsBA78/VXaDn7td6q8E1wKLsxUPfTnF8o7KiUjAj3dpezTzdufXjOid2iRN1/m2K3p uFatukXWQuaOo48UOhhKj0JINZkklxD8LNzdHd0fxTxMYo6RPKJXE2D1oIggIn80eNYjUu3qM3EO xABDxO399IefxynfUFWMlFT6KTT6NS0K5eLDJ+S87OmUzXwhtYmSBdAvf02RJiRw8DCTZLBigdMT rO61gTC98IZzvHzs9O/48lWLng2/jSryj70jQzam79vjUljxnVNFfzjPf17QhLXnqmoCOtvfsuim mXmNx2K1SnBAYA2jxl3vKKqcmFsv31LxZCiouk1XFxhgZrnkUpeRwpHPG44cJg5SMzsM6crzZfDD Pcm7/mSMGsf67JrFvThhGtvzvI8v3Qx49iK+MN2kvjeh98svCnkDz9QdvLBbpCIK35yXWh+z+MIo yV4c065kkPHynRrO71oxeC7HUebVQ3KAi72b1u5AUNEDZfcI70+XioPTGn27tC8Y7lcLybLyzva+ 8OExx5hyT/Dxto5xkqAGdusdBNstbIFj4FtwgTJjDUAjuxgvozCnQO6V4FJxcrbqIZdqoW9mvhS5 Oz9pdjEZUycZ1Fa5gvqYAVV7vcdHjB2acYTU1Vc3bfh8pJZ3eZ1VlMv8eYyzEPVDpgOWey9FprIn 0YuxDEynjDhlzLQvKzh8PftVIX8mvq32mfnoXn/LrwIzXncPaBq9M7/cZWb3yvoyy7ecvKIH6aP+ /e1GyCTSmWzO6RWybGcx/x003S0CQmy5/OQ1HofKwmkmJcnYKI1XhD0T3BWj+qskT55wCOD663j4 X4x3rj1TpsmPtB9SOCEtSV3FFjCErO1gC5Bu90+Tiv/KTh/rEfjmhN1HN4f2yhpkCG4PW91fDhkv Y78Zvh6Jp+Cnb7eNnA+RqVDSYXHUSXRUmc8p6Ajt9Usvtil8eXuKK9RfWYmXL8ZHW3C1SMBA8OMb eaY8xRG/CFXUoPBx2XDT1qRIzUVY8c0Fx4LbCq4vmvricUdj+2Yyp1W86PT5YjVHBe6NI47xZ38x VPOeKTzQOZKSfupH/MrA7ejP3MX9yT0TeryasaE9mWFlEqshifO/SG4mnT62g/V2jaxgqM0RHC4e XgOjkfW8d4WtMWQpYuSLOX/U4q/pY4gmXV+lYKIjUNfYggwJwIqParVzcNBUfNT9dUJb67NiOShT i0BHslDtW/nlgtjQigKxupwa2D2Dhaz4G4GqEXHjgsrspdQJNcXB49HetXRYVBaFa6hyNe27nvOn IW0OrqviTxT63NESbHd1PnWz3WLTZBlb5lJPCZo4OeQlcYTL0BN2gpVxRLtT6mah4cPPZ2S+7S3d X1AtfUFpvJBf4rXrJXURO7Y2ejrzcp0lNc2p6RfIp1MnqSQZSwb1Z7zF4/In9t8VnfKZPfGqOST3 PJdPox7/JK/xW20+eUZztRJ9uxs9CTPJRzKcA53ZgU991wO1xkz17l+mEbcXhvYJN0a2UiNOZKom iHo0+oTGLVyMGvdYIbb54iy+g+F3i4DAG6NNhlfVULaT46Lpd75u+EHpMBdxu2zPqfFf/fk1OtOC gfsuK9JNFJw6OKlt6ho89TldNaYZcZEla1S9f1WTZo/d6otG6aLSkHumY4yv6qoPS4yieDj4e4UP 3RJX57AMqK8NHb4nwm6cyEqMNohq88PZimGlKsL2l+YUDphr0HB/kmmjiBCJz+yMuYZLyDI+6c5X HMZheKwnmcTxryeQcrMbEfa1nKeTn5m8UHF8dZb4VVZTwelGQCmQq9071TMSEprVfFGIpZouIpnh a2BPEnlUeUBK9mj4zwNv9sDISkJcJ2hO+uUQPX8vmOldRXw41Eh7B6PtFqZtvTFEYrTBTAvbw5iR EQgZOxFNuDE8di2qhYyphbiwVbjVT5iHOiyaU0SW2gxma2qTZmxpSm5+GoADFV1ETkuMt3eQZbcw CAHfDEfQGi20YAJ+fA7CmsW8x888QfeJ66q17QtxE4ZVGf3GSMqL2U3tAhPKx8RU6EpEqvK5qR+6 8k41xwEJQrPJsQX5na+HjB32853xZcUaf7QK3Y92GbySIRIl41fHOxfr5er58ak6u8cFdic3UgbZ JmOqCxWsqvpFEolhasRDqz41M0dHksO/NCdwLHPET8+JF9oN8l9w4+50YkF0F6Ia9lEyyR+UuCif 4TBU+Mq9B8XYbUmtFk2cq3Y8ZC+RMfeZ075TuXI45a6b6Yn2lQ2LdFJE2kU7mGa3QA2JFN2CTXC5 76RoJr0hRoCvW1v8OFm2z8z7wMizENki3etxN1mjrJYtuE4djRCpmlayDeb4vNgECWYK1+N9k05z W2NZIkCn6lxL5dNX8QyAchQkIiK8gZf6F03MgAjnuJn18Vs87pKXjE+F+DMStzAzpVqfFntcExf6 UyKD+PgQg1OufimnGYsibYXjG5ZZ2S8XG/cDlneir0OMdINZfaTnkxQeei/q6+gDndOcSg4hoRq3 fd383ijS4ApZH2dBv5+OvEPlMn2DeyblGaNSa7ypkdh3umMuwllVmOGWRzdPflcUslZ5456qZNXK HZEbI2+PtfeWLJP6ItJ8+UwbIK396oiV14uce2ZH4tgtAtw542hQDZxBrUwSQUjGyAXvIz5nlfkq jtw+vpc2+fLZg6kh8eT2xM6diSXXSdjm+0wecRoHdNXFjXhLCTJdMv6+2rt08ddPEs4SX50dXLNb rIrefOOFRIPQXeNFsc4LNAJzCoYmLaBtU2HRoin/MGVIyXQ4sYZMm8rEL82ZXtC5rItIJ4buwHbe qN1CVjhyCya51UJLykUjO6szyPiZ/Vh2UE/C61+PJmFx0jJL0tzi8zDKB18+Y17UzXWm1GB/YXru m0UJH6q4pKVLNxEWVPmZRcMKplkbcFrlgKxJ+53mxmhEKcdgierVBzZROg+vukmQ05VkWtyn9Mm2 NfkkPE9TfepMWQPt8TDlh+5PTj29LKMNi9lBl90Cv60hLg/C7zoYZf84syGAHDs3/KVSTW9ipTTK QeydxAINJRVC0kIx4y0m2tx/hPNzup75tZ6wxBM35Wrp3wskP8v9XF4ZXWvYaBd8cj75wPGYdCyi LfdFTqlCJubGCbQQzzgg639J92PrjGa/ec2kG9eEmDZrkIPwqixZQaRrs0Akqa30+9c8H+1ZJRje kheOORWWq9h9rZoxoE7oFTPIt6WQoop2HjAmJ6qtoXpDVPv2zQCrwJFDpyquK1U//GzIL65R8iLH pRLry06xD2dcE/5wb+95e6KaY3QLKSfqvrEkZQkDv9r7LJ8PwJsU8/jHyNUkHcXqbjsoidbvkbr+ cIi5Yv7A6yEoW+61uDkqVzEL1crqhDdDDTIRlLNajnvmuDnsjA7IF9uoj1MVHRcMR5qmHaztpLrd Hd7OwBxD/vXF/h9lweyPQmvHEp6+O16NS5z8wcZadvXDDq7ZLfRFILdMiWkqOYFh9nhRaMEvu1po LkGtLfvLqrUwUkmN1dgabuXnd9QjmOvVs1Y/aLmX6keUFxbRPyfWd9BBvUzkbUzLlXPV0c/0dGLc n0CN+hS93YNyfCzNPQsV28KiosS+yqD4XnMxSPKA8EjY+WqawEOt0adHDHxFPkWVqImHhifxMA/a R/IMTrCcdFO12X+/WywpmbKlROSaWOzhFDcTxwvz0Vzcia5m6IalG2rcbg3Dvx7AJjUPh3edo3jn yJeqGm1Egiu/mJOnK4i7duxMZ73/J5ccP7PK3pIFJqsP5d/ODlIc8169te97+cDx+hlD7h2stuuJ ROz2u3rfGmZZEaL9kXumduh4twgTgdp8pRzVxIWTSFO2jLNcknF+OZvfcntxdQLSTHw1UBYQO+qo Ua9OHy008LnxVNHgbOy+5+7Pk983u3Kw4uhZFLv26ahmGVUefELhxmm550saWvgq+yTJcTMI9pKj h0p937QrO5rUs9da3VIDIcTm2FRLpu36ujG2Rj0jhHrasIO2sZzhlcW+tLtR9SH+PKpcWorJn/iy kdJhpKn3NVNDOet8Jlp47pmc4rlA88NQub/Xmal9P0qc9b4ELl1BL76lqY5aiGKlsu2ZvM7++xL0 jA5V/bIr8VMj2IGu8sK6haUzzgWVMBb9+bFijjDV4iUsdGhJcnhy+SdJVroB6w4G3C1SRCI3j9lH tXA3D8NpWlYgPsZEk5/nEw6qdP9YdVE6RUaWY9MiMeJUI8frIxzWr2k91HvCMql67tH91oBZxf5G sWvWjfKGTdHV5+SER+C1ErVXZvuX2A8uP2htKqSoh/YtsutOZVO1yNTfQBbVCN6sEWzMN57kzvH0 0E6ryT78evjG6rE6Z7YrrE95zj+DLo/f5/F4mib/RtKyv8iALtpKIYo5+uq0VXvLiPKksF7D8DLQ N8AiLnNBzzcF5l5/UeQmwtZCztrk3NW0+rpvY69vpZMafay3SBPdsxwrWE1yMq7VJgX41TjBlYmg z8idOMlfqsni/qnJsLC88p4SwmBR/nobc/tkdexX9zuI+23iF6OZ0tXkl9g9S0hp7w1/6rOODThR insuxOuFcbvk9PlJ3Gm6pmxFRZaXFRC11EZm5dfRS3HX47q6W+bexyyyX14lRg55Ee/glN0iUTgG uXXe3ZUUTiPrfMqP0cNX7BP7cYXClUxqq8oBqe8e/h7XJKlqnIzqAjppjw+UtKIqbyLehn61qF/K ypdSe0Gxj5tJL1Xp6/R1pM7EYI9pbmqKIVSMm7E1fPi+FI+XWEGDrEF/rI/Yo8tTXLNMq4KC43Ym xCI5M1LLWofmu2/1aX6KS74lKGR98MKbKsrH3JEl3oZqFvEVnhRF1eeE9H54k2SNi/nuoOtukS5u M9BVDZVmfAZQksxWcqtryL1YdbnUtXr2fvfeJ8/U9gSzyl9ZQF9Qhs2UIVisNQTuRMY8OwUzpH4z k9L8C6Gkci/wpWcpydWCecerXUo/vjleIrq/con8HV0XJ7f+DhLuFnBu9YZqmPhe/F2se+IVNkrg 03DHRS2XC7NVuk6MSVefUzSHHXF1prT8kMRVOfDsxtEDFg2lSQ/Uh5f4RyuCvX2Xb1QkhQsGFmaT 1/ueSBJ3+RpeGOvpp1qj78CYljZbIsUvIXy3T7dYMyrPcypihlvp4ZvUl9QhlH7naKbzaPIe31Xn JB4uzsg4Gycwcfc18tCd0jnFuzLm1/5qXnT8xHzOc5Xo+KQocgddd4vgEOgt8x23lcNJAEq5xYQr PL4/RyRi4045rU6j7qhg3GKyVvxP8mQwCo8zX4StNH5uMy+ZKOa8fy90z3Vu5tYRwQV9v557AkOt xXLFX/MRTm8nDlwdoh3PjdcpKNOsF8sRYxHNGG/+njPzs0y4+SlPEILM5hVuL8ZhtMQkhCm1Tdc9 6IdcWGZEduqQW5jN0tWI+qfNPSxlapgfn3j3UVzxSaZS+aya5BooNTwmcMmJ6tu84+MvUnmllVRp NpQjjfQhe6Ufq+Vedpz8ObAqVnNv/A2N3k33eXEV68fDUHjT9XJf+Rnm7i+SbA8naQ7MNsWaOb30 lh03zGt5J53R8fPQ5CKdxnXLa9vtiN4tGkXAt8x8aDzG/3I2KUlGPdLuNY3taElv+WV7OD5NBiPD GBmn0hQZJNYc/kBA/cAxZdOgyqBRO3MMr6A8NCKPd/EFZN47eIx58V1PdKEsKuY8zocaKZjDceCl MibOQZCpIultDfI7ra0LiW7QwXwD4EWacW8J4NRAt4/meSzTDW6ak6rkqw+dFrXezkpy2qdci3SZ y10eXWjpOFqpJnlTruLJ8nVrxwwxiJzDiQufr7uY1BU0yqb1kKIlSayLiXIHLi1jzyu4sPtOMQUP o9I5ZVdflTVMkgRd19phUhu9W4CLQG0GBKqaj23l4DST75kNPxBNWl9MoNYy+mYv20QZVg0kQwUy eVm/1SvTDFIY0D0duX1K9vLB4/AppLBk00j38bHyJh3mpyw5d+9osJkOrpwnrWR1gXILNVO8v2VB 49y++CGVPsaYD2X8wF6Jj62nEmleHZx8s0b6rs4+d1Vm4VyWNmTjtC62QKwQsPHgZRqqJ5Ij7WML azNODcmPCqtzOpgFCSf7y7h3gkPzxhWhyFdULimvaitaP9wf/+aGlYV+/pBV4eFNM6mcV/0x3VPY K1fmUOuCiri7Es+TuQwmBks6Mq3Ye7ejxCRNvUulVhMthJZ+NHV8WaFmOWIouIP9dotCt95oYTB6 MCIZI2UeMjOg/22jFlddWEtjN2kr4WcSh9P7rp4adWCXsrqTwpmLInqfQ/twB967nhJFbpma0FSy A4fDykmWL35EQyJVDdLq06uPDnRRGRufV45vY+DgYPAIft4hPVJv8Cokbuluk9H8YwmWg1SlV/g1 Sc8EevZRidjvi1kRbfWaO/MXLmK/OgJg61uYk2s0jpH6+Gxqf7fJXSv+74H+HTcV0Ryn1c4qv1C+ T39Evc8nk/pk0cNPHdOFIkXT1uqifdPZ/FHqQIJBwZ6YUD0VVjP2BblRkboF6ZzCgAT/zyleewuW s7gYjVLi/fjJKVKlxPPGSxKD9QKSXF0TS0KT9wscUF/FoNBK3CNMvPF9XWUGS78SPFd+kmToaCfu sAZh44iqh19D7oxHuYT1qfilsjJra1KPwkVR+D/1xwBwhKgogEPgACMIVMbE2YKwnhb636yAx3vA ydlF9ryJEwCDQOXtQA/g19dKSECgclaWlhb4hasW+PWxIHyDOjuYmFkAILqAOlg4WdmbgxQbE+fz APSShZM9ALW3A53n4g7uuZx3sgD3Le1dQd9aWrmB+85WHhCos4WbBciTsDAewKEBqKuduYWTs5m9 kwWAwwJQEwBqCkDNACjYtQUAhyEB6DkACjKwAr+Ax60BqA0AtQWgdhAoyMYBgIPDHxTk4QzyBHsD oG6g/jAA6oHXfm217d86gbEEVTFZVxaff6DarqYuhDb4lsjfy3PxBoMQPlVNXJysCCt+RWAwOGHd 7z97RgBUzcTW4r817VoXchbOZk5WDi72TgB8fVUxnj9+UbQzgIBtXai8ESpou1jY6oLfobImDopr JsOClwT+WjnnTPAHvnP8WmaC3zdI/w9TCFTVxIMQNQAcCd57QqXXzsDHx78PH3yDf6kjANVflwwN DrRQJRcTGyszabtzNhYAbKNavzGaAYCBwf43KuQ/PRcJmhgFehCFgQGiSFEAg8RAcGC2xYrCAATh rQ0wQkXD1o7j2yMx8LUteEsOtv9XFfJ7H98WX/F9/K5oJBwMY7wgoLExomBDnCiAxYLfQWei8a9R wFdwyEXg0BCwAhj8C+rQYCcgMMSCMBIrCgoAXhSELf44EqxwOBgWCEKfOFEcuF2j4bcEZZBYCH5L EAC2phgGjiSci0bD1vvAvzYBsbaPRIGGECVUNBZH2OKwKAIdA0dA1trg/34cDmYHOGFRC/4YGtyK gkbCbwkV/9fn64bAbwnGxvPGG2jNEQRjocFzCEZBb6iEWCVwwX+BYdf9h1dtgx/xFb1WIeh1n/3d 1doOKOBaFwgk4TSCVHjrgJzxYbDVhXhroTf2gMLC8WqvxQIGvllUPJEQTGBF/9YN3wucYGsI4dh6 BzgM7u+KD4S1GNheCbbGiRJiYkMlxMPGSoiV9ZjYWvFyEfbBczdWguYwNGj39RjYoeJEEWtxAUdv qr9j4nfF6wT6HULYbqkEX68d31TRuDWv4rdGfy9Q2Ah1rQDE2iMN4AiOWH9EAxyskWt76/ln/Zsb gFh/7sMcICyR0YL8zkuI9QSJz0iI9WHXBiAshdAipCIAuTb0grkFtf4siTVA+L0c7MQOQK6ztgCQ 68xMAOT6IyhrKQ+93oKQ+ZDr7NbSHuEHBrAbFwC1zoSQAdHrip0DUOt7pgBqvRcHALmuCj59on5z AgizK2BXG9Ikcl0JQm5FrTN2BVDrWtoCqPUG9gB6nf1a1kWum2htvEas8zAD0MgtSWgTPgMjHrfl +MYpM2kE4UEXMxMADuYpafznetb9+8kdfNqVRv5uhn9dCb4hYbtjU/jmHmE7NdsgzYb5p3+ImJ2I GycKVBEAfN0CqqCK605WRYH34Ou7SAC+7hJVcChAbE3UG43wN4w4Ye9k++9mwUBQtp5ykfj3V6x9 /vNh9Fvd388ybYLfGo1DCI25PaZmAYYiRmZkQPPgFS12Q0M1QyLrUnLIDuAR/R+Kif0fialDEHOo C60L02gc3XMbJ0UMYNkU2UlweFF9Csh3mMeBI/4zUeEbTUp4r8ba5z8f/1JW2zDcXhIuGnnPxCvU XuY3iGTFLXKlmeTjfpQyyRIxZOZXrozLv737WnLCDDhWceN1UDjdTUnLRGeq01fnwhjrgsdrBawy xKMsaVON0u+kkV/whsQ3PTpvJWbvqGdRYidXHPUNB+PWh7U62Dw2sQlZoX+tPD9+KO9sDZTDe5mt Uwmb2qL4fQdbIP9Dt2H+l9xGlGIoYkZmFsBJT1fdSTZfFl9GFIojH9tBUswfr/2dyDaYQtnKHH/T BF8bgQkPCbqCsBu+8ZlC542j2MbxBLw5MHc1A013xNbExcHG3sXGyhRwMLcETE3MrMETBCBQWZCx i5W9nRx+PDwiJ4aAwXFwECjBEQgYGicEg/PDYPy/29lv7gkughaBCwPnXVwcxKDQfw6I2DudE9gg k4eThSUEBDpoCOzvAkJSNJiqLIG/afgIIByxW6fhHy7fRkMi8abYSsOnvy00FAiBttLQMPR2GmIr D7BgtraDwZCi22kImOhWGkIUsZ0vDrVNZtT2c+FIDGy7HlgQ5m09F4nddi5cFL3NVnAMHiBsocFR 285F4GBbeYB6oLbpi8BttwES/x82W2lI7HaaKHIbDyROFLmVhkLsQEPBtvWHQm/TF4bCYLedi4Zh ttMQ22INhkaht/oIhsZitvkXA99uFwwKvU0+DBq3nSaKxW6lYfF3yVtpKPjWOIBhMdtlFoUhtvWH /xP+bTTU9hgXxaK2tcPB0dv44pDb5cOht9sKhxXdFn8w/KTKVhr+VmYrDYvYTtsef3AUFraBh4uT iZWNhRNhoNOyt8ePiWtPdltdAjEyCAqV7CxB6Ir658FmEycXwlAEXgJoFISXV179xP/lnyH8KX/K n/Kn/Cl/yp/yp/wpf8qf8qf8KX/Kn/Kn/Cl/yv+z8l/+bQC9AFgCAA== --_002_VE1PR08MB4783E72815C87C787CDA359984760VE1PR08MB4783eurp_--