From 79c22d6dbf7c577bf01e3091aaae7a9c44b84b6d573a38b1cc1c4ec6b44f5d62 Mon Sep 17 00:00:00 2001 From: Dirk Mueller Date: Wed, 23 Oct 2024 08:38:16 +0000 Subject: [PATCH] - Update to 1.7.1: * dtc * Fix check for 10-bit I2C addresses * Improve documentation of -@ option * Update to libyaml >= 0.2.3 * Improvements & fixes for device graph checks * Add -L / --local-fixups option * Add check for length of interrupt-map properties * libfdt * Add fdt_path_getprop_namelen() * Add fdt_get_symbol() and fdt_get_symbol_namelen() * Correct documentation of fdt_path_offset() * Correct documentation of fdt_appendprop_addrrange() * Validate aliases is fdt_get_alias_namelen() * Don't overwrite phandles when applying overlays * Require Python 3 * pylibfdt * Support boolean properties * Fixes for current Python versions * General * Assorted bugfixes * Assorted build improvements * Assorted typo fixes in docs * Some additional testcases * Move to GitHub Actions based CI OBS-URL: https://build.opensuse.org/package/show/Base:System/dtc?expand=0&rev=63 --- .gitattributes | 23 ++ .gitignore | 1 + baselibs.conf | 2 + dtc-1.7.0.tar.gz | 3 + dtc-1.7.0.tar.sign | 16 + dtc-1.7.1.tar.gz | 3 + dtc-1.7.1.tar.sign | 16 + dtc.changes | 331 ++++++++++++++++++++ dtc.keyring | 739 +++++++++++++++++++++++++++++++++++++++++++++ dtc.spec | 98 ++++++ 10 files changed, 1232 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 baselibs.conf create mode 100644 dtc-1.7.0.tar.gz create mode 100644 dtc-1.7.0.tar.sign create mode 100644 dtc-1.7.1.tar.gz create mode 100644 dtc-1.7.1.tar.sign create mode 100644 dtc.changes create mode 100644 dtc.keyring create mode 100644 dtc.spec diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/baselibs.conf b/baselibs.conf new file mode 100644 index 0000000..d938e88 --- /dev/null +++ b/baselibs.conf @@ -0,0 +1,2 @@ +libfdt1 +libfdt-devel diff --git a/dtc-1.7.0.tar.gz b/dtc-1.7.0.tar.gz new file mode 100644 index 0000000..5fa47c4 --- /dev/null +++ b/dtc-1.7.0.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:44844eb5373f8780ca1b7b4f64c073b349da1746aaad76c531f65a9dd2483232 +size 209788 diff --git a/dtc-1.7.0.tar.sign b/dtc-1.7.0.tar.sign new file mode 100644 index 0000000..92a0127 --- /dev/null +++ b/dtc-1.7.0.tar.sign @@ -0,0 +1,16 @@ +-----BEGIN PGP SIGNATURE----- + +iQIzBAABCAAdFiEEO+dNsU4E3yXUXRK2zQJF27ox2GcFAmP7EOQACgkQzQJF27ox +2GcU3RAAixXFsHnx8a2CENeoa/prw3qI7pUpw3YVqEHRAZHsHy3GCQr3cxL8hZOq +W21ZfqI6vueVloRI/+qP4yv7aozzv/40jLGAvHY+Mh83BOjjBkxyHeQxRPo/LfV8 +CMfh157Cvt/2lWF39csqVoid5P+qF8RahaZiRObiMpuillrFCxS20N2WZW4PmbO+ +fSwW1FWnlWGgPK17K15m2YKJaxIy0UijlW/gAVVHWU4tEQjGvvkOlEyB2brJbUO8 +ObjfoczMCNdDbsb0aFw019J878BfgKLBqEe2q96k+E77O3PDDJ8zag15JWFC7rYK +tKhy0KFHoV3DNBupViGuTzn5hAs4OUZmTfmiaW7+dum+EUY5KGJDdDP4gjbOTl8N +a27I2Q9ycP9+YXlcFzEHnrSR2k04Wcmx3LSlSo2/qZZo8Z2wy/sCLwodFg6EWRNw +nBEW5SfBQZGVjdO9EX3/YmEhIJqR74+QeHSj4JnlesIIpdcoXK0305S0VgolDLTV +63TDrXTlBAkW0nS4JGv+hKJYMdL9TcxL61CchAYXxxO2xRPw9iiXawa4AdIESllq +fzs0ytyF3nbyNBrrlt9H2YveDvGaJBoAIp8phZqYkdeZJKLS+JtgWz3SA9rLGTQO +M7ZPCJe1s4lDIXq9MqOdBFUx1t9WN6Xld39bjNKCZNVv2pruBy8= +=Kv5g +-----END PGP SIGNATURE----- diff --git a/dtc-1.7.1.tar.gz b/dtc-1.7.1.tar.gz new file mode 100644 index 0000000..7d1c871 --- /dev/null +++ b/dtc-1.7.1.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9532f10098455711a4da37816fd567dfc8523bb01f59ad6c44887a112e553d9e +size 215129 diff --git a/dtc-1.7.1.tar.sign b/dtc-1.7.1.tar.sign new file mode 100644 index 0000000..83ee410 --- /dev/null +++ b/dtc-1.7.1.tar.sign @@ -0,0 +1,16 @@ +-----BEGIN PGP SIGNATURE----- + +iQIzBAABCAAdFiEEO+dNsU4E3yXUXRK2zQJF27ox2GcFAmbAYRgACgkQzQJF27ox +2Gd9wRAApNwkb6UW+sVhFxzKdERalPkYeY3+8mh5M6iUUwTyU0MTxWbaQ3YCSOtE +4rjHzqHjdwU02DQT5KsWFJQRuP8kbaMdtM1IK2pq+bSUM6YdnQ6gPjrvuZqWVrvB +TRrGpd95T3jml5xRoim1w89wyYHqmdCsnutQ+iu0hea+Y4tfGZZaO0qqhMMGvROf +WWTv833EjsFm9xmER1DoqqYM5tHHgVoecmojQnytqS9jPaKOZm5sVoSUTYZa0sT7 +UgF96DayPyO8ZYAAKfmtQKJxnK+CsKfYaCMb+C+qDLDQk08pEZeYcs+EXN6Z/+pY ++rbSXyavZhnsHckuj4E5s0Rubn4SEpnFWU5mpeE5NSZZUyuQQjgdLjikCBh+gsDy +8abZZqCCQlxpX8wEnkqOGmTAsDNBhl8YHDw583Op6ioxhFKeLs6WJO5dRAoLV0cA +UljRXgzcFIwTnxKNu9IyoM3yuC9dR61WnSVGrujzd5t76y4b94/F6RI5de8TuUTZ +p4obIc5LYU0LWI3b6IuVT6TrqhljumELjBDS9UijTr61bzEr12om3Wb3OVZraX53 +A51QGdQiG+OVJW67LWPSuCAZ9p32DtqMdUdtouzyryrPOR/y4VKpuigUkYl+g/7p +TpRE1bvUb9uBxjfWy+jE3vZQCBgeaNOGwNlzJe1QbNyY9QowJKg= +=zsJV +-----END PGP SIGNATURE----- diff --git a/dtc.changes b/dtc.changes new file mode 100644 index 0000000..4a544a6 --- /dev/null +++ b/dtc.changes @@ -0,0 +1,331 @@ +------------------------------------------------------------------- +Tue Oct 22 07:24:23 UTC 2024 - Guillaume GARDET + +- Update to 1.7.1: + * dtc + * Fix check for 10-bit I2C addresses + * Improve documentation of -@ option + * Update to libyaml >= 0.2.3 + * Improvements & fixes for device graph checks + * Add -L / --local-fixups option + * Add check for length of interrupt-map properties + * libfdt + * Add fdt_path_getprop_namelen() + * Add fdt_get_symbol() and fdt_get_symbol_namelen() + * Correct documentation of fdt_path_offset() + * Correct documentation of fdt_appendprop_addrrange() + * Validate aliases is fdt_get_alias_namelen() + * Don't overwrite phandles when applying overlays + * Require Python 3 + * pylibfdt + * Support boolean properties + * Fixes for current Python versions + * General + * Assorted bugfixes + * Assorted build improvements + * Assorted typo fixes in docs + * Some additional testcases + * Move to GitHub Actions based CI + +------------------------------------------------------------------- +Tue Apr 25 08:42:48 UTC 2023 - Guillaume GARDET + +- update to 1.7.0: + * dtc + * Fix -Oasm output on PA-RISC by avoiding ';' separators + * Put symbolic label references in -Odts output when possible + * Add label relative path references + * Don't incorrectly attempt to create fixups for reference to path + in overlays + * Warning rather than hard error if integer expression results are + truncated due to cell size + * libfdt + * Add fdt_get_property_by_offset_w() function + * pylibfdt + * Fixed to work with Python 3.10 + * A number of extra methods + * Fix out of tree build + * fdtget + * Add raw bytes output mode + * General + * Fixes for mixed-signedness comparison warnings + * Assorted other warning fixes + * Assorted updates to checks + * Assorted bugfixes + * Fix scripts to work with dash as well as bash + * Allow static builds + * Formalize Signed-off-by usage +- Update dtc.keyring +- Drop upstream patch: + * makefile-bison-rule.patch + +------------------------------------------------------------------- +Mon Sep 26 07:37:52 UTC 2022 - Andreas Schwab + +- makefile-bison-rule.patch: Makefile: fix infinite recursion by dropping + non-existent `%.output` + +------------------------------------------------------------------- +Sat Oct 16 13:06:58 UTC 2021 - Dirk Müller + +- update to 1.6.1: + * A number of bugfixes + * Fix many warnings with -Wsign-compare + * Add compilation with meson (not used by default so far) + * Yet another revamp of how we handle unaligned accesses + * Added a number of extra checks for common tree errors + * Checks for interrupt providers + * i2c reg properties + * Tighten checking of gpio properties + * Reduce dependencies when building libfdt only + * Allow libfdt.h header to be used from C++ more easily + * Accept .dtbo extension for overlays + * Update valid node and property characters to match current devicetree spec + * Add several checks for root node sanity in fdt_check_full() + * Somewhat more robust type labelling for the benefit of yaml output + +------------------------------------------------------------------- +Wed Apr 21 10:28:05 UTC 2021 - Matthias Gerstner + +- explicitly pass -pie in CFLAGS, since the build system explicitly passes + -fPIC, which breaks our gcc-PIE profile. This makes all packaged binaries + PIE-executables (bsc#1184122). + +------------------------------------------------------------------- +Tue Mar 10 10:03:02 UTC 2020 - Paolo Stivanin + +- Update to 1.6.0 (no changelog) +- Removed dtc-no-common-conflict.patch + +------------------------------------------------------------------- +Tue Jan 14 12:54:51 UTC 2020 - Dirk Mueller + +- add dtc-no-common-conflict.patch (bsc#1160388) + +------------------------------------------------------------------- +Sun Dec 8 09:18:44 UTC 2019 - Martin Liška + +- Use %make_build and recpect %optflags. + +------------------------------------------------------------------- +Wed Oct 30 15:38:12 UTC 2019 - Dirk Mueller + +- switch to building python3 bindings using setuptools to avoid + patching + +------------------------------------------------------------------- +Wed Oct 30 13:24:05 UTC 2019 - Guillaume GARDET + +- Enable python3 binding in python3-libfdt + +------------------------------------------------------------------- +Wed Oct 30 13:23:32 UTC 2019 - Dirk Mueller + +- update to 1.5.1: + * Numerous assorted bugfixes + * Add a new fdt_create_with_flags() function, and a + FDT_CREATE_FLAG_NO_NAME_DEDUP flag which improves speed at the + cost of tree size by not deduplicating property names in the + strings section + * Run tests against shared library, so it will catch the common + mistake of not adding new symbols to the versioning script + * Add a number of missing symbols to versioning script + * Use Python3 by default for pylibfdt + * New fdt_append_addrrange() function in libfdt +- remove dtc-license.patch (upstream) + +------------------------------------------------------------------- +Sat Oct 26 17:20:31 UTC 2019 - Andreas Färber + +- Enable YAML output format + +------------------------------------------------------------------- +Fri Mar 15 07:51:26 UTC 2019 - josef.moellers@suse.com + +- Upgrade to version 1.5.0 (bsc#1153301): + * Added i2c-bus and spi-bus support + * New "-T" option: "Annotate output .dts with input source file + and line" + * Added YAML output format + * Record source positions + * Use inttypes.h macros for printing. + * Fix some minor bugs which may lead to SIGSEGV. + * Adjusted source URL to working path + [bug#1128943, use-tx-as-the-type-specifier-instead-of-zx.patch] + +------------------------------------------------------------------- +Thu Dec 13 10:55:22 UTC 2018 - josef.moellers@suse.com + +- Upgrade to version 1.4.7: + * checks.c: Overlay fragments are a special case + * checks.c: added handling of various busses (eg PCI, simple, + i2c, SPI) + * checks.c: added some plausibility and syntax checks mainly + for device proerties. + * dtc.c: annotate .dts with input source location + * some code restructuring, cosmetic changes. + * decumentation cleanup and update + * some more tests added. + +------------------------------------------------------------------- +Sun Mar 12 09:39:47 UTC 2017 - mpluskal@suse.com + +- Update to version 1.4.4: + * fdtput: Remove star from value_len documentation + * fdtget: Use @return to document the return value + * tests: Make realloc_fdt() really allocate *fdt + * libfdt: overlay: Check the value of the right variable + * dtc: Simplify asm_emit_string() implementation + * libfdt: Change names of sparse helper macros + * Fix assorted sparse warnings + * Clean up gcc attributes + * dtc: Don't abuse struct fdt_reserve_entry +- Refresh patches +- Make building more verbose +- Run tests + +------------------------------------------------------------------- +Fri Mar 3 12:01:08 UTC 2017 - jloeser@suse.com + +- version update to 1.4.3 + * Add printf format attributes + * Correct some broken printf() like format mismatches + * libfdt: Add fdt_setprop_empty() + * libfdt: Remove undefined behaviour setting empty properties + * Print output filename as part of warning messages + * dtc: Use streq() in preference to strcmp() + * checks: Add Warning for stricter node name character checking + * checks: Add Warning for stricter property name character checking + * dtc: pos parameter to srcpos_string() can't be NULL + * livetree.c: Fix memory leak + +------------------------------------------------------------------- +Mon Feb 6 14:00:11 UTC 2017 - jloeser@suse.com + +- version update to 1.4.2 + * including patches up to git commit 3b9c9709 + * Fix NULL pointer use in dtlabel + dtref case + * fdtdump: check fdt if not in scanning mode + * Fix memory leak in character literal parsing + * Don't always generate __symbols__ for plugins + * Plugin and fixup support + * fix fdt_stringlist_search() + * fix fdt_stringlist_count() + * improve tests + * minor bugfixes/typos + * including symbols in version.lds + * no changelog available + +- modified patches: + * use-tx-as-the-type-specifier-instead-of-zx.patch + +------------------------------------------------------------------- +Sat Dec 12 16:30:13 UTC 2015 - mpluskal@suse.com + +- Obsolete old devel package as well + +------------------------------------------------------------------- +Sat Dec 5 10:22:44 UTC 2015 - mpluskal@suse.com + +- Cleanup spec file with spec-cleaner +- Dont include soname version in devel package name + +------------------------------------------------------------------- +Mon Nov 9 17:28:39 UTC 2015 - p.drouand@gmail.com + +- Update to version 1.4.1 + * No changelog available +- Use download Url as source +- Use original project page as home page + +------------------------------------------------------------------- +Fri Mar 7 01:29:13 CET 2014 - ro@suse.de + +- add use-tx-as-the-type-specifier-instead-of-zx.patch + taken from fedora to fix build on s390 + +------------------------------------------------------------------- +Tue Jul 9 09:26:13 UTC 2013 - dmueller@suse.com + +- update to 1.4.0 (bnc#826457): +- dtc-check.patch, dtc-flattree.patch: Remove + +------------------------------------------------------------------- +Wed Jun 19 06:58:23 UTC 2013 - dmueller@suse.com + +- rename ftdump to dtc-ftdump to avoid conflict with ft2demos + +------------------------------------------------------------------- +Tue Jun 18 00:58:27 UTC 2013 - afaerber@suse.de + +- Recent Git versions of dtc install libfdt_env.h, so that + QEMU 1.6.0 will require this file. Install it for compatibility. + +------------------------------------------------------------------- +Thu May 24 12:00:09 UTC 2013 - afaerber@suse.de + +- Use %makeinstall in place of %make_install, for SLE_11_SP2 + +------------------------------------------------------------------- +Sun Sep 18 17:17:12 UTC 2011 - jengelh@medozas.de + +- Remove redundant tags/sections from specfile + (cf. packaging guidelines) +- Use %_smp_mflags for parallel build +- Implement baselibs config + +------------------------------------------------------------------- +Fri Jul 1 17:02:06 UTC 2011 - k0da@opensuse.org + +- libfdt1 subpackage + libfdt1-devel + +- dtc 1.3.0 update + dtc: Add code to make diffing trees easier + dtc: Extend and better test dtbs_equal utility programs + dtc: Audit and fix valgrind errors + Assorted cleanups and extensions for ftdump + Fix dtc bugs for 64-bit compile + +- fix URL as mntioned site is no longer available + +------------------------------------------------------------------- +Sat Feb 6 18:28:44 UTC 2010 - jengelh@medozas.de + +- disable failing `make check` on SPARC + +------------------------------------------------------------------- +Thu Jan 24 19:01:10 CET 2008 - olh@suse.de + +- update to 1.1.0 final + clearify license issues, run testsuite + +------------------------------------------------------------------- +Fri Aug 10 23:09:22 CEST 2007 - olh@suse.de + +- update to 1.0.0 final + - first official release + +------------------------------------------------------------------- +Mon Jun 18 18:14:47 CEST 2007 - olh@suse.de + +- update to current state + dtc: Fix recognition of whitespace characters + Implement the -R option and add a -S option. + Add -o to the usage message. + Fix reserve map output for asm format. + Assemble the blob in memory before writing it out. + Fix the -S to modify the totalsize properly. + dtc: parse NOP in dtb input + +------------------------------------------------------------------- +Thu Mar 29 07:31:31 CEST 2007 - olh@suse.de + +- add flex and bison to buildrequires + fix endian bug in ftdump, add C style includes + +------------------------------------------------------------------- +Fri Mar 23 23:33:01 CET 2007 - olh@suse.de + +- initial package to build PS3 kernel + diff --git a/dtc.keyring b/dtc.keyring new file mode 100644 index 0000000..015d548 --- /dev/null +++ b/dtc.keyring @@ -0,0 +1,739 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBGPd6ZYBEAC8g/lUNNv6t19CEKcPLeZKf6/99lbNH+DuGssQGEcWVtMjWuvQ +4oXVkHq6ZnsCMMeHvp4qM+F15gyaoES/wts+YvqUcYIyM7u0enpQL9XWRNxSJelS ++9TSewhHc5zg1Fz3REOjteJpV9bi658fy/ntH9ISWoSyx7XNZyjzTWsnj6g/slXy +g7gtB0LlNSGPq7XFGLg4LAfgt7vjaHaHEt1ju9R3khZlErxZ1M/BLrfXQFxDTIXl +tRCdht32JVchKRh/OvAic2gWQAdrY37AjAl1wg5s7R5bv0ygPEOZjtmhVn9nog0W +ysPeqAI3wnSoQ8s/flZxi9CtsVKykfy5j5wVgD0xpTEtMo1/ZyxNvGYldA61o4lQ +Ce7mw7M+ch+qfCMT7Jvy5huiWTdgzympQ1A54asYs5HDtnjssP2aOngZJchbJAp0 +IQf5N30a4scLlgp4vQlVDCbEdNtUfKyYbjMgayftzu/Ud1QKVJekbs4asVyz/nYD +DZ+2HymnWQgIu9o8bqzTjMFzKsX3R3f7CivWHeHAkOjnImbsa9FvYccrOUrPXasS +RK68brJkL7QxZnpD7o1ytahxMoeyyMHMK+3QW4Tj6IUnc7msuQVbqZJHN4D9j0gl +TIBwbRAVw8IIreCKB6tI7lLhq6UOVivbd/hldb2s3uGLEdAn8p0dd2YsHQARAQAB +tCpEYXZpZCBHaWJzb24gPGRhdmlkQGdpYnNvbi5kcm9wYmVhci5pZC5hdT6JAlcE +EwEKAEECGwEFCQHhM4AFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQS7OLEVSVW6 +FH0jn7b8Kn3BbE4hVwUCY93sSgIZAQAKCRD8Kn3BbE4hV4loEACGvko2uzr07JW5 +ZPMV0m3GrF42Wnzm8vk6pK3y6Ycolv796BytRywI0mrL20gFyum3NcCg577Zhgo4 +qUfx2/UMTJGIlb4hiB0HvqK37oWvpRWNokiJlKOwC11fSIdIO/jcRJ43Dljnw+ks +VgS1kY5HO6AsD4Z2HyeMW3n4J9O6gcUzSzQPx55XcAZHDN3fN/Yhw99xqacA/XoL +ftDO0eZJmBstfY/Wq4us0N1hRfUegXg2RIsB5Hb9wK3bJZzD8rpYiJ/NEwpFrFNN +1wdp6jh3HWawEYyBU7+NkQA5yHGR9PoapOP4tn7l5kyg4F7LZsEIJE9UBoaeYBt9 +ylYh89VhzJr1laZ8sqiptNMeoOs1UDFil0wUYt9mAS84sDUTXvSapY13BpEiSlP6 +081sw74rh2cueUXXxv11523DP4B6IQV44/yM8hYCKJ6JuPJ6W2Pltsa3l53u9XRk +CeDRjMVBNLkQyGop+mRvj9L/SUZtKxXHMHudWYGGDYZ98o9ejsf5R2f5Y1DIwvK6 +AbyYaLsrKnJu6ZX2DA3L95rKURepfIQDqGhfxLsCq6TGQHxIwZoxzn6hmDPFAdZe +NzyjTVrovestahG0DttAdyZzgAyvpP40QJx1oUqb2D+J2GAoF+DmCZr7Mc6+US1b +iRQd38I5SdNPBkzRQgvVfMlnNDYGXYkCMwQQAQoAHRYhBIZwbiKH+c/MtgAnyX/e +vFKULLNTBQJj3fjvAAoJEH/evFKULLNTJosQAKrz5DqGp3KByGC6U5hQJ75j8Pyb +jdemou2J7sPg0a6BMcAHOnsF8KbZedxco7wAtyzRGdivlwKCCTxG+saVULeSwEXa +IZ+8X19UklFkwitpNKMCXjpQnSdNmeHA+j5Qx1SG3iwqPMLoQSv2WaY0Mg3EKdC9 +HE17RMQO7SKkvfFk1T3awE4VvK1UilYaR5BIxVLvye7F4dTCMeUJWV/rC7DB1Dvz +qE9L+vUenhx5siuFMJj1TqGLnIH+GBKlZPCTYJQyqrr/En5TUeJC21qrfKwhtUrZ +qpXBZK+emxqP+sZZm6hDvvsI7PmNB54bf/tqszmcmLDXXpPNHXZqt7gDI1G+ToFZ +Cb1IBm3RStzPxVMJx0piw9fb488RW2XrFDOFOD9ZFAPsUqt2n80ve4lMbr+nJV6D +HNVU5Li9/0nM547R8imvGHVTBoVx77a1uOE+5m+AVqmVzVuWt2LL3xqtB87QEomI +tYLjk9J7To/WRLaDO0NnFnkS76oJ5W8+fRP5F++0eUJEqCXFWnTFGjc9xkB3CoBP +UsAf2R9WleaWvWyGKGKGuTcRatzrlNYcixNSZs4Lr9juQMRJ/ycREvIbxuMT58QF +/SsNZ4XDe13P2LeZV3RNVHv/DX4Y9pyraZT4vMxYrGVI+glmyoKHqb9+MdQitZBP +kAPFfeqQMC7qiO0YiQI3BBMBCAAhFiEE1Byj7VswJ1z1oBsFWtJCEcBg0cgFAmPo +yXcDBQF4AAoJEFrSQhHAYNHIJ5AQAJsoCiunZxR61guN1F+DkYPqUBMAoUlxAOY6 +e3njlY8Up3ERwQD9TxlQMtwaR9HW3SfVHoMH8QruSCt/xGWXsIiyNDrpciDqKL19 +SwrZn9f8iIBt+OscOfcLFC6eU89ZURP6f6gqAfoOTCcyQF9ozmGdRX5AbAVF8xB/ +rvl6MMDh0pJiiXIBylzyepBBq2sPYjdvshXKC8km9sA+Jvry9OxIN0MHYW8rVsmH ++afA33ypvSinv3O2MNOP7k2w2KJ1KMmjh+zdXWzDoiflqVh5shihmjZYvnV24s7W +YkZcsMkMWgSwG+JoRbIWMup6H3kd7L6ZYPJtpe7NE3qeb4XzLhjmhECQToffLEYw +Oa2z0s9D9h8mtWyOaRIknRbMf+6T5UZ+j4TbvZQZcMBrgmj0jPtFFqaiuNCTS0Sr +sLoZEBZKWB2HduNRg3i8UK/dXe1rUtb0JHjGv+NqrK7caadXAgB+f1ilKPDW3qG2 +gK1A1yivdMWQdUd7X/vwXRMohbCpP5eGvKxxRbZo1biAJcfnyf6e94NftgMH9i1p +xQusli2byljXvPe7ygkfbw9eU1oVLamYlfJM4uUzUBgLOwXODExXQ5jqMQ9dFjGN +W2CblRf7MxJahEo6/VG9uhPdWvrfUUUYsLLYe2JyPNKx4pNQwzeF2l7knZpk5IrO +94Jb3XjsiQJXBBMBCgBBAhsBBQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAhkBFiEE +uzixFUlVuhR9I5+2/Cp9wWxOIVcFAmQneygFCQIqxRIACgkQ/Cp9wWxOIVe0zQ// +eCh1yqfDAY1L6NI7Vrq8UYutAC4dKp2B63xjw7EhEeZnJFeEwydZHcddEbMkx0a1 +6GAm5HOQmnmaarjgupkkvBJpk4nTD5EIc+BM4UoKXF97mb4Orn8HinGBWMUi8bfF +7EP3lWb8QeM4LKCdzgtJE06waSWzTwJ0YgH+YS5h32GyAicIqlFTC+8hW5YAqHnV +V+rq8ZBvmnEY2Z3Cq6pYzntp4PWiVb0ZNlKmTCz9ZlbBknlu3cXu0XjKZnmn9B7Y +i2bub9lto04Mgm28poatu2McjEHQdI8xo2dfiCmYSFVr2Sdij1CSWiySHMuk/2I8 +/5G9qWxZK07q3UMpNZg7ZRrxRyfYRkxn3WSPhnog7870rCyBSlLoq5nXOelg+pMi +g02bueGKqEhfYbDPYSkU+hycdX8qx2ZleasVt2ASDRHwFungl2kp9fqddjgk1lRk +qOKlvtX3Jo3xn8S52p1igCEgivAxYYEEaCym3bM7V61UA3D76l+NpI2i9VJREeG+ +GpiM97PuoalD7M4VUygdZYQ3jKvnKiHhSlDPNY9BcP++mAoTCtmNZT4SGFbsDntD +cfSjsm482FQ++AqUA9F9FYP3GHWkst6ohSRzjLMzlm1hv8KWI7jEKeOid6PwrFCK +10HYDJ2+YQzsyftb6aAp9LHd/mBn7okp6Tde65g3b1G0IURhdmlkIEdpYnNvbiA8 +ZGdpYnNvbkByZWRoYXQuY29tPokCVAQTAQoAPhYhBLs4sRVJVboUfSOftvwqfcFs +TiFXBQJj3ewBAhsBBQkB4TOABQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEPwq +fcFsTiFXuAoP/0rYmiEANTQ6QxAhHRcvXxurB48RaJtXOLbQpqg7sE5JKCtsP9jb +aBIR2CqUCbBHdg7R0DMWX8UCpOU9vszMdQLObxuAXeA6DZONFPzNAQZFLfwkIpqe +yJLekdlqnqZmQcRI838QLlw23Z3NIC0xBRAATtTafeR340aKDWO9QlAf/+S1jN44 +680tWIUCFhyW/dY4esP7yZlnTQg9MKzfMXd0hAUqxtqGbGQaPBq+mhBnsNkWpMQR +maTASQWgQ3JOp3Gzn7+i6G5O+LVySsn9h3kyZfm4NJ2TXxghUuyy8oBHfpRgK7NW +l6/sPrvubv5YyfDLkPofsV9JO99dkcpCgLe/myooHIFfrhSb7F07GmtJuG3ssJCJ +Eteru3/oSDfSo4TY5Vaoo6+PFwMooU40AjgG22GQreBspIIwc/CwcIi1KANd8t3U +5ZbziTX7gdyOVtjzVWMN6mamiuZWNsyPRp1HcyQsrFCZa/ji8pSbuALvUWhky+75 +FYMRL75bbG1Yf9D5S/cIE8Y1XacotSRwX+zEflbg2drB4etjfXzCb8ZV9RA7U+u8 +G3cfL9WHnAkSsvxgpmse3PPewwlruI2QyNvHPo7pqG2p03lCV2dyB/W86Gt81BBc +a03iI1hYlpxSvt8WkAhLaSWxEOUKZcwSNyijY9pt4VOBVGuMT9PqAZkUiQIzBBAB +CgAdFiEEhnBuIof5z8y2ACfJf968UpQss1MFAmPd+PcACgkQf968UpQss1NbLhAA +qxlV1XyCQ1OVBNcFspTSYzKWv5gxCfXwmVUYVhCo4VDC+ppnGJW6iv6U1kgHcAE2 +Y6p9CDrR5g8/nCI0vMnAKzpk5a5DYx0ZdKUJpOOXLlKAmsiFvXgkwsCaNL8Lo6cV +nyGY013CSXl6Ocxbs7jZrlJ6Rxvp/tDrs76YQ5LXxFhtMJQXpYY/tnJW5Qd7zBNz +1WWfKsEiUoSHSPuBbevSReQtG/1kxdaG0EFkm8fiuOQZhJaH9s0HQA1umCnJpitZ +/iVdEjyA00pn012EaqO/j8em8DjqIIErUWEfpnMwoCWGzkUTW5SwTERbdyjiSG5J +mGEBFQy4AjGby2+rqqL76+HhQkm3eofWo0dM8jx5y1VrzN1xEdzlumV30/uWSHX2 +Yf5p30LNcfMQzJoVEVTosjGtfsB1W566jgwL31/SQ0Lh4Obz2AKTMWu/NDKxqtu8 +xnlBqOKFqWeTydELVG9tM4L3/gMriyI3Z3lM1CaWCiFtzCIOMiPJfPEaMX4q+Qne +pYVqB8NSdz5/0li5GDbrznZ+r9neGXw862/TtpxXGOnnQctZehDtCO0s2tKpvaA+ +NXUl1hlIRHJsQfmcDehprHEg4dP8E9fGYvwgQ7VKAeZy5RS322+H4/K+DINIhIGd +go/ZUiypWOWQSrk3nTOdNA0QC491QlXpkSpKDQg6CFaJAjcEEwEIACEWIQTUHKPt +WzAnXPWgGwVa0kIRwGDRyAUCY+jJgwMFAXgACgkQWtJCEcBg0cjyeg/9EFdP6P6n +S/x2cPyd2hZ5IEmdW2zat0ucENuK6HPRPGJ67nitp/s6TdTbLzrKNJ0Nn1ut2s3t +9a6bKkSADmvD6eLiqU+qVL+vq7yKwe6qnWrOiKBAGBIFHfZ9MbAFnx8WQvbpWdBv +2oCj3iA9KUcdM5cMQekIks8Y05/LKWgW6H4arsI6AHkMQF833UJBa+EhUJHjwSnP +PjOxhcXGpBuQBBEk1oYNuCBLjE7HATzOguPPvv9ZM4x6sj198IYz8a2OiRg0HpXv +ukSRg61BLVUJ+LPipDLvx5dk4kSGllr72dDtO9nx0JXDLGDsG4G+Hj93Ae/4FN3t +USpsbPVbzBBzMt1uRInv5ZXpUwxsf2hu5wVVo60JABgb03Gi/iw8emKlXPZ2ZvuJ +es/XUxu3ave2TYP33l26kDCFKwVv68C0AkP8fucBg63e3dNh81ZPlj72EUWJc84K +jCwRYC+fKjW009e5j4DdIAYVHKVTkZiDexLCzM2/zzZVGcO/qy3EVm2MiDVsuDEL +4ylm9osEPoieshRDc2d9NyIge+u8m5i0N0SrPCPXIUL+WSFAe9rMvOWpz5ko2WCF +geN5keTe1O9dsvYttwHMieN5ac4Y7lA98W83l/AvgqbiGE5kO+t+BaRcNSwZXglx +alL7ZbSH+J/Yu3wbc1pRVEhp7qEfWAozzsaJAlQEEwEKAD4CGwEFCwkIBwIGFQoJ +CAsCBBYCAwECHgECF4AWIQS7OLEVSVW6FH0jn7b8Kn3BbE4hVwUCZCd7LwUJAirF +EgAKCRD8Kn3BbE4hV9MaD/9smI3GHNHfyBrk1ac/NRTD8NzDZOTmUJP6vilbZu1l +hedW+NlvCLgKrO+EwFaM/lq32+dRMWfFodnO1m5dLFOcj/mfeXpD/rssJUAX+gr7 +JMIOfIw9ephDYu6+xY8RXv4WR0SO68kpV2+BeGsaUsAGkVUfpkPA49f/vYg7H363 +0hqoODit+GfEP9VaRXvxVJizoabC3eVWPQ1GwK3B1o3amudRubVv2i+oNhgoyPOx +5pczDTSqJNJw4Sus89/wTjmlRpzMfS9iRJa5GF0l+DE5KTvd36UmM0jimglzN2+x +WPNuXlMmf+VSKLm70OqvN+2/bj8louZR1Q2fmNE95Oc8X2j7vonHy9YAoBQp1uSx +vR3X8i6DSi/hSPT5Voc/6fScWMZ7o+N+jkTicXNyKdQzHl2JsNt8OM8UZzbJnCvK +A3NkD4oIHZbTKhJ8vtU6i8Lm8FpDz92FaiXR4IAfAdGUeh7wteRkC+28aMqtal3Z +zL66e0Noga2m9lUfs6ltg2F3JYYpw7Upy6sFivEl3s7xN2bcVQMAx4lkbyAu4RO+ +oHnIOEJs+VY1gCbkQeAu0LIkdOj/Mp657YyNZ4DID9QaR/NsMAtgoxS9y+9618q1 +HXqazQCUZPxrw8XHBHnuN25gCf1VThByoB4cDSb4JQKl4FWFXVMezsmu+sWxtrUz +H7QdRGF2aWQgR2lic29uIDxkd2dAa2VybmVsLm9yZz6JAlQEEwEKAD4WIQS7OLEV +SVW6FH0jn7b8Kn3BbE4hVwUCY93rqwIbAQUJAeEzgAULCQgHAgYVCgkICwIEFgID +AQIeAQIXgAAKCRD8Kn3BbE4hVyOnD/4mZgJrASYFDCS6y+HtCkPHOY3JoNCwRlpN +6ZJ7WgBfH/k2FLqerswHdaT33EPiXuCcLwsOnI97Q/t9v/H0g0qccLQMbINOqsLJ +UTt/VB+ujtL0bNVDAkvR2Eu7AZCjb8kXvrkeSjeqT7+Y0HwL3CbWfrCXo0BjkZ3b +DJpn8Ip0liPz3XsSgyJPqXD2eTR9vzq4IvrG0jq3isixaSKz1RkWYR+jHGEsfYS4 +gFc01anc5J1lbKGoZjRaGwH5MhYp+gzA4yANyS9DUOwHJfSGm5GGFRt0GwDVNRvU +rGLam1WjI5yu9wr3FGAEY4gljiqmE32iZFg6bi2MUsL3jLeAmkp63aXWw5Zz/SKb +noYS46iilXbJaEoPASXU1yXwk5xElUY6CE0hUROb8NH6/ZNWJmzA4yzp+vaWhl1D +BPKVImS8UP4XrtJwMEXYrVBeHYDxH8faMqNfi4/wD/d1dbqhHxzbdl0AaUmbeVXY +TVHG4fqYSpVodm+/uSaJBtqNxHFNLeTEdSpLg5lzArO84HbMDsAwdB3jdMhVGJ78 +hz0XZwDOuS3Y8VuPNNzfPJllUa3okJ+CW5pgrG2KlE46OfB+3VU9mAEvaqiFZbA8 +c/L08BCSNXwQIOii2WNDg4UgZaVms8cf36pG1MmkhcD2qgmZpaRd4BwDNZoE6c6F +rBeegkmgwIkCMwQQAQoAHRYhBIZwbiKH+c/MtgAnyX/evFKULLNTBQJj3fj3AAoJ +EH/evFKULLNTBWgQAK/IQITH9nZpykC4WFpr6UbLnoJM9Ou2y+RQnKY1AqMBZo/V +SLE9MI8Ri8fi7s1ohoabydRrgzWRV7Kj+SIGlbQ3OyXlFtzFjl5TnF0e5ZtEZcIu +GDqg6XoGpjeXW8G0SgG2OVnCHwyFPJSRWvKmygkQme3x3SWF5bN0R+CXyEh/d1SP +yuSCZghVIj/SkUAubI7MAbFyArMM7R0+d67PDQBVqWOztp3Tk2LHVYN6FX9SWbKc +t+a1VHfqzozezdkoXeGO+PR8OfQcL5+OfLjQ9kVUpqbZVpysLN9uq/I2I0XtMMIb +KbSE9cH3VmZEogBFQ5iv6QZhwI/7wyjMQq0gUC+rq3OiWfdvrxJC/uXC0iSVM81H +sCfEIafvUXpgZdFfsj3AtZvFsCV+eNLGN8/EBqUQXE74UbU9csDgt5rKD64ieS/9 +Vb/w8QvX6vJfe0k/GP5LIXCT4oVHBjbx9KCc/vrHdK0kH8sMXTuuPxnEfR4KReea +Q8nXPgzANnOHvOqvYmr0WUzSMWHYp4XI0x2z9kcZOBi/Pl1Ct1Sy520jgRpMAqSz +QFid2OrpkUL4IAt0vjpNy9gQbB1o/fHgHN0CKwdmbFlK6TyOmubOktXoyQHG9s9e +Q34Ay9qq/wLIMRtECwDL4YKEYtizUP0eRhkksdMnedRvsJkd7NSICa5C+BydiQI3 +BBMBCAAhFiEE1Byj7VswJ1z1oBsFWtJCEcBg0cgFAmPoyYMDBQF4AAoJEFrSQhHA +YNHIGP8P/ArUd+XpnSdgGa2fdOxaI/k+ILlhJGMr9/Ch3+m2++GBq74cuKNN9qop +mDcuEuk4SvVcez1QErS+CiYU4wirbBF9rfISOlH4ZIqFUEWJ7kspAVU+QvBywuFZ +QgWlacab7ZB9WvvOmlZkUypGhRkUasqDcs39bwHrMTAqacF1X3n3o2yzbEJlvqrT +N3l8ZLjJCVV9iBa9emo0de2OIIZtyaz/Kx6zxRsRjYNgbmXnsw52DR9RBkyRlAZg +CepknYGpqO6AXOguCIpwMyHTsu7xJ6ZamFkscP/dQbjW8EeyFjrMSNjGvagporhZ +i98XWtbiINTSzuSZT9GRbL9+8mUWPefmVsPc1zx0/BijgRhnGsbazqt8mhInCh2J +0CQBiJQ/OAmbVQOvg/oMHo7TE5SpjDu6Of1K4BRHjP7yYMs8BzTgEB/6o2R5gN3e +z5MMKKqn1NwOU8ZdEvdBRD/mrW/PNHT4eaCeKwHwkUydT42UoTR9OgYMwd2XtL6e +3qdDCTFd35N0I2ajLKZgLEXrvI0gq9ZLZ2dhMqlIy/o21hs3EeXKTnO7u/dSnijM +jk6ltijAo8S+zYsp6MobICNj2AcCAh261HFIYHHysrSErKxKBMOzNUzGwPiOrrTE +0BLBojbzPJg+boCVPqRjM8LUf3zRzWsah98PwiS1VVdnbhJhykq4iQJUBBMBCgA+ +AhsBBQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAFiEEuzixFUlVuhR9I5+2/Cp9wWxO +IVcFAmQney8FCQIqxRIACgkQ/Cp9wWxOIVfQShAAu/j7M8C/CZaN1Eja2aq8KmOG +g+6kdL/MGDHs96OUgel9YuM4I829jjqdabieV0vtjg3jQGMsgfxhB6Tdu5PjVGP2 +a2LdVZ8cpyYz9FS1y/BVqqBERK0xk70CyEn9068DvApUbVMn8uuVcPZfCA1uW0qm +MBcm/T5/lPyjt6F5Wirtnw9CEs4dm46+crKMFbDevEKg/ul+2yjEY8RVWXzjVSrp +I2sL4kkR/1QsxUevbaL8jMwHtgv0J5o06Dmt9GAJHURYrALETMg1+v2mW8fapD6R +P3/BQdEkGgWlUtDOLWGoFdBbf6EvTpvHVKtu8FOQ2DPOxWoyuoidNQvFYKs9XgMv +xvCNNwmbo2AF+Bc4mvQvI0pKAhmfJl1IA8Vchb2rLi8GeI/Ax0AOPJKNTzV5Dimg +Sn4PCwjJ9VKWTGt9aQfhPZUFLdNAZbcmPnDWkpB+LkLpWkNeqNAGvbSaJFoxFuOQ +ImVEEcTHME9xs17RmY8Nk9cuZgLuFzF8te8U7SfjGB32E0WK1YMTtf0ZW3ThnzEC +gwfV+IR9Q72DzGys2YY+QG7RtRLzHVndyE6umJebc/uCGRav2dXN+7yCWkpaXyLG +za2QQlRxJU5KUPPT8owcFFwhTH6KX9PwZAPmHq/cQgxuqllEn9YrX9dUudx17DNG +/hsme3YDBPtzjgdXdd+0IURhdmlkIEdpYnNvbiA8ZGdpYnNvbkBvemxhYnMub3Jn +PokCVAQTAQoAPhYhBLs4sRVJVboUfSOftvwqfcFsTiFXBQJj3et8AhsBBQkB4TOA +BQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEPwqfcFsTiFX4aMQALw9fMxyW49g +0+K35S5iANFyAWqh5bl/Va1FVWn7a97VwTF1mct9IpGqrfeUKFHKQLwr8s4CmdBF +QyCF0bNVAaDk02ZgTpf2LKk/Fs542Z8qbYO5mj8TTDRfphZZB7rLQpZTRMmq1RFA +/sqa6OZFL77ViaMRnxjQ/qe+gLuqyj7b60abfS3RwdoSkkhj1dU2i8jy4WvOihO3 +xU5bK4IK8wMqHxtA6Ngkoqq3isdSPxzkgzlk26P/qGyTLH/pSUFGN955+hheiTO3 +p2jf12FSbDuewweRDjVeJzBWxTpyQct4doYxwFPRAR3OplyuLW0fxqUkcRxfe4+P +G3UC1gPMjgSIlxXM4tiQqwPxsLXUUH7m4CPHH7GFcu+wWhhJrnR6yBHurP5enry2 +k1P+HXI2KR57jhnWOZAjhWASsiG5ADOND3yAQTi7gTG9aM9k51NXMGStyswJKYrW +Q/dYvNMVL5lZKh+wDaogPo6MI6Rw1Olz2E8WZaCTE02K8oMWZ9TcGO8YQ0NwBElb +MtJ6geg6pJVvrJ5mt8bdnWO3IeC3q4TY8YtN9afpm9awSMRUHqG8GBMB4TkcwO7k +H21lFOcdLnOdC2raWOGteig3uFWnU0uTk89GYgfq6Nes7OoqrK9VGcwnl8hnpodu +Uf0EHOq7ACXMKQIadk3RNIFSNoOP4gxOiQIzBBABCgAdFiEEhnBuIof5z8y2ACfJ +f968UpQss1MFAmPd+PgACgkQf968UpQss1NdrQ//WfXekwTI2DyEbeecZFLrYF9/ +wrfMAYx7eIzJC7WzzCH0gDsWZkvxbx7iy1Iq+A9TSfsZzVVPnWjMUL6S4+oat4CM +0RDGf4Pga9J7GQtdUDjingH5NN7vCX/IKbDwJL7ZGC5+0u+/pAjjvm5Mzmpmd4XW +uTIkigDC17tEDj4JPWBYgtKOd/kjR8l0a0slX2BWI/PuTmzJaExYwYgpubjRZjEF +nBgzMgqeYziBUiJHYDAPZwO913JQTzOfrKBafseXNAj3Gm1DSNB1nu+Ccns4Eb58 +hHGk0/dxcflwuhamQ8V73EqxEsIhNWOPQXNpsluWTeub156p6htxB8d+jsuyg6ey +HMDnLNEfE7b1mchrWAFf/nz9x6TJM0Ntj9/UAlS7vI+ei80SJgILs3nJ+bbiSyja +eyGgUVDuIsst7QuCFfVnJdnnojaQejUMenevNHOT0vcOT2HOObQav1QBDFywFRq0 +xRkbZQhQRdVMjsHgTgl9QowsCzirE0X2q4E/9fMJ+5LySSj49EUn25y2mZsRG+oM +0YrvTkOwMAuXDs0XQ1ZBmU5PzoQW+D7GMnhOu2PDVu1d1ppZrQTvFuQdYpol5cTh +AHDkoRcfTWsqrlWr3oBRVQpeIRhxLlr5fBjbVk7i8YHZZ1G1bYKADMEX+ranhagH +/3AlNv/hVgqlJCr2EEiJAjcEEwEIACEWIQTUHKPtWzAnXPWgGwVa0kIRwGDRyAUC +Y+jJggMFAXgACgkQWtJCEcBg0ciXcg//S2RaDopT6pkbBWjzh5rIv5PfONwQnmN+ +sG3kBbJjyILtwGNKg5m//7sD3m4q9P6hBg/HKDv98KCH1sgiX01EgtayZEmQ+P4W +Q5c/XGcNUUhdYrF222qSCWBiB0UWKM5YBelCeAvShxF4IUN83dXBuPOj/vASOQtt +xHsoN7OHKr+ljPabG54Ycd4WvofURdq/THKaw34FL6uanfESIkB6+skXFLMluPYJ +gMQsUKAavZToipxtHNEtyhk+9PazenF5vlPAT4KAK9OxofzhbzKgrOpoykzD3die +exvmmyf9spVSEe3Pl4YtWqxVIZHCVgC1pdKrBnS5q1TGIoE0STkJuXCZTNun9L9L +6Zc6xeoYQdcNi6dDpdu2uGZGvOtwjWZMvKTdTLm+qMyiNuNgGkVVLoqOm+aG+gTT +P+kN8LQtuvjUcqQjOVBgKqsK4jpkik7phccllVWg3vmlBpwv6IAaoS7ZDrlZoaGK +POpiG4SE1CljE8OLXciat0ufhUw1JLk+svGGE9wE02P8kZwvxlwt6M0gzzUljA1T +I+DB5UPKInCAMKqsQ+On5E/J9LZo6R8BMKkA8VvboKjVQ4C6o8Y+rPdTrB9nhw0m ++1SXHI9uhMj+NrTyNOLffykaEryn0audUzMtFxBzCHAx9LikTDmdfleNNkr2Nqx5 +16i8bvK4pECJAlQEEwEKAD4CGwEFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQS7 +OLEVSVW6FH0jn7b8Kn3BbE4hVwUCZCd7MAUJAirFEgAKCRD8Kn3BbE4hV6g9D/9V +XtAfHSmrxLWTyMjFCAfVrl3D/mRN0LNdcMY9xDicdNR2SLxZJpeOTv7oNrrzM5kv +v7Sy+jbj/wwg1Nwm5WIWIdE++q8uRNWpSQeAdOQT8W8yYnY+RnXhh5mUzsi94EeP +iyS0dhk0Sv57Iwn041dybtmN5mnnH9S1W1fTPMr/hUkcGmYzNZLxobbQhkGK7Baj +yUgr/bKhBguB/LQztAd42lsx33xZQlzUPTnAfVczcJLBY8IdQLmkUNGBLnyJ47qL +oTDNYYoDVBFZQfc485bnSYjP5EnYk2CAIaQbnqoEvmQ5TlYvBbAWmN0kZs8I+p7y +cju0XoqROhqN91gYw1afQhqlJkGbIdxrDJBcac28UWbco1yKcUwIGNKcFctRc2Vd +pLaoM0u2uaISrD89w2UyukiJ/13yuo58BVreWDSvC7u3DfUQCFRa4k8R9hS4d+Bv +wbaqVJ0/R7vVCjoV+q/DDrePK8PEroyUvft7fa4OP0mcHh/EHj4BSCMoZkaPI3np +BLwurNFBul2LLsWBURTvHQz8KAsIRoFloHqtPi8Co8QrJYkuWQlY5c5ZVkvlCu/8 +JItgBmNi0CeEp3aSqA2VZzGkKnX+MtPx+tNWNStExrzGobSm6ezVWNFZxInCpBZY +PLhL/d4d7OItYhGUGVxjZCfW45UZNAeUiQP754WfhbQvRGF2aWQgR2lic29uIDxw +b3N0bWFzdGVyQGdpYnNvbi5kcm9wYmVhci5pZC5hdT6JAlQEEwEKAD4WIQS7OLEV +SVW6FH0jn7b8Kn3BbE4hVwUCY93rlAIbAQUJAeEzgAULCQgHAgYVCgkICwIEFgID +AQIeAQIXgAAKCRD8Kn3BbE4hVzJRD/0eSRNcVKNtfqeiDQAwFMqfbizRCg4nG6zk +y0kjrK4fqHvRi6I+jb8BoNfR+xtADymJCCse+DjGbzr9816g815tbCPUd2oTH53Z +SdKABMhxaCofhkOyMxsjdfKmrgHTGO4t0ql6FKn768bzv/Nr/PrsW5hXlp3snRRl +1B/lCbD1+1LVzFX10sKHE0eubwQo3469FxrQajJUPV5BrRM2JbKcI5zlIMict8CD +xW7TGvcQAnAjGv/ZIQupaUhVmkrun884CVcXVYVCYD2EKUQPbf9sjBwRiMtQU+cC +NLAaEYPQuhw7k7r+hEubAJ+g+D8s3rxe2oWgzM7AiutlD0Rtlc+LaLkGkRz2Yk2H +MX3xzyisrSA/cHc4TWsOUPWUZiDOWIxLVtGHiMbHsSQeSJe767X9zWKcO2t1j6re +oSJxLpw8LywtGOV0BoSgmxCNVim/5pttQLIbW/5GrxcKZ8w+ftKbJiaSvlu0orSA +qAhT0QofULQCPNQ44L8huGituNZbOisR2BZ/XQ9mkRkXVKSQX+8rLXXYvM1H4xhf +2Z9Qgv5NQBUdDpJK0i5UDAQlFDYHwz9QMqoPh4o7zmNqUtba1d1LWstE3ZWjL0HK +/XDO1pydW7Sf00WwVNY/QbZ1LcXRcEM0OpOtCr5l+6Tk6MZUEcgJMdj+L1ogDPcz +vYs7qX4MeokCMwQQAQoAHRYhBIZwbiKH+c/MtgAnyX/evFKULLNTBQJj3fj4AAoJ +EH/evFKULLNT2SYP/RPzQZPFQpwpjNSrGYryhQ39VEian/F12p7H3h5AujqutDyU +nduGVvsOFN7mnNp5NojIvJ4vFWMYCXtGY4Nk8KOq2nIqhl67IsVJBmU4J4QVgO5W +iDWmMzNnifuafQ8iB6JPEM71rzltFJ79JL0VeWnygkefb9AbrXe48rAND5WAsd9+ +wp8CZqJ4Oac/e/7mv4G+gzFB/D1Q4k7NGRf06bKE7d+z+4WZih4BO5WflOdLawae +0/UTseLfN6Wlr6sKwhQ6pLm5xxulpWwoKx0NRcAAYMDlSHr7zuXFrlVe5F74L+cF +7HFBzTkevoV7mZh0XHeT+3z9F/sTwWN+pYGJQzdln5+73h4y6m2mrjgaRni31NSX +cJeryBmDwjXUXhzWd8MfqjvuCEXo0t1S3M9JGdqr3Mu0WQyw8WPFqIyAymadiNGD +ORWi6Qerxcd69u40/vaOmmR2b5vvO3Obb0sgS6QmWVpTZSzyhO5H0Tdz9oOY7NDj +L8p73D6nPZYzb1JnNOGVNQWXIQ5ze+FeucuarJs1QV9dyijfNHGIbjcyYNjiYVr3 +ngk8aWsKby9+LNMwtowuNor2apkl2VH10l52g4nZUDieEROA8cOzMBW96G5g0dKG +agtTMGw+1ezKmhQFBvAIqMS6I9HM79ZRlydp/NMzhjmbBV8g15MupxN3Qh6QiQI3 +BBMBCAAhFiEE1Byj7VswJ1z1oBsFWtJCEcBg0cgFAmPoyYMDBQF4AAoJEFrSQhHA +YNHII4kP/0JHZvQPXgyViUORwgOS7Kcme3fWl2KbjrK98BHAit5J91ZcdpJmwZYe +TeDPjiFlwzTvzg+O5PbxH6YEhBRb5K0xIQnqrzwDygZ5q9zzJLemGJ/OAnONWMpJ +f0OUI6sZ+dlZJ3sUdhJn97V1t15KShCt6+JHn+/qMcRxYIAV84UHqXj/j6E6SxZi +Z5zQyd8TJHcU1E40wvv3vaoRyUAtnd2F89J59zQgIc5R7PGN1hR1OtsxNaFx9FJZ +EbcUA5tzKVzZdHyPha22CaAfzqnpcUazmiEyx+HZpysfZGex05kt8CdSNVgfiVv1 +wWQyLBIDMsLp8IggkMoirKBsfDCOKwpYU5ugPsOvGRBQ2KXQFHHLZh69/z2X1Xsr +p6ukAJHASVAZWwfDTddD9ZB5S+Ux3EeahSV3SsFKeOzHCa7HrUpz69jszP+PpT6j +/r6DspWW5M9kUne/lW2mnpDFfzUOcSIpKtXrwcAwlJaE5DOxEe00m/V3pj4BdGN0 +nzomjVvt6oAzYlIsr0g95Jhd7I9UL7ARa6+c2VMWqVA/HtClin6Kc1O4NT2a4VjY +Bkyaj0lleyvOjUX0r+f3Liw3AZAm1wCv0aDfazRvdenAZVwQeQzoZoUoCdJVXyU/ ++Y74uisFDdJ14aJH42aLSQU946ldjmVTjQlRfCPhbvbGnPo0DJ+AiQJUBBMBCgA+ +AhsBBQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAFiEEuzixFUlVuhR9I5+2/Cp9wWxO +IVcFAmQnezAFCQIqxRIACgkQ/Cp9wWxOIVfWdA/9HL3dgX7gWAY97fDA7AfUAB0S +yLxndSKjdzWg/p9uZ2W3Ffl/9EXgqSkIU0NZM32oUR8XMzdJDSDa9UyhDQU5LQzV +AGrsRhdSmrLoljIRnv6uMSRaMJmhjDpEOfbDK/9cyy2O/I/LyXjdEFdb7dj/5yb7 +P7ugV1sWV7M/xmDxkdZJjLoi7Q2TOhdJzSG4mYfCHcLNCxoGcCHKumX9z7J7d7Gq +fqrZVAB5cZKhdHgxnX8NQDdVo6R9X5MVohLlnPfrpZpYMMFwUhaZfrG/JZKhRlYq +hRiGVldYQKGCW8CZo/Hmk/jp96iUVhkQ55TdjiRXqm2fk+KEtETt4YciL7mwxAci +FrGBFeBhsfxvYky0U3QYsB4p7A/K7rOUeh3suQgrvpvceHOTHbmG768WSVkbfdQj +dDaE1/Xc4y5BR8l3uQrs4MJclIuJAXGCKAJpylsU3TKaBTG5CS2DKgsonya+3Zfa +UTFtqfZU/YU+I5ebzNRKAw/iAG0TIAtXcsfohMG3jsfnXwNi4r/gIXp6TCFVX6FY +XkE+z9xRtAcWo4lZeBNYlm6+44rbQ9yFOpPDsVoeIAy3AUj+5cLpJKxKZiZqSEGB +lcMRCFwUw+85KVqBIDF/8hEI6oUQpNZRvQLOxEGqalygqIZTJ/yM6E8NY7fkkZ7h +YHIXURbIGMSn0Uqhj+G0L0RhdmlkIEdpYnNvbiA8aG9zdG1hc3RlckBnaWJzb24u +ZHJvcGJlYXIuaWQuYXU+iQJUBBMBCgA+FiEEuzixFUlVuhR9I5+2/Cp9wWxOIVcF +AmPd650CGwEFCQHhM4AFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQ/Cp9wWxO +IVeikBAAm1p18BAvlKcm8FDcXwtKDwuvCBeZh/CNlNnnDCS+jAYVW67aKfKolWcc +L9TQ5SHNZsj9hmQVGf2ay8cf2Mvc/4WAaj/9eJVfgQmOy1OJkoSURjJ4QNrpuq/p +R2/kxBGpHqSg6pV8hCI+YdOm1x51g5np7n1nK6CtwELapL7gjRN4iVHwuea2EAdl +GCtTkzKmURSUmOGWD8XhQYzIgWt4UtGguJFIkHFQVnl40Zc+Gl9yXfesS/ZIhs2p +dudmqXKpEdaZIdUAoYk1k266Ikf3+Cn+TQzF35hiKh///P4MQ62s3AHCC2k87bWm +kRlfLfhAm0snMFWQf+0p2aUlfNRk69mF6bfVfc1y/hvPh2dogBskOfMbBRrRhDD9 +0rKB2JMw/GQ70ZiPHFHqX+a/bp83OI4N80EOC3r/f7fC6am6sULS47jioLmpZrij +KlxS7XciZ4ENpxW2g0TeVmwtrW5X1gnTMXnJdG1UjxgtPfCjTSfcevbQO6jGmD0l +aDh+HJkWHhemyK48DebT7TL/7qjC94kG5PyZ2Mm1wk8FlwN4Bdt5Dkrxt0FHzpeW +S7OudJMT9CWUU2RgYfvaXcIYfxAkRK2NvdqjuVIlKOXboyd07su3CCdirG0QNVff +sxFM6rMppyzSzF4N3PhxLzGIbiyaLfXc6RfvtIL5ShdEc3m8VNWJAjMEEAEKAB0W +IQSGcG4ih/nPzLYAJ8l/3rxSlCyzUwUCY934+AAKCRB/3rxSlCyzU015D/9Xxhgy +y7Rv2aDmyVANkaZcaw7evv98bNEsVX34uKKffLEcDO0CljepsfoiU7Vp8eEC8v7k +ABfYLCqhXkW4FjeOAJvWPAVm9JWXGJBUWgwxs2xCTx62BSlHD3IABrX0yQ6ue3Kc +3KS6OVhxsC5VVQ+xXA9BYq0J4zyVd+bexZ+hMJihH1ZR95bRXY2IdNeGju1cW8rF +ihPalE5Jl6Abmn5H/23LMgH3czVPSJwgrLN8b+xRnHjwhh0cvFghm+8kGxXHFpX6 +tg8r485eskxbk8JPqwUGuyYmwk25bNSOK2aVOnnTWL5Av9GnwqYgww3gJo3lLxZr +0C4kzJvSU9AT4yjLB3xQ8ZlduP77Y/dm/W/IaDn9LMr7Z7z/fb2wSFwLkSVK/FLO +EW/o2ds+ks6nLQYQj5moffSYwo799XdsUdoCPvmwWj10abdvc1FwKPe7sFlCSKAv +nFNYucbZugq0KjpmHFyk3jhgXhpeeBEhMRFLXjQSKetNJPt2ctLNs+wLDQHUT8Ec +JDYggAxmYspZXFfYLYo+yEm9xEAxmhfTbOD44VyYEj1ooFwqMPu0yD7q0D6LcFqN +13tQXpa0NpRDgg+PpnSiUYY1dne2uvEqC9F7eJekFn/AC/lYifX81u5XmGSyH6S0 +c+Fv0BVRtE3TZ2eatzqsqUl5yV5S5WuQNClEr4kCNwQTAQgAIRYhBNQco+1bMCdc +9aAbBVrSQhHAYNHIBQJj6MmCAwUBeAAKCRBa0kIRwGDRyKVED/sFk3nrfLGdFQy2 +LoYmcjwmXPio76/+MUovXg0nlg6NI5JVjhMjji61BXzOpTPveRAVAzEdUYUyxUvy +jfJkqQysq5JZOaxtKiWpv643H+nETkfxC6RUu6/5TehkTXKEQlN+C7qPTIcvLL35 +UG/khhZFha1Ej6mB6cgHKzDZezJz0pSm57Nq9UrO57XvXSJiqPLitYgkTZyVJIoG +RwPbPIiHjSyeKC+h3b40nYuSDLlFRziW2Ae9yXSxvuKPCU8VaW8ajX7yaH6MxMiy +a2skIfVZWP3PGqSrsZ8JwKR7RS+tmMkAGvQ30T1L2zusVo1xqEZQL7nOPWqOSpif +v745ekI7RGhPOzjZIOZMytb3YjXPn6U3PzBtAI0qOG4+mvgVn43mLJH48AOe8dOa +nl3YDqsxu+tp7UPqhjZ9jYWaa+X1B9fJ01Ke9Tg5q41+R3HEe1JrChxDRtcxgDjf +cuv65/q0+zC3guSL6FZ68RO2gJ10X3qzQ9lJ03UpySs+PdxsmwWtsrEjzpmXA8yH +4pbbZ3oC+r76PS6dFG4xrdethPALNzCfPUIvFFssIAjWX4D+1FDViQmZrCiO1pN1 +b5gpK2s160QpIACaITN33HJSA5QdzjohJEemZWLfI4VVVk3U74L5PCLMC/j+Xf0u +93BJ31z1Whha5tyMxOO6NuFMLVOoIIkCVAQTAQoAPgIbAQULCQgHAgYVCgkICwIE +FgIDAQIeAQIXgBYhBLs4sRVJVboUfSOftvwqfcFsTiFXBQJkJ3swBQkCKsUSAAoJ +EPwqfcFsTiFXc1wP/1x1r20HbUrDbdpUUnKJ8AK8OY/oqJf2tn40RlpxuqiZVRjJ +IROjyDVQ49a9gmvw0/OMwoa9p8HjNy/fdm6zaqjHx7t435FOR1eZ4YNHosFvQiyG +JlwYLxMOtXTmxszWVff166nm/EEYXBcpIFiMqhd0MEv+A6pTWRoLO01TkEkYEz4v +qpm0b/J0bXB0WqxQ/UBq98tpd2DO/NtqVvKaBVQ92Od2uZ9d949PZF7VhS0j/GTw +i0vo3uojNH8kCtr0pHsFUXHzyZa/bC++ey8gklS501FkMD3AdsxpONITLfJE/g9f +UWZDnOHQAEDkvQ8ueGES7/RgD6dA5rLLGo3tzzXPxGXhm+bKddUPBtd2xW7w6dUa +678kvIftCc8C1A5nmmGucsiASwghxHrHBXU8JK+S1+ugRM+H0xV4bzhzA5caUiYJ +PJ4EPJyCYPlK4yJXkF7ZE/pggBBqngbOy0n7mWkXpPezI40dLMPQYppogWrwIq1b +b8dy91+DrKa+duu3b6F4UItWMwfJ+0rmar7xdzlHOmH6CHp94oILLM9JmNxsL2tw +ntm11mA4riKyRp+8WwDak+LR41604KnlDRc7OASStAhHgHQsIW4CaOmhUSUaLUzO +e3QmTd4+sVTRdKC5HUBlUH2GBTiQOeLHQmYXo3yRnc6C7sFsgMJZdFrvqZBxtCVE +YXZpZCBHaWJzb24gPGR3Zy51bmlxdWVpZEBnbWFpbC5jb20+iQJUBBMBCgA+FiEE +uzixFUlVuhR9I5+2/Cp9wWxOIVcFAmPd69ICGwEFCQHhM4AFCwkIBwIGFQoJCAsC +BBYCAwECHgECF4AACgkQ/Cp9wWxOIVfZgA//a2RAVuAa0LprT1VzDoeW5aJyYAmS +7zZ/mugSIWlxLMlMkv0lt8iK0ztHu6V8vRdVfBE7IUK+fQBl5iTGTPc52RDCnagy +6Jon/k+J/jHj4ODENW0CpGWE6RyBjQcSR9ckY/mxSvjL3xrEkQ1aQJhTrm9npYRB +mcvtFhGR9Vvf4FvTqWOL0XuZ9qwsEO0LVPwezmLj0hgrYPUFhxAq/JjnEBaD5cFa +rTcxaRDVkZHneP48LBVjT6yfKMfpFYMqsurPvkHSqmNhmgNRHlj8B6X2/Zn72UyB +ETTbsb2nF/2Xt1oV2wsFexyoI+ZsQmNlu/699GV7ccy0XlVGVejpz6V/zRhGVXjx +9YyE9BXU3TfURx7pNphTJ/qCWoY5u85haBLy1UwNAA1Uqhk9+7x8aTKDRIWLDRLr +uYO7ErG84ao8H23lRPo45Ot1N7JLAdJMdqpKvDc1jlhl6WpydoqF+jZ+eHrJfvkl +QRXuwp2o2TYgnNkLwv8cV5PKwDZgC20i68SFF67wX0BzACLo8ssVj+NKqrniJ/F4 +Mtcpb3k3waZaonoeOcPZDWnVWlE9Z88bAkpW4NKPWVokppYLXzSqWW3d4VlCmybZ +p/04oj+U+GajXHwETq5JmNzWiicVbCf8vwNcb4nnYCK7UYptUtoi8NmKBztw6Txy +VOFqv4GEyHYcmoGJAjMEEAEKAB0WIQSGcG4ih/nPzLYAJ8l/3rxSlCyzUwUCY934 ++QAKCRB/3rxSlCyzU6qnD/9Llgz8662tsI07KBa1sG9WF1+AOHE1xIYG08Hw3aPa +WeTni6MB73rzWokef3FdBaBtH7s7EQxVnSBUCm4hkSpxRpr2jBYuD0BkzF9ME/eP +k7LPTO/tra02/NTJ+TBc4PAPsZNR96CWl6XBlkFA7YEWa7RjhwKTfgqz4eAF9A8J +J+oOmQ/3oi2ioSgHFhMrRymiyHe8+wbvMCmTei8x0bFiVkS/T/Zg8WEs79CvwkCN +ZiRTOL6l0aFCnaHUO+qWz2zh31MTSo6MlubRW7oGtp9T9GxVQmkrIxGMlEkaRngw +OqmqmJIVtuVYDaHTo/INYNWirIOMhQSGIQiKhlIceXkUlax88EiWjRnTgmmLX6JW +Bdzd+LNxD05IFr76qYwgns6lXzClmNfKqjL9g5UqxN44KaTd7DDGAr6Wfk9wT+Ru +G+IfcBM/JaE4Qeh++xpiWXL0hPfxXplG+37JiLripbVILg5yh26nlDduCGXHN0TU +PDDWKphHj+hxRrPPB0ldbkqn5Mbx89ql5sv+oGXOrpx4SxKhclccmfGzGlDd2lEb +OIzBhbXFYLNX7peJki7xIhNWKmPoZhcFRgaH4m0+SSiW1HGcZtnj+eAaVd6R0J6c +hCV5bW04TkXjB5ozrQ2szjsdd9lTdqH0/wNdHZE7wD71N1y0b60AL/UdI44/dngw +yYkCNwQTAQgAIRYhBNQco+1bMCdc9aAbBVrSQhHAYNHIBQJj6MmDAwUBeAAKCRBa +0kIRwGDRyB+ZD/9gpvJeaqTJt8zYSzcOkg7uI6POG6bJjzxVFbwAmGbCtBeBHXsv +DrV9Kl+M7R1YamP4/9MHESRQ5HQtqTPBMRwuAB6Wm+ogcnVHZJGAbvtO63d8SsWz +AMwJHPpuxU6ICWM8qUunizReNgDygIyDUoaNJGIIp1tYnwFD01WYEMe6zKLqBM0P +SM8z2ME92XZz+CjUkKInrqChly0F7Su7sS2c+7IqafhC4SbLhyBV0Gd2M7uKuG/T +gwzlt3z1E1wD4bGDxi+M4JkErmtubbwJPCt9elkdfS9i9Ah2BcvKAQ3qLk1CcOCN +grjp7Mf8EzINYHrLHUTBKphtKWIFcHGtjh95otJYcNXgTEjE5/0j81wEiUUAqTnt +LJj/r8Ux72tQ0eNlyR7j4LcPHchDbxw2mVpNL2kAvKvXnphvpqfWhfn7YqE0emZX +bGFHRp4tDVtibBfi9nRVmIfLyFYb7QtzAsnrO+E653amN6ak3afo5YCAqOwCpk8t +1WAHhmIJAK7WYReYzahf00PCRr1/x468sBWGwWJYPKvLOf+4r1swTcq+cvx3QPeG +iwpI+D6MiJfkoTW8GTRtfbHG0QxN8wbw2ADloHqupsXvDK5eAl9BeSX4g5E5yLxB +2hQf3FA3fAnPPEqKFzuqjxMJizLbwIj2qQ8NumJWM+tVpftawo2LOtLlA4kCVAQT +AQoAPgIbAQULCQgHAgYVCgkICwIEFgIDAQIeAQIXgBYhBLs4sRVJVboUfSOftvwq +fcFsTiFXBQJkJ3sxBQkCKsUSAAoJEPwqfcFsTiFXkqYP/3iyEy1126m4Ecu0OAqF +06KXnr6wOiETh1nBEbG74rLQylX02j5LajcvXDO2ta8fetxzwHDHws3QX1/oaX4q +TAIsDCK/b+cUAcNLF+jdHg/yEAoNfghEN6xFnpGgkrVsjIq1EqW+OsH06cpUbSit +wpgWf/2kA/1gfJYzMAdBhv7Q18t80/DgAWJwnlyyhsiBSdYTNuGM7ak4OlJJtBxJ +3s5cMtholjJ0PsTgaJ7urAMEJn896i+bDvNd205U/AL4Fo2233cmof+yznsuudo/ +u6itshS6affY8LlOyVt17KvLER+WEg18h/VN3oz7yqts2gb1TsLtxwzmjKYG7Wob +2iQ120CU7gAzG7nHB1fwkwgrrfoeaSh9n6732yMivOYpvza05MQKx5HFuROY8kdn +7rLqnADpd/M+10g+Ro1AAzC8cZT+OT3QiUrIDOvHpsmfLpcOHPaww2OtEiVnSLzO +xvFJzQ+GDMslA1+5IoMb24Pnsip2YWIXjxxO5jV0jnGvg/SKVLYwiwVMCGexNnpq +URIn/V0kGsG2nNpcKZ192SWWpgZFZfwq8jL4K8VgBUg2C13LGiFvqy6NOhPW1oTJ +COI8aMNzr5kdJ+2dVptyuhFRiEHSb47FonihmO+loD/hfJRy4JPaxBRUlWJQtiwp +kK3ZomulOok1G8cRj3p3u6DgtClEYXZpZCBHaWJzb24gPHFlbXVAZ2lic29uLmRy +b3BiZWFyLmlkLmF1PokCVAQTAQoAPhYhBLs4sRVJVboUfSOftvwqfcFsTiFXBQJj +3evcAhsBBQkB4TOABQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEPwqfcFsTiFX +1TwP/RrH+6RYRUzvaW5ygjHU4GV+4UXSBgyUqJDu5kUGlehSpRcayHRpdqiePybO +PEzRWS/fRdYb5+517Me5I2WyCZ/eYAf/H9rfPtqn6DOsXJynJa25zgbE1KlR3N9o +FxlTcZqt1rK9LT2eP6KtbIOyA3N/fHz+9xPfqZMBHV3ynIvnuN1FVS9nI7qQNXaz +RTFne0nzU/hkdCtnfisEAbvVgDJn318y7gM9sa5OHyqD1pXWJFxm/QFYFF5NyYRr +/0KO1vzxrhUucoJjJm61a1L69b72UR2ZrLRaSKFVogOwM4q0C5XLSuP5WNfhjMg7 +CtKxqO72S9m6tdTT1IaPEuCZN0X/+VytVVU0gQp7n5G1g7E9fdYLDkKDhinq+7Yl +8dJ5S6RVv1gZpdiQA4B84r9I4Ku/wb7R1p/6UncxC0y5F10D5PbUAr+lVFzxpshV +iBc/LA5IENFDj7m3asFpolC2DuLVhOVGyMn0DITQ7Z+v8b6lHTmAmpaHhhUSd+8x +g64z+tzO0h2GmDLEBfKruNsJoggK3DxKqHMny6+Q94d7qCyWnkd1BR629nDn1ip6 ++10xwz/zHTOAzdd7t1Z6JnP80mxB2n1SW3aCz/z/nPur4plbQ9MwmnHXVxmjTfPj +wZm6VUanzix93TXJjQMcdNQSciX8gcQKQ8nuEvfA6dgZZRZWiQIzBBABCgAdFiEE +hnBuIof5z8y2ACfJf968UpQss1MFAmPd+PkACgkQf968UpQss1MtXQ//Rtpjax2Y +IvAJcS+hM4dmms8YXTZZeaUTjYmLYmMkSLcwX6BEYH44P82vIWCJ+ugM4XJOFxWF ++hXpsz73FA+UD11YBO1zU8BkysqhFfC13KvHqCZd4ga6rXRQnVha62RJ29maQJCY +TX7HZoMWbINXeDWY79Y+ApNpJDwCyQ+5XuA5rnSpcitkGPko2Gl2kjpqSuvoxIDl +trFmZ6/u49lm0BH0PXtQIuAfKk8s1Q16FRnQLpElVWN1cmYRgKtgXR6GF16/rjvI +LwGlsMlK0QjQpCYR2jFlIZywbo6ADN6moU7MoSGCj36uFJilyzDuM4zr7XJlqvwa +AhsJc8dEtsJdKFd2lDv/ttwXIcQr6Wcpa1sszcxh/G5dr/lEfKSoLo90aJ68bvCt +11FE7FC2TW6a8dTBhD2zivaoND6JKe2VsOFGkU9WVUeZRzcdPEQ+uqL2vA0vuqGG +kdVumhEiuABBMFYfEPmZkN/0jw+VTYD92+M3bvZPp89Y4zayiB++X+sTMiU3Iprs +flvqiAM4rLT/JyHyh822KPkArJDCjpXHf2WZu6rxgxVk5eHjyzMLKISt7TBxCrqm +6YIv7H+3ktZtFdCws3TBzxZAZJgjEdNxlrw8pMczRx+N9OHP8hnD6Bi5dQc98MIw +lea19fDuF0A5zpTscoI1gySZgz4C7dTEaQ+JAjcEEwEIACEWIQTUHKPtWzAnXPWg +GwVa0kIRwGDRyAUCY+jJgwMFAXgACgkQWtJCEcBg0cgSjw/+K7ASwsyn4qVnfodI +Nvf8brPzjIpLuV/NTySEJBqD9+zTowRecOTrO7TVytxMkc3lnPmk5wqFm9V6ukoF +SEopDqW0new7TcbxPCeMD/1EWu97OO+f1cF1v+pySx9IPqCUuMQzQHxkkN6n4csX +7YnbtnoLZ2IOoggYP+juDhIsjQYOMOIIKLKkH1yx4TNJlSaUJEc6tWPMbGDRJj0K +IP0ORj/IKL5vbPwPda4U2Uzuc4SLWUrh8MWOKPGLSHcyqS/L68ojkSkC8EXxJb0h +tK9mCZ9M2irwe8eS6Yl3DbEig14zpdVM0g9p+COt3NWw1GWZdcfoMUMiQChUOPaf +VVokzwxf6kyCOmGcEW8wMgLm/NzbUZpTU02QlQWdhAcm+nBEuQGMjvXBOOA0nC+y +KPt24G1sCTrRQzgcrG4OLxCmAsdz9xIcBrsOZIp6ojY0hQGSDosoNx3cBuLb42nc +lWlNo9/DNuOYPFwS6Dusgpig9PAlZX3t7qFhAaY9j/Bv2kGjRQdjKXvtYyb2ZlbU +TOr/prA8UtncHrhckTwrDVV/3AZ7B6OaAx2dzH8ASJ05PY+zYdY5EYVbVuRckYrO +vURQpBs1WsgP3akdUw+MTW7EqAmVS/+4b4RkrnVCcfiy0HkAxvjfVWbry2Zg6xTB +zjgaqploQxmOJdIw5xaE5wxHu+WJAlQEEwEKAD4CGwEFCwkIBwIGFQoJCAsCBBYC +AwECHgECF4AWIQS7OLEVSVW6FH0jn7b8Kn3BbE4hVwUCZCd7MQUJAirFEgAKCRD8 +Kn3BbE4hVwtxD/493U554TXECga1s1pntKwbDVWu2EAxgjWo2YO8yJWQNAQb3rZV +t9MbjnoHVG38uqELRhWGfqd8Z8Bz08HfZcfBaIDz5U1O2dq4xrp9amvsYEOsYteR +2Hh2HAyG9ttxHFnKVRZPYaR5f703rVHqU2w937ziZLTxHQFQzAcgguWV439crXrR +PHJbjgCge/A/mwBQX3hdNtDZZ+C2sQHZTffGzCIQOkX5oqMzbozFOXGFAAIzDtjm +a3UQx1nvQqeHVnp9WNI6T+dvQJLDyBNbPrY7L7oc8j2WUs7RvDY8OxtnvMPQQmI9 +tUhAFQiimkKovrqD06iEVXlrxIosKWQGWT0RoaQyJEEi4jVsk0f/4qVHqydsj3Cz +umimXU0jDe4Ote51452ww14zqJDk0i0G5ALWpM9eAYFkcI7GgLm5+pGq1Cax0q1S +M1G4fRKMyb0fLi9XOXecSr9gDnpoJv23z71q/0tvbuPNnKtr93M+O8wTN9PfgpoM +dXFoBlPWhMUSJrRDabYrme0vfiDJK69amHtN824x0G/P0a0WIs54bSnVu5rbR7qt +V1S0fLpX7VwkpGBlVHM4mQKb6afW5kXOgL5nt11Zue16QQ8c4b/pALz7vuGQVXtW +RfV6QDCtbcOjPGmnoR31GhBgd1wX0ODwLmBrnTP3v4dnjnt9vvICmdpb/7QrRGF2 +aWQgR2lic29uIDxnaXRodWJAZ2lic29uLmRyb3BiZWFyLmlkLmF1PokCVAQTAQoA +PhYhBLs4sRVJVboUfSOftvwqfcFsTiFXBQJj3evpAhsBBQkB4TOABQsJCAcCBhUK +CQgLAgQWAgMBAh4BAheAAAoJEPwqfcFsTiFXdIYP/3xLWI78jkeEzyZQqnCP/HAm +PNzOiyLyX+yWDphlhfhA6Q6I7b295dmAJPhTZSQOUJVQYy/RxWNexYm9f3kZASON +ylXCqBXmcj6dEW6vE2A+gCJlBoTNFCpswjqBRXWAd2Xv13q7XGy5B+B9HWoO6Azo +dBf4RKHC6yIMPj2fyV+eMOdx1SJ5vbeLuVxRSOdJE00PqDjrqWRb+/5rNec1FDWA +xWW+uKA3W60MJdrnX1DFoQcyTnKA0zR1MnteNSMTUlHv9ShPtavvAszIDXLZ9tbh +F3vpyqj8BOG78RqoMOo0WLsrObRKf3JzVIhBWtekCx8RrzP48rdEKI5Cnf88xcLv +q6PGRLBM3P0bytOLU9M4yWyZTywEJx7eyi3dsg9V9hJEytuvCQY+WnI3katm/B7q +aqsgbKLksoOsqk9RmtzUBKTqMgEh12zTBadQhX694B2/24nkZJbKf25vXAVLW7L6 +Gq7rf0714/5ewRmbffx+vmpc2eRh8CudIEn2A2DTUsNiZuf7MjWkcZNrl4ynHK+W +kCc/Xg8OlVVSz1ADTa2kCCB6cg6AMxHVVoZcx0cwthxePCActML69ZLhDM9T8wFA +FtVTsyxx16EPZVP9xjTHUk9TcP3wH9aB37n4y0VBUhLV1QGAvkB2ql/2muY1swlV +kAvGKiYLBcfYq6r+TUHYiQIzBBABCgAdFiEEhnBuIof5z8y2ACfJf968UpQss1MF +AmPd+PkACgkQf968UpQss1NjgBAAmq/rsiGlN0CpRcooT7NlXIS4bXDlvtJDO3aZ +PPSyudrzR1kUdHu3rn5/oDO23+wHBrKEetwg0cd8suobHA0dY76oaJS8w7Y90IKd +T5mhhZdERilv00eaRpB6cw5U+2293ju6ML7Iz40I9Q6kPPSvbUiEWFg8uzjkntWG +8HIyV+VnsF9aPmwKMCXe7qCx1KSDdtaNSuaUvzvJSxJK9XD9VwHXTwwu/NQfbCnF ++2CIOYpCJgXLYDtWjYVNTexSdIF2k7KI5kxKM9yuUz0+cOXbRwEeFxwPyllo58ot +evbbSgarxNeWcb/1+8S6ltuCbOOskHrKzKaJGfhifZ6aiL+tKnm93pvO8iGDgKh/ +KEiUNrTIKpoaW893a2Uaehosfls6/tJ6BGcvHpFDp/0z1X/QPvSmULwNehlcfNZ0 +ywStBWOpFGylyXCMHKb8M5FNWG2i8eQwfvqeABV7jas2etVyhanIyUCsRHtQZnBY +7aTVkE6p6iTlJLAsskXcYxvrz34kk7OnJglP0oND341bYgn1RSHBro2CTw7R9Ht4 +PaHkDpRRtG0HRNhbREjDMfSlpdSGoCheNUvjD1glrScI0+YJ/88zcsX4bgA19q5q +FzD+Z8Ub6794ri+p8oDTwi7YE7v9NO4hiNhH3qRYiyqtg9XexO/2HZT2PqHi5qwc +MjUmIfWJAjcEEwEIACEWIQTUHKPtWzAnXPWgGwVa0kIRwGDRyAUCY+jJgwMFAXgA +CgkQWtJCEcBg0cjtxw//c/iGQu1WFusB1YC7zPE3mxNlF+cxXjOa/Ts2blbT1Zs6 +xIqblWD1MZKupRK4kCDtQr2GzegBp6FRWx96IR1UFvZkysTmdozuJ4bdH1xHaTlL +adtc52Bmf0GedVJf8hB5GY84a0OnvWqfWP8oHC4SW9sCdqlNelGc5QCheM7938Lj +EqQCDsrzEhp4Pwdjs/0FPt1RsV8XpqwYyRi1Umfyanw7OFuQURiZZ/AWU3S2yQfu +Tmwg4rvbRUY2YwRrYJSKUydlnkJpE9ct7I3wqHwJJsGktyng2jsX6BVS1Xa5xpqY +1qmY6b101Ht5+0O0mMAxmHFSmm9BPrSDLARCdTpCtwXoxuz9RfO4Mbgl/UIjd0iW +tptOm5US5dpuyLUhdGqAaO1n1m47zBX3NGlrqDK5CxjWdUdLN4xcpllSCY5UleP5 +kAKK9N+fFBL1L8IMShnWNIjCQjleVV9fxZzeshAnW50Ee2yEMxdHpQhPzcClCG4Q +A/2WueprEXznzWpO1uc6Uqh3LEMNf+z2q0DX69wwdZKjR/dHShY8c4EYMRZEG4PN +N+lecKi3dB5r1wozQsOn4xcc67nrdLnUw45bOjLwzAinglQl3ifqUk8opJtHi2hm +HB1hPESuy0AAiRq8fOgdqvV/XXvb+0W805aZ/9UFR6X1DnA9D7JTQT/88+fVDTGJ +AlQEEwEKAD4CGwEFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQS7OLEVSVW6FH0j +n7b8Kn3BbE4hVwUCZCd7MgUJAirFEgAKCRD8Kn3BbE4hV03DD/4zvSF708iWBdqd +QxqxtmtrNaFPMpMyNu7xxFZRyphUeAPEi4Yiyul7L+dUT1K1+uDhHt6aqOfnMbkG +Td++/YYAOdgtpK/3nShwwmxo6AE91Sv42vXWWhF4Plh1HaGbV5IrHxx/OljtLjgh +Q6KPA1QR494Su8VUFwxDVYK0Tfu1VcbCbWVpQNAEd4vLaBWxKaFDn6+4WX363/ya +ZsENaormgUKKwRzcHTvhfWpSWwrFezs09GF7Y2BmTL5vbEBekkzzSURVdccr6jZb +kIRN4P4Y09FB/vqppGAe8lYfpRAKCM3bDanOlF45nQSLElkbjcvduDFYJWZ9JE+/ +k+6p1SiuOg7rG3hJpWVxYQIbx8oyru08Hu6CQ6SkThaNR6EItCFrrPDtgDTjh3jq +BS2VlMGg2i+2Olo9zFiK5/IJD4PQPIL1m2Z3/enUzO3MeeKhGJGTdetsD4OW6eYB +UvvawcWfVVsxKg7D4xZ8ZZH+8pDNXZ9uHvRZQSWZ5+c3rF73ZymWLK7TiFlFVqZy +Pz2cC/PdJTNQzK64yknzK3iQlX7FCYP3zejQT+c1htvcWSan0fbFfZrj7OZR42zY +PDZ8jokvkYkhS1Uhvi1zcyJpExOFdfOPqQPtg7BMjti7tHJ6FOSO5a2eT1r271jP +w/wT8UikkfJVLYECCim9JHInchQ2K7QrRGF2aWQgR2lic29uIDxnaXRsYWJAZ2li +c29uLmRyb3BiZWFyLmlkLmF1PokCVAQTAQoAPhYhBLs4sRVJVboUfSOftvwqfcFs +TiFXBQJj3ev1AhsBBQkB4TOABQsJCAcCBhUKCQgLAgQWAgMBAh4BAheAAAoJEPwq +fcFsTiFXeG4P/1VtM2FwxZrc/gtinsfH6bK0vidahTRIFNhyEkJJOwQNIcKfdvQT +RZYuxcLK2+uECsizFaAHyarjxh6mBwXjvqp7RmRC01gBghYRrXUmZSlRa5jtnDqK +tf19lHXUk8aLoj5Jc9nbZkyEIbnxTH4SgVsRHganCQBNE8wAr+pqSMY7KAfP+QHP +bnMipgGTWB9W9uqq9TTKQ1vRyHFc6+tkHv/an/ZIPCNntIk/bZVNljFHasnzPgG1 +h988mtIOqGNRFW30zxT54qVx8ybgIdUlW5Mn5utk2tzfaZIYV+mBNDhBJi1xlKjd +NzdJjwRMs5Y4Tgy1ZdQEyKfjrNG0VyFE1WS/QiD9rilhwZp0dKkgENKjoPvDmRIs +jtvZIGclHYEQx+erp7gW7Vo9Z8Tp9Yu3i0No+FvKwpBMumkbmRb7leunkuv0YRXX +fLbKqWXUyBVTxxPGwup2frKA+d8FyGWFz9K+w1/HybckVVh3gUdqvdiW0LJpdHeG +1UdO3doTRXiuobNYFwPRm5rF5lRsqelcaw+HCLav83y3518Hj1O/jECWauCWafFW +0olE0iYrbMFfzRWOME+h236qOq0+SXuhDdovfX61tIOQKh9pyhlci/aFiRRMGpBX +dCkYKqrw+M1NLvzRshNuN65Hv7Tsz0atU9aRBFfJO+K6LTdmCSAvVxmYiQIzBBAB +CgAdFiEEhnBuIof5z8y2ACfJf968UpQss1MFAmPd+PoACgkQf968UpQss1N9tQ/+ +OV+CAizP6ye+mtrzchpfy6N95vw1tYWQ5VfDkRoXxjP/NoDozST5gXM9NpOViFcL +0edO+y4eqTpMxjSVJYfC6bAyZOve9sR85ibV+Y7KQygoKVqNvPTd82hDoH2Lg354 +FKdQRG9k3c92yjaoZbg+ZRi8KU+0Osd91dRXAK4mmhIcpi8bQcmBuGJCk8TUVm66 +5Q9g6+EV4p1vnEr8W3TDE8PQIP0modNMn5zJ8WMoeGK+6mVN9dspGakb/PlHDXWQ +W3LIqMohp0YYcHdbyTlMDYf+p36VfIs1S1CYTcz9IpiEjKB7wuCmPH0MuRvbls2P +ialpvGEIlEYlW2g2bk5FRKN5Ej6c44BHDuwL72KxXhvkIKHBWnszMDlHr3w3UrnE +hkOfOqkhnVdHIF3Edrk+O1W5MmwHT8QR0SBecbny6ZBX/l1kKmdd/u9egTTCP4vj +mh9hjt9MCnNMgqThyP1Q9lwvRrKK3eULojmr9ATVszNYujrxyuLhlZ+ATmDQ2q+z +Ra3TpsSSbhdEkFGqlE59HdcMQPRt1U4SHl130cYQRElxEw0ewDdXlpVE9zlEtQfk +2AAhfUevPiimOd9vPY6eWz+VlTyNQciiFBI0IJhFhKQ7oYBtClO+r6Vl36hvpLH0 +UyIoJ8pxbFK3BWtPGgfB/6kvVPhFsdX0f4BkFujXaJmJAjcEEwEIACEWIQTUHKPt +WzAnXPWgGwVa0kIRwGDRyAUCY+jJgwMFAXgACgkQWtJCEcBg0cjyGg/5AUFqwxWW +AKippjFJINHuim+yE+uke8upAawBGEK1ynMOdOMySCr6DlDyperUKGKe2MZSKpUn +wk3r1YI+1yocbRi6ZH0RIfxUtc75aTrKxe4lZ/9j2LGJiPuEZUfuel/LHVy0dSOp +QqOIAcpneKZrmGf6Ljx7Sj/8DChc1Pfi02q3minSwe/PdDRVbBCIuHXPGqQTL2Qx +dt/PZ4PlQTknjJHH3ykdJ+xBxbXisOwuk5gn6jBCbt+wPKiYnX+6f6jT3w5PlcPd +4gUk3BxwG8psA4oNcnPUzq04L5/SUAmuYaqrOFZeIHNUFnlJYf7rzBVvIXsI8Snk +gMN3tx4VzF/3fGCSdjiMaHu6ydNAAyZVYF+lz9mAuCIrylaAEalB+l40xdMm/MQm +011PhPDC8yRQhCwdZ5vDS6kU+ZSEmaCmpPXgLgSiQl3nxH3XQs9LfeOWY0OPU6lf +ehIdoCCWYHD9E+k0ITgGHKAdNQdN9PuBJGcPebxkjgYqAkIPKPakJig63NKUiNwZ +EcNieyz2xEKqWLafBqHC0mukKA/ci+tI+V5GcoPyAmULIiYOBmCkMr3FXBpI2SMn +t0dtpOJeU+LbdnQ1IApUGOh2+vdnnspnVfIEo0Fxs3/XqFvqAzvCs/WIvGUO88qg +zkoGZVMBD38by8glm1g84qRsWDRAiiI7V1eJAlQEEwEKAD4CGwEFCwkIBwIGFQoJ +CAsCBBYCAwECHgECF4AWIQS7OLEVSVW6FH0jn7b8Kn3BbE4hVwUCZCd7MgUJAirF +EgAKCRD8Kn3BbE4hV4h7D/9ZrvyTL8xzc8rxDvSVYx9JtIXLK+h8Wqe+bv0wzRQO +vNm/fA1k2b4kIGjpV4a5z0NL2sp5b8H5Ndu7q03QOJM5BxeeepqE08G0hyyKPU59 +rIZZGFuqxNVQBMhJZltHb0raeYx0OOKUBjTVaz/hxarsJJygFZJy4+6k2s1btJHv +4DxY1gp/QOdL5jDvKZi7eZv42JYniuJQ8HrLPD74w+6+X59gQFR/jarcrL+5ScY1 +nsLIcVZM8uC7wpasDrzhHIpMSppm1dG4D5q6IkNK7mW2dw+eCN3TC/0wp+xyNGvt +lve3T91xPoeYoIIIcnvkCDYy83EtLnRqL/EhbzmkGlmhsw7FsQZS0hFOekWJhVjm +HvYjLxLn0/9t/pqDOmWcjL2iEqiowFiK8wzTPX2zQVZazb5nJxQZCCFqCP8Pvf27 +ZGt1XPWWX3llZTUkGOre1JOivwDlIHlRnSWH5KKbHGMy7iRATVD586VHohujpYo+ +iof6J9UdbUZ19HKVhxECBOEc5MFFACTA9YSXhxIRdIwkQcZZnm1zUkx5TGJy1sD7 +JyGzg3Xki1Yj5O3JyTQ8JyiFnkx6ZlFP4IkijFcMcnBswazZX8oyWEJ5ov3XPK62 +Izgg00skxOsIn1VwTDfOkrWy0xxvoktaLFD0tOyMK8lC9oqc9q4ya2M7mUN14AIG +N7Q4ZHJvcGJlYXIuaWQuYXUgYWRtaW5pc3RyYXRvciA8aG9zdG1hc3RlckBkcm9w +YmVhci5pZC5hdT6JAlQEEwEKAD4WIQS7OLEVSVW6FH0jn7b8Kn3BbE4hVwUCY93s +WwIbAQUJAeEzgAULCQgHAgYVCgkICwIEFgIDAQIeAQIXgAAKCRD8Kn3BbE4hV1QW +EACoDUHS7P1W1oXmgd8sT6Lf2F3z/3i0jxYsBnWUil7mQ998onzkmTedgUCX11Fl +yRhlzWSwSJBhCK6XDm375eyw8c+pJS1VAgMJZkWIzLRzubseLNhCa6f4+Q+IkYy4 +EozC9kmVf6E7cQV3en2WP77WE8XqXeQthd/0JWgg3Puus5HcsUCUDPV+i70uEY1+ +hh4DfY3eV4+we/3WlIJEHSptHPgHiG+LDEES6iyCAZFA0+4P0KN15vp14gou37g2 +JqgljcXchzPHx/XTXVNPClrgWgei2kMzXU5mEVa/VQkurjvbCtG9kj2EqEaRTi7b +fQsNFI4SfGFfyx0lX39l7m8kKEGbtsQo9GqSIXbVRpb8m7e9Tu71NQZdf1Ws3ZpG +L6hk7KJvu46DxmZ7x6OtpZxZFXUdUbES6EuqG8eH19V8pa6/uGquA/+mOfeMe/JH +df4IaRrYQY8RpvZdxkZOsMHGM+ozLeTb7xs8m5jrRH6hWcNDP9ov+pBpB7HV9RUe +rBLnZalLuEi6kplpy2qA5LwxHg7JnboihI004uPZRbOq75YcTLhnGz3l/1lJivAr +AYQjnfRxc0SArtRXg37KsnIaBv9id3L1zLa8jpmUSensIgFkzwYvb/Fey8hhtYSO +Rr57lNPLzNaQKUdXMsS04AHTqq222Yr12ZTIunwfq474nYkCMwQQAQoAHRYhBIZw +biKH+c/MtgAnyX/evFKULLNTBQJj3fj6AAoJEH/evFKULLNTChsP/jUK2qdVH/Sq +RgGn7xaCQ27BINtdCbtFpM/vk+KvIXTBd/XkqB28u+E6tK6fvBKtVgdzIdsw8wwA +A8HKSqe7yc9Ox10tyMUEmEPIcS1Smn7fwAJopcVBMUoTFfwK1BS5JkooCxhj4VMd +jQ4nrnh7AkUmSw1X9aWpaPVgqX/2hEh9WwiKM1yqq3lM4PtBJW+YZuYY3wxIhV6K +MSS4sG32J1TeTwOCDYdVpWV+lAwqX3d8PPn3ORiowxC9Ks4eN1tfWW/waSEKAlJ7 +K+6LDFcq0wteMaxcyENC5zuVEaYyzKWBgNN2XBGsfoOJQnU5sLkG3G+esVw3gb+Y +pv1v2jf8Q2Q7cyTj6tWd6fMMYKpwAwnXgxrZQ3DzLmJdsKQBHY2fTlChecF5yKxQ +FrfkJSJ7icvzcX3PyoG5HiTzTVsOlqqBcwOKo6YRWQoHOSGaDbwfXuOuKM22nGJn +Jpl4DUzUFeNrUTpmgJXMsRCGvaiWmRpANEwtGfiPjs/oXV8SqzAMpJDDok3OvHJj +ODsNjizsKrVOeZiZaK03a87ke+S0m9I67k+6N1j8npEOSqOapxxzQGvgtLfZKOIs +0aYEHfacxD1ZYh5nehkHCpYxZ9Y/1C9Fr8NBPkgRYZUvmHGzW6/5HZNbiTJXfpIX +wfuDSLREs1qkru0NRCGaENcBnswdCQWKiQI3BBMBCAAhFiEE1Byj7VswJ1z1oBsF +WtJCEcBg0cgFAmPoyYMDBQF4AAoJEFrSQhHAYNHIL2AP/31RUJGnB5tLKfZAHhsa +EK2iwwm7MfrbK54BVLWyAfKbXnhkHPadyi1pWMi2GKHlWRFNxLXH0sIvz0ey+j3Q +o6z3z3lbH+5hzr2sy0crw6D4DUo5ZIEqsPBdBiSMpD/W/r7lelkWJS9KKiluXcHM +d+m2BcCbJNQiQQNw27CLDDQhBeM4twegFYvAr7OmvW0sfiaKJkN8yrCsyEUk2cVv +/ODvUuijmERXjPpPAAvweQbdDHR22NgVCqQvq4MFvK+BOyGS5NTUJbaUzxjx+Ofh +T4QNpNHDuzdw2QO4Wfm//M8Vt+VZTD6gx/z14+4au8rbwlA2VyO+Zv8/8FTuOdHE +Shp/r+H29gixqPV/w4V/zkmGyqT9H1SKzh7B8T2s+kkzlNSXJ2VLUEhmOUSQveby +tVJc7tiBa5buuyATNeqeCUQ9topPI9iIsoHbm/QbH3IBGDrCSSOOVWaKAWZIRuvf +wVdbH791RoBPTltvZmbYtW6PPuvOLCfna9pZjPVzfaFAjIqjXta+ecqZw1BpncKD +hdxNEI7Ass/x295SX8HAmFfb/EXWYTnQOTYTI/9vzoOGNQ+ceCkUEGzWfajqBRcT +K8c7UAyVsXDsoH3ebZ0HBU852rvs1NKS4ylYJQ6uBHxPvv1m9fCZl9SoXo0FDP/t +YicXwn8yh6Bh16SpcDkS0eAYiQJUBBMBCgA+AhsBBQsJCAcCBhUKCQgLAgQWAgMB +Ah4BAheAFiEEuzixFUlVuhR9I5+2/Cp9wWxOIVcFAmQnezIFCQIqxRIACgkQ/Cp9 +wWxOIVcIXxAAp+BOYi3/j4ppl+22i/zL8gRRioVMjWPpK3n/lk0i+Ic6crVr/eJO +nhiQajzjnvtrYGCqXNzw6Tosw3YWbdgu/UO8lAnUQzFocIi5tlwC92cljsiFpfgw +tn+szfIXSon6W6tkX1U+q5TCQT0JVktGClpJmyHhuFTnbJcQQ+/DE2lL86OT3kGS +95rWQvgxDv1Reu+Drd4zdJ9yrZO03/scEj9dTa6M6DjBIsrjt/AW/lZD/qD0wBiv +WyoK55C5qxkaMX6dV5Nsiuo5kjltWJ8krPZcSPU5NIFNV5qVZb3dyqL04RsGwyP6 +eNEcISsqekZE+iap5PsCCMHm8jFIHJptGsKsQJ8Wqq4bosKmMIrs/Ekbr2YAfKCB +5OWrU23epg9NYPBlTATOnLm2wpDA0dg01scXexVQZMOBeTe8qU1R8SZA7WDcdqIj +XZuuCTpruvGfR7GUv/OypSmEUMNVQMYcSvYHPPeObCF/HNEVeQgyP5Y4LDXzBotT +6SAZzTnJnW4GRmlAO3OF9+pUcNc7F7sxLZqY1KM0PeDiy+zQmj263dMWydQ9mF1p +uqGzh63Ccj5nI52sQnfLpICqlpAAAhxZQDVXVookBpVf98KgThyPDrMmaAgkQ4Dm ++ncKcREyVunzKeLu/D4XZJTSVjTG6Mj8UtGqsxcljmHi5eziktXDSym0OGRyb3Bi +ZWFyLmlkLmF1IGFkbWluaXN0cmF0b3IgPHBvc3RtYXN0ZXJAZHJvcGJlYXIuaWQu +YXU+iQJUBBMBCgA+FiEEuzixFUlVuhR9I5+2/Cp9wWxOIVcFAmPd7GgCGwEFCQHh +M4AFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQ/Cp9wWxOIVfgsg//ff2mFVqJ +zyq+2q3QM8touieAr/tSEXHU7/B5ZR3JnBSg3f080lN64DkGjrxap/adAcqHntop +LQ+I+rGy1DTKdsbIXQNz+x+jNx/tjbNoGrtMr488a7ceAfY3z1+pZD56mEEZbFWy +mHHumN8ru+hhgeqHREv79RgFANy2mD8E0VRxdMZlCO0L2zzC/5vYS1Pr3kcvmZjO +pXHvLqOY4xYAJfO9kkjvsS0L79ozE0q8XJMjwygUu4GGp28VKEU/1nl8KeEWFbbl +PDTYigVvOkEFvethCmXbfq8gMGgXK7a0Fd6yKyAwxS5vu4IZlwt9UT+SmtwsUdvh +xIUOK5DKtebOlScAnfJ9R73ujztieGYQIm2Ro3izK4SXeTXV9XSXKip+dZJ2y+iX +AGxBd/bYQklYpMaKteqXY6wHkVZ44abNB3p827zs+9MBPogd4DkObqqkktw2xfwz +u+T9FgOt0V4skYrjzTwLXDzOt8KaNAn3YJ9h1pCe6VrcECfGQL1R3epA7G0f6/aV +JeagDG+0Ip6QbueP0o9ha/rxHbljTTcluS6dhEcofepPTA5GrzsTe8qvL8FyTOMy +vh0jdzzt/mAnWVIRG8bOHawTJOsmp0gkA8Ax/z5Q0bBVAg2QW8o2hLxsXCeYU9MD +qjS0DnGNqdvoLlXDADvskoxIb24lb7AQw/6JAjMEEAEKAB0WIQSGcG4ih/nPzLYA +J8l/3rxSlCyzUwUCY934+gAKCRB/3rxSlCyzU1RMEACOpC3XmJJOft1Pd+XJFUOV +rXdTrVlaItzeGF0xp2qHmjXPPWUhmjeXIptF59vBIAH2hlIwcnxwykgz7QOvOM1O +JlzXauMt0FuHCzny2piX9SW0l91gwHI1cl0By8fp19XFc5mq6lE5+3E8PSKB9wg/ +zdbTeYcVNF6KJxrPMnHQqRnW8U4A0TtsYCSJEpwYylHvc48OCbHLgY7vDKs4IxDt +8hxbNjlTndIS0/O5yD+F+W1V2Y2oiCA44z034GIYN3EwbPr/K+wjq6AKPZQMWNnO +GwOuS596N1qLwQz/DgxAZ5Xe/ev7QaVC06PcrtPVtnGwtxbnUuKNr78WvA266ljY +1GVITXQzDkiEuCPehBYCn3OEMekUGjMLX+7HnT5TRWbiZm4TYgbZuK5OMGvFeW6Q +4oW3ihuLGvPniQSGaHxrpqZ0+saD4lWML0UgFCcEGlsKlhzrguChsJoUEkFhiawR +vrOdUKiVczMBsQFXkWlDEhqX5+GoFz0SUfzYM9ngrlCrpkje0G7oCOiInlVS66kl +EdgPJAr4+wP7LTb1hwfneQoMzrtn19MC6YAAomlTYQxrO+mr6FdLwSxEadPCci4Q +fFEvmowb8shy31i3bPVT8MRIUuPBosTeEZFdKB1wKzDLwqoc8LPvfubStvJiQUtt +zb+ZP+7ZMYd00D5Yu43ns4kCNwQTAQgAIRYhBNQco+1bMCdc9aAbBVrSQhHAYNHI +BQJj6MmDAwUBeAAKCRBa0kIRwGDRyFbPD/9Iuv8Zh9Ikop+D7kqvK9nE6VIY65ep +pEpQvDzHSwelVcXbBPJKw8Z/E7TxDh8jmtdBrPGDD6BQe5eGOyhMM+e+gaOCkxbJ +WWORdGs8FyyF6osFVx+j6R2zQGjfQ9yuT+1+XsOXEWACAeIAwKcUFI6EjIFlXfG2 +m09SuP3Po7QwSWv4nmQEgQ6Rz6xOm72gtkk01rKhZ5x5gTw5A0alzQ91bmxpxvC0 +YJr6fhRHX8gkQRq4x2ADITijidVWKR/+AjWq7203zX0CFpMIxSdIK89H6537fiUX +ThzOxwhkQ/VhkK4Yn6QrzWrMljj9JWr1VBM45DGwtwk7pHYJklOqMTTFi3XW8r/M +kVovgHKNuqcJLWAxEIq09lyNI8ONwARyA0rNrwhu/l71kzagJXrwwTuGBRrK8u0c +2ve2YaN2hrsbFB0PZxsgou/rZks/KPSQXc23wnS6PsU2BQItaxjpjtUQy/KmMMBd +vAGs4rW3+1HVRXBf1emyBo88NbKTKiQNPTGbnSDbzGY3CewpGRgfBdNyilyvWt/A +UMZqjS7WgfjrBpNx5LgOCAAc/mJc1mOPZkrHTYQFbhnt2a/BXOcTNo0zG9Dl9p0N +P5YBkRcGQFFnCZAe5mS50tpd3eGMJPlsGWJy1UVEpT95W9mZepNojd7UKmhD4gey +JQqL0RTS8SoEHokCVAQTAQoAPgIbAQULCQgHAgYVCgkICwIEFgIDAQIeAQIXgBYh +BLs4sRVJVboUfSOftvwqfcFsTiFXBQJkJ3szBQkCKsUSAAoJEPwqfcFsTiFXL9sP +/2/B7IOvXIzhy2uWbGMKPOsOK6DWTQ661C/v1orieNitnVIae/ZUI9CaHK1FwKvy +cGHlWY4stOAuu/mlm/XOkGrPl2u1SduXu+0+IetedPXKLlCi+/mX/WuLq4+odRs0 +FhqQ/J/y15XYg/FqV6SyZ/NsU3CFkGo4Zb0v9Gvgmfu5eBlg5Tk2cx/6fTTHmPQu +A0VW8t48Zsu5oGhMwv/JK+B8SfoFSFTQcV5ZKaidooo9Ar4uSNP8Ybw9Gu4oTVkI +EP2iIxT0DGzgAwkUDmvy9vwvD3Xyb0FnGMwUWFQT6NlZifZmQtlmwNWIA5mTvm2Z +LHbedtXSElV7xISsM/w8zoToldeAFcteHiGjEp8zQ6K3vDT0qWTcq4jAt/fsOp8a +fN5sIGlTD+FzlPk91K5fORwk5GtbrdOlb3RMiO/ctKQ/D/dUolWRayLuac1OD1Qy +K8U2E0hbdjJFpWhBL/x1Oiz9XzuNKGIqZpmpGTQipYx8M8eSZHWl8lS+LSKkLk5d +1Yk2pvkyPbfXadcJFR+uV0C8WBab5A9uys5xIMQNkDz64tACVWsyfZQHejgmK4o5 +YUpVyhD7FVEnJYnHIShC+NPs4HcyTxv9p+KaagMfpkGqkNMqWXmrHpEh26QE2FPd +OPfbFopippbVzKRzVDyienhPvpXTM2BXtL8RZh7uh1EDuQINBGPd7G4BEACthzk8 +MLvNJi8RXAt9ffINHO5Q2h2NYJXQKfAVP7xzyS1pU8ZyJJu8ugkEEqpGXkhrooxC +RseMnV+qxqDhQC5X8+p3q3u0qVSjH0rn87JzqhvpDykhrTh6X4U1mR1NyjCcSDaT +TAyF92JxerdAcFFrWrGRjqMraH9+lm3wojCGSy6JVMMdUCnzf3rCskm7FK71AK12 +ND9jsYwtyQMQNKchEBU412Gs7sUNS35Wjq6i2xTOH5q5Hg6MftCCStThGcAr1jNF +iotH1m7+IMkNtX3o0dDgcMqifz5110+S8sCqu9XxKwCTD1xGUQ9DRTJofUd5CjE3 +pt2yCzMGRFMXegaO7RoOD827iCOV05/kMjpk4Ei3JDeLVRd6X1OxLWt9L6WpVdzm +Hzmj5YptrOxD9QCMF4MJjP1XwD6Hml162N6gogNjCqq2j99rKjF5J6gxZl4X7gaO +8gZE4VCcDvNrTmwr3Uj4+La4kYo4AAMjeJs0e589KmwX0V1hlk4/SdY/kxcY5f2e +rLVaH3n+B+vSi4WBy87x/+aH5sJkhSnnJGYATGL6nWFN1tRGgRPFp6NDlzcbkoum +DnlG7scPBMA+aOhOIlnzuj4ZF8ieg9m72qOpk2r83xKqyCPCO+F3FnyDQThrAtZv +yqp9dwmoXonZj7o6AqNfLUi7jlbRmxeLFP+XNQARAQABiQRyBBgBCgAmFiEEuzix +FUlVuhR9I5+2/Cp9wWxOIVcFAmPd7G4CGwIFCQB2pwACQAkQ/Cp9wWxOIVfBdCAE +GQEKAB0WIQQ7502xTgTfJdRdErbNAkXbujHYZwUCY93sbgAKCRDNAkXbujHYZ2Rc +D/9Jx9w/b3EWUJRQFstUCL91nEoZue7rrmZKVBQoWOtNZ+GJoJnxtWNj1YJg+NsD +9vsXVupWZN3v1YoS66bCmPzzOtYpGzzl8HD+X62zMkil+eoXl+Q1yHtwDfsugr5n +Artcn8pGQ4OMosyrVfgQUjiSAkO3B7M/dXt7yjNzAUJdw+5zhhsWQprtTF8x7BuK +fVF9z01D69Lx++QodonFmAIfRo8ah09Z7xq7xbhoYlo4M/JwP1kRtTUoClfJ/CPH +cTmX+zZs06Df2wXuVNfshhccpWUvztKpPaY2LfKeIrUCpDHICy53Ff1yayRwSuUk +DvIugsEefvwK85VD5P0r+hvrti4bryqgwkmOGDvwTva4nI4xGORneWn/8jmQ7aG4 +U0M9ImlxDt9VVHk+UgnfwTxSYRlwj8MxjToPi1T1JAhetoF2jxYuudme2I6d1vIF +nK0cyhpQrjEQvw73yl2gkkRWrlE3DbJ7pUL7ciqF7lAIz1SyvFqZZFutqS0AxG9j +cbHfjTdtv7loOG0Exx3nrJJmCC9BIgB5sHfHSts4uQmM7uz2s3TDK32Adx3qy6Zk +fKW9pDqQKU83VCEyYVU8TCe3hOVMolSmoZd1F+ig3EnM03/++knotsuPQ2gXfoJT +852L0EvlpnRoWdyC8aO5HWYtqLkQHkZ8i1AH6qiIX7c2YrU2D/9GS1hdqed+ujbJ +hrmssxBEA/+SMdYduPo2RcmMe27GphD6IifOepoZSXh5auvssltWJw5vgIWtCUt5 +IiwIWF25I3oAA429WcbJaY6jV5x8zGDNaRp8c9JY2iG3bfii9guJTuW2nmEoNc2g +el6R+GG2FKoM89/Nk5PK35fwKpJQybR2yCtH4+XzJs9jxoNt5oWU/WHyM8j9jnzW +D4dHLUOnR9TuqeyIsQQpGEZ41QKMwyVrj6G7LXS/z9QSi3tjx8ALF4dxWNPGfwZS +w2ccXCnOleUtyqBku5YASyeNsaWCtk0P+Yyl2s1x4hhLxAKM8TNINakfjFz8sVvf +7azDlv60GI3o1esm2rQVMpNfxMt2hXY6wumQ2LI3PfzbKtP4dfQ3fV8+rXOSmlIX +P3Oj5EUgauZKaxC79FicZcILsNWBmdHcdA/L0YP2dV4Nq0HBJvAe7MZyv7bHbD2c +PzbkMALNsEeVZITJKlvI5x1Dq/sBMrVWUNHOVFciC0lhZcTjxb/vh6QZ1QJ1D9p8 +GpVBZT1g+Y9U8NdiuVKsxvV65enxeYGgfjcChL3zJGxgKKOgEHsmQ1W15FA+io7W +CFcHRs3yX+5N1RaIyY060HZl0rWPsSwEYzRwg4y0Y9ta/NJpvBgFePK+TONUAykS +O/Qv/C7It+EM6UQpcfUCm+QV9ZGd+IkEcgQYAQoAJgIbAhYhBLs4sRVJVboUfSOf +tvwqfcFsTiFXBQJkJ3szBQkAwDXFAkDBdCAEGQEKAB0WIQQ7502xTgTfJdRdErbN +AkXbujHYZwUCY93sbgAKCRDNAkXbujHYZ2RcD/9Jx9w/b3EWUJRQFstUCL91nEoZ +ue7rrmZKVBQoWOtNZ+GJoJnxtWNj1YJg+NsD9vsXVupWZN3v1YoS66bCmPzzOtYp +Gzzl8HD+X62zMkil+eoXl+Q1yHtwDfsugr5nArtcn8pGQ4OMosyrVfgQUjiSAkO3 +B7M/dXt7yjNzAUJdw+5zhhsWQprtTF8x7BuKfVF9z01D69Lx++QodonFmAIfRo8a +h09Z7xq7xbhoYlo4M/JwP1kRtTUoClfJ/CPHcTmX+zZs06Df2wXuVNfshhccpWUv +ztKpPaY2LfKeIrUCpDHICy53Ff1yayRwSuUkDvIugsEefvwK85VD5P0r+hvrti4b +ryqgwkmOGDvwTva4nI4xGORneWn/8jmQ7aG4U0M9ImlxDt9VVHk+UgnfwTxSYRlw +j8MxjToPi1T1JAhetoF2jxYuudme2I6d1vIFnK0cyhpQrjEQvw73yl2gkkRWrlE3 +DbJ7pUL7ciqF7lAIz1SyvFqZZFutqS0AxG9jcbHfjTdtv7loOG0Exx3nrJJmCC9B +IgB5sHfHSts4uQmM7uz2s3TDK32Adx3qy6ZkfKW9pDqQKU83VCEyYVU8TCe3hOVM +olSmoZd1F+ig3EnM03/++knotsuPQ2gXfoJT852L0EvlpnRoWdyC8aO5HWYtqLkQ +HkZ8i1AH6qiIX7c2YgkQ/Cp9wWxOIVf2lQ/9HjHnP7vSRZG/h9FYusOFeuQqSfvq +/H6klSQcAY+5L6j1WMDCZFaR3gegwchSzjWLqIK6mbfFU9MEWkxv4XwIcuO7QWzz +yROHYFdna28/H2oDgfBStFdlmt5Dh5utq7NGf2k0vrnGNqCJGbsDyfiPZYVTp91z +/elvYBCwP7Fm2+kyDo3XLz+P7H3tfG27c9hAwRUzwbazLzDOfj/PYYonSYWjw8WS +z47YJZuIGIPF0qZCA9AS/vGkjNplwXFaRjnm0slMeJkUxRePdsvzGbyNai07jvXu ++sZNgDs2CBbA7R8fTGryNPOSmcSdl+lw5gEZd5Z9BI+6KCIOt7vD4vmDzYC/cO1J +GpQVLGIaOt6ax5C48mjSwZ6uyWaMWwugR1EPm6Udmb/mYFDMKrS36b+xWo9tVkhG +CkfqcyeZ4RidRKupgsKFjsbNCUaVAAzl1VpfMXNbBw4WlsP0wy4EXmv2o0dJP6bx +XFk6UU34Gg1oecGwx5QAsc7VA5/D+DjfbKrCMpeSXkLXcyaCB8lVTfBslE6JsYGu +F4EuR9WXz8cPgfEhZu9LuS5A3iMHGdqRUTKA9K0Q+oCiuXVMV4cCW1ge3n4pIoUz +UexrzOcpaSo0Hw8Iv0yGjYpyRH/twgeSKxHV5MTvstfWanLpMVSYUTdTybOMpR8i +jI/CBRljvmvfRXq5Ag0EY93slgEQAL75xFEavlkDGqvrTQcE3ONkLE+3CNKd+r03 +2VMejRncWEr2h1p1IX3oPqyF+bh3thWMzbYqgpoEqaoXjibQ4tHuPgBWibTIJVqV +9WgnsjRsdDWpN6JiabtMunjgBtfYRlU/grcO0JZsmkHG7/pv7kP6QeXcL7BIRdpS +Pg+chmgCHpwiSOiE5E7N4+5dzwD9NabjGT03XBAovM8Ej4t1tiXJSnQuTQyPuQBw +jRVSFRW4NW0jfEhipLT4iEoulWFnysNv/9qOkYrRJnCZo6LLZYuBpZp4Fyt0tSs1 +VJR632AqmFLKwKKiCXqMrrjpA/SEMAhGM4aypLaypVakfEIaeqxK1v3FLap4PGtH +7NG8Gk2/AbUjGJo6tDiaOMfdsraPSVpiDGlkluVuJI10oN7Q6RjTPeltqurgUVsy +FXG8Z7Jr7dGi7rw/A/LxTbm14a6aSodICNE+GzhED8hiUbzjKfh0AfaxMhTXv76S +586SBIIu+HeL1mfo/tEwRrHErmaNTBm/ME0o2b835o+eCpXlpMOeQpmmK06VwD2N +hr2r5hbzJcCrEULWpT04Tpf/r14RxhPN7M6vdO3rbYZ2FzIIlp4s5/C7a9WeeG4I +TYfoxW2lVTxXWEN9FlB79bfn0uTivBOPAC/JjSCw4b86iq0UgP96VjbRn8sgBf5a +fRipuVlRABEBAAGJAjwEGAEKACYWIQS7OLEVSVW6FH0jn7b8Kn3BbE4hVwUCY93s +lgIbDAUJAHanAAAKCRD8Kn3BbE4hVxPyD/wK8XBQU3wKzMDgoDqkA78Euf6RzgBU +UXTd1t5WTmRpmjXEOqMsMHWCDHDuqa03rqdR988DC/Q2Fx3tlrgoMG6XM+NBg2oS +ZymPatxXelwG4gSU3gahbB2WwVEOH7rBrbjuHQPeFjZ/aCd3a6AVbKwMZLC0cPbS +MtiqjCNrbzL6988mQ+Cbrwta1Mgo06sc/1pSJWwBz5I1mJSuO3b7Uk04XpmoEF90 +qPSW3b0cWwY+Wg1JuCcrWKdN+8MYco30vQtg+TKQpkNws3HtgAhbQ/p4ThmmE/3q +TPWWGYOwFJUWl0NQxUSLnDtMxuS1jeb9qSdHANMjBFIo94MSzUK1MwDGvbyxVwLW +UmKQPzuf4LBgWSrKzNBoN+2LlGXpSMFTwmvMaZZMrgp1di+dXBWnEgD7JkLt2YQA +5bXq+MRG0RCqYl2glVHorQULPwUGPHVZqnZCVBzKrlIR0/AI/n3GnTulkvLTXTr5 +bEMPglMt5QXmqRn4zN/g8ZHc6iBwp7UuBELvIbW0VFBpw87lyxeCgWb4sdSH444Y +KJprJbqyAA1ALEYnK+O4IEkGub8Bk5fv9i2WcDUwUnex9Ml2OEjkppuzK0D8Qs2L +xtBVUeBsyFgTlib7GMPsHLxBhj7zNm4W8ghOwwM2Zrc3kZknoAZ9T68u4h0VOvC/ +LGRXKNqGSJV8L4kCPAQYAQoAJgIbDBYhBLs4sRVJVboUfSOftvwqfcFsTiFXBQJk +J3szBQkAwDWdAAoJEPwqfcFsTiFXcIEQALWU9BXjjVDT4ArLWL7Kgv0fJ9DlvZe4 +zsVlAtI9nuq5mE+5gnxeUyWFYdy6yww5P+0+UrwAsJZhOBzhBpN9zcsGy9zabpau +mI6JdNR/KnYhG9jxRW5na+xI+pAcybehfgbrLlKhbjQCdf7q3TBAXrKjuK6RdxJ1 +9AsvWcRTD/BVVPOhX3TPIrdAGEW46FVVUdiX30QQzkMkH+moso6yCgxCya5zuoqm +2IxnA4DeT7uYDJcfJfoT1kXUwRjNn0biAxQJ9WECmFw1V0vnuo04oFEfSS6Rok+m +0BHbilvn51Q3Tc51Y3TfWeAPDQhDDicYmI24uGmtibgLxW56UTvrQwALUGduDbw/ +rtRmDBPz8B2sq8xRI9jL/YHNlfX7wyc9eq4Aqr321V0euS9D+NuRN0hiQl5Cxrp+ +Y/7DWxwYFViWZWAG41LdimTFTwHqYwSsZWnq+wb/ptlaBw6kuq/S6GI70bbWo3hc +fLBWmZoNapzzPIgbQZjfJUE1xeHjvcn6D6UMKaMO7hYE49Mt+txBLF4wWkFSDTtt +sUz5MThcmpXnRI8jjmB8K5EdU32OKe6MtH1HroP+1XnmAL/EHc6iGSEypDE6892F +gLGuIVbMq2tpm/n/uDAuN074Lsw+eEcMZQR2kuAOKChcIKUHR9+PCf8TzBqjk0OF +nD/NDE2SMKVtuQINBGPd7MkBEADOf3ZAlkDVu7YwVPN3Oa7rcq3oUaxhW2rxFMD7 +E0LuFSKKhHeuDe7pg/CHhKTZe/oYl8CxcrTUSdXja3PVF+tQGQTGgmyr1EoSW8Md +ood3bEJgVdxAl8P7MB35ETDUPovI+ZovJsKJKwC+RWuqIaSH3p9nOLn9U1IfsMS2 +s76/n0qQ1yvXhjjR/1LrXa7woud0l/VbeFfX9ClYnRNsDZLHckmbJTfo0p1jjg+q +4PHOcFX2pElqULiEKaBv4Kl9iL7OltuOMstITHQ96wanraUhqj1/lLCEM5LEg1yM +wYkWi8U+bu55+qEGdi/Mi3TYiKsyd5qJT5VWH27DyNHz0L+cuadf8u+32i/47Hnp +whzPHosltTuoBTSnZFE14mSy74VZx039exSNQDiotcsIT87G7ZvxsRY5RhJBZkG2 +5fKi+uBDx0B51uCDoiYvOzCyXs0XuA43DXjj7ObXzcYP43K/dUhxHlIm0FqmkFaB +Zh6f+UfVMalFqwzNvBTSTXr39hn2F9Jf8UB784kv5KXO2PY5yPq0vNl5VsaTAjyN +/pkr6LsvcwS+s2v05VwSmJhYB/prYT3CMbWaMTExH9++uLRut8wDHr80uWkSHa2E +Y9OhhtX2vIWJiQWDOoYmMfB2adzVxgUbhQrwQQe76A6U/G9GAlOFezVFopUroTAj ++pOJawARAQABiQI8BBgBCgAmFiEEuzixFUlVuhR9I5+2/Cp9wWxOIVcFAmPd7MkC +GyAFCQB2pwAACgkQ/Cp9wWxOIVeeDBAAqR6Ic/o+D59Xn3cmEvtcdJ0cU15M95mk +SDhg/SzF4MFEmWYnTYNFBJhBp8VWnA4owI5+CAkITujrBkBeiujtvm1pQtTBQvN0 +4M/So7SA2oc254dc7XTytolyeN9hYOJIuA6n2N6cwjjWWz7hWfQRXbLAt49goytc +oaF3WCmiIjmqx7YihvfSQ74LoEDzene3KEN28ge5abi5FDj5IpYxO9z6WgMQAv1z +5ja0jfz2tdUs/dNCenLSo5UbzARxF0NSeugWvzGiATPXGJWJqdMawZW75FCBvkFE +w2WC0CLTC/MBLRjL6jZOUDhN5OjtAHXWO9bzkY6RRF/AgO3LrkZs9WBc+xG0P1dB +TadP+O0eDcyL1DOECMUT8n7gijBYqLLO/WTeFA68IMyvqJE1eb7+KHJbFptTBSal +NSbj8E9LcuGG8DvIkxPXe3HtvGiyVRDvEMvOhy8wK8AuAXYJpNXz7j+EVvyD8jik +y0SBd+1xXFkhRTrhWUSKeTwKYyA7tEihj31yZaWqAhHZW9V+vcDUfzBu+2OePFvV +Dcimv9ABQN855sRjdzsJN0v5EXSmwJMvEDbMciURbHyb1BKpxWTP3EUdgSRhGIrK +hIoXsduAM77N/aU0T58c462lyK0YRpK3qYVzNEyR5vdczrXnlgfqXwUv6v/SixTA +OIExTHBoeeeJAjwEGAEKACYCGyAWIQS7OLEVSVW6FH0jn7b8Kn3BbE4hVwUCZCd7 +NAUJAMA1agAKCRD8Kn3BbE4hVw+jD/4uQMAak2E3uxt5aZEWCzae30RRHRkKIvhS +s52Ad+T2kYT0z37qIXAEX1Uz3GKLqCws6OKYecbqsMc2DpPej7r6PeoEio+qgpJP +dLsAd+pL6cGsa8Y1x6iGzuRKLoG/k9+EXLBQaEillBpBC+CL0zv5u0KoPuL0jRlZ +Mv4/V56EvL6kAcD4T0dg5FWAZTboM+jp1/ByX/rzyN4TLO0Z5sfaegPIz8eBWyjb +0wqVY7UBGQTpJ8xJ4J5mQlxrYioR7Qj7NCD246nHVLq3gpPgcARn9ORiGRSpheby +xsZGXRBq5mpAIHRQ2vCGtuxnQ1TcDyDKVWDxXzdDdSLPnrDO9yrCC17yeEVIrAd7 +OA0aPXhglVfTxFbZwFNAnQbqG0wEqtviwYzjI87DdVxWovZJefZdTqLNWGFjgelD +GDZCVt5WH1nheAVjMhLzh0r6IX5MuBhGsYv8CmA3CB1NTdNa4cQIWcFeVjnAE4pd +0cY7IKVT2IXv/+gp+Qwr1xPgTKhHHkar8uOMfjwkhYZlLBQN3l7i0DocsytFR8XW +3v4EDw3e1zQv7+g3IeyAdJrBg5Tx0WX715vlef7YwgSS21RBkx5rUyKo30XTTm7F +76K+pUFvpW3Catvke+hYX6BMunBkxliDKUMKRrrTt1Umy+uituhf5HK6U6AJc8pH +ntGkPpd3Ew== +=kINb +-----END PGP PUBLIC KEY BLOCK----- diff --git a/dtc.spec b/dtc.spec new file mode 100644 index 0000000..b3b10a0 --- /dev/null +++ b/dtc.spec @@ -0,0 +1,98 @@ +# +# spec file for package dtc +# +# Copyright (c) 2024 SUSE LLC +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + + +%define sover 1 +Name: dtc +Version: 1.7.1 +Release: 0 +Summary: Device-tree compiler +License: GPL-2.0-or-later +URL: https://github.com/dgibson/dtc +Source0: https://mirrors.edge.kernel.org/pub/software/utils/dtc/dtc-%{version}.tar.gz +Source1: https://mirrors.edge.kernel.org/pub/software/utils/dtc/dtc-%{version}.tar.sign +Source20: baselibs.conf +# From http://gibson.dropbear.id.au/ +Source21: dtc.keyring +BuildRequires: bison +BuildRequires: flex +BuildRequires: libyaml-devel + +%description +PowerPC kernels are moving towards requiring a small Open +Firmware-style device tree as the only means of passing information +from bootloaders/firmware to the kernel. This does not require a full +Open Firmware implementation. DTC (Device Tree Compiler) is a tool to +create a static device tree, which is adequate for most embedded +systems (since their topology will not vary across reboots). DTC is +available via a git tree: git://ozlabs.org/srv/projects/dtc/dtc.git + +%package -n libfdt%{sover} +Summary: Device tree library + +%description -n libfdt%{sover} +libfdt is a library to process Open Firmware style device trees on various +architectures. + +%package -n libfdt-devel +Summary: Development headers for device tree library +Requires: libfdt%{sover} = %{version}-%{release} +# Provide previously used incorrectly named devel package +Provides: libfdt1-devel = %{version}-%{release} +Obsoletes: libfdt1-devel < %{version}-%{release} + +%description -n libfdt-devel +This package provides development files for libfdt + +%prep +%setup -q + +%build +%make_build EXTRA_CFLAGS="%{optflags} -pie" LDFLAGS="%{optflags}" + +%install +%make_install PREFIX=%{_prefix} LIBDIR=%{_libdir} \ + BINDIR=%{_bindir} NO_PYTHON=1 +install -p -m 644 libfdt/libfdt_env.h %{buildroot}/%{_includedir} +rm -f %{buildroot}/%{_libdir}/*.a + +%check +export EXTRA_CFLAGS="%{optflags}" +%make_build check + +%files +%license README.license +%doc Documentation/manual.txt +%{_bindir}/convert-dtsv0 +%{_bindir}/dtc +%{_bindir}/dtdiff +%{_bindir}/fdtdump +%{_bindir}/fdtget +%{_bindir}/fdtput +%{_bindir}/fdtoverlay + +%post -n libfdt%{sover} -p /sbin/ldconfig +%postun -n libfdt%{sover} -p /sbin/ldconfig + +%files -n libfdt%{sover} +%{_libdir}/libfdt.so.* + +%files -n libfdt-devel +%{_libdir}/libfdt.so +%{_includedir}/* + +%changelog