From c1031db7bffc07d21db5214eb7f002908a7c36b3837d618c0b90f94e8912346d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adrian=20Schr=C3=B6ter?= Date: Fri, 3 May 2024 15:49:07 +0200 Subject: [PATCH] Sync from SUSE:SLFO:Main libseccomp revision 85b6518580cb2f7b3d6ba6b7714f291d --- .gitattributes | 23 ++ _multibuild | 3 + baselibs.conf | 1 + libseccomp-2.5.4.tar.gz | 3 + libseccomp-2.5.4.tar.gz.asc | 16 + libseccomp.changes | 364 ++++++++++++++++++ libseccomp.keyring | 720 ++++++++++++++++++++++++++++++++++++ libseccomp.spec | 157 ++++++++ make-python-build.patch | 595 +++++++++++++++++++++++++++++ 9 files changed, 1882 insertions(+) create mode 100644 .gitattributes create mode 100644 _multibuild create mode 100644 baselibs.conf create mode 100644 libseccomp-2.5.4.tar.gz create mode 100644 libseccomp-2.5.4.tar.gz.asc create mode 100644 libseccomp.changes create mode 100644 libseccomp.keyring create mode 100644 libseccomp.spec create mode 100644 make-python-build.patch 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/_multibuild b/_multibuild new file mode 100644 index 0000000..d59c13b --- /dev/null +++ b/_multibuild @@ -0,0 +1,3 @@ + + python3 + diff --git a/baselibs.conf b/baselibs.conf new file mode 100644 index 0000000..1bc928e --- /dev/null +++ b/baselibs.conf @@ -0,0 +1 @@ +libseccomp2 diff --git a/libseccomp-2.5.4.tar.gz b/libseccomp-2.5.4.tar.gz new file mode 100644 index 0000000..8683cb2 --- /dev/null +++ b/libseccomp-2.5.4.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d82902400405cf0068574ef3dc1fe5f5926207543ba1ae6f8e7a1576351dcbdb +size 637228 diff --git a/libseccomp-2.5.4.tar.gz.asc b/libseccomp-2.5.4.tar.gz.asc new file mode 100644 index 0000000..ccde5fb --- /dev/null +++ b/libseccomp-2.5.4.tar.gz.asc @@ -0,0 +1,16 @@ +-----BEGIN PGP SIGNATURE----- + +iQIzBAABCAAdFiEER6aPzjfH1wJP1l4RNWzmLCtSQJkFAmJhXrEACgkQNWzmLCtS +QJlfEhAAmj2Oa4pLZj98t5UOSxqrO/yWzX8dvtSmAAIAcD/jvX+lQ9Pq1uO5SMHq +g0jsLy9tqGP4zEGg7743bmrJ8GjW70jH4153ENJIqrvkIgeP2/8diyAQ+x7AZ0z9 +O2JEGmA1xI+u9q9vdi6l03viwQUqm1EBokaKnPwQwUEN8c96EFdWIcK+Bz0qUTDW +aP5TejKH9Xnlc0PVK6o1anmOdl+J1pxwptnZxW9dF29MMuQD2pqmfGUvfOlRXXy8 +a8qqlDL+iCEwBSRRvHJ4FEsh3idSGIGhqUX6zEXMHUe5E6AihCJ0aDSutXgvmO4F +aNFiUFzx71S31xvDxJKCwsTol/ObHHI1Df90VbkhsI4DBtchF5qLXfdEDaLBpo1h +kOWP6Qm5FOSEAhYKUPnIdsz+0yBbFzs/XMEyxtIdp9NTcvCPlaYa70KZ7kHISZ3Z +yqmhU6w5aQCdWSKK1mgqZe9QJ8y/9XHGOr+XSQlc6eAy27HfMT1dakTTsOf7Nr+L +z5IvkyDqfFnwL9k6CiZ2sB8i2qEWV6jR4o7k1JFQ8qXr7sw/ghZfb2jPgSlFcerm +eCUJwTKg3cZLLz3Cxwq1b8p7jtGfbFYniug+IJ3u9KuM1kUGmUAAhNfLCWdXhf36 +n35zutoYBK5kY0zWDvAPVg9JOHrxMx9u33ypW9Tq7oMHf0O8sPA= +=G0np +-----END PGP SIGNATURE----- diff --git a/libseccomp.changes b/libseccomp.changes new file mode 100644 index 0000000..9af717d --- /dev/null +++ b/libseccomp.changes @@ -0,0 +1,364 @@ +------------------------------------------------------------------- +Fri Jul 1 11:33:22 UTC 2022 - Marcus Rueckert + +- fix build of python3 bindings so that the debug* package names do + not overlay with the main package + +------------------------------------------------------------------- +Wed Jun 29 13:05:06 UTC 2022 - Robert Frohl + +- Use multibuild to get python3 support back + +------------------------------------------------------------------- +Sat Apr 30 16:42:48 UTC 2022 - Jan Engelhardt + +- Deactive python3 by default, it's just not a good idea for ring0. + +------------------------------------------------------------------- +Thu Apr 21 21:23:08 UTC 2022 - Jan Engelhardt + +- Update to release 2.5.4 + * Update the syscall table for Linux v5.17. + * Fix minor issues with binary tree testing and with empty + binary trees. + * Minor documentation improvements including retiring the + mailing list. + +------------------------------------------------------------------- +Mon Jan 17 11:08:28 UTC 2022 - Marcus Meissner + +- buildrequire python-rpm-macros + +------------------------------------------------------------------- +Thu Dec 2 12:09:38 UTC 2021 - Marcus Rueckert + +- reenable python bindings at least for the distro default python3 + package: + - adds make-python-build.patch + +------------------------------------------------------------------- +Sun Nov 7 13:23:22 UTC 2021 - Jan Engelhardt + +- Update to release 2.5.3 + * Update the syscall table for Linux v5.15 + * Fix issues with multiplexed syscalls on mipsel introduced in v2.5.2 + * Document that seccomp_rule_add() may return -EACCES + +------------------------------------------------------------------- +Mon Sep 13 08:19:30 UTC 2021 - Andreas Schwab + +- Skip 11-basic-basic_errors test on qemu linux-user emulation + +------------------------------------------------------------------- +Wed Sep 1 18:48:49 UTC 2021 - Jan Engelhardt + +- Update to release 2.5.2 + * Update the syscall table for Linux v5.14-rc7 + * Add a function, get_notify_fd(), to the Python bindings to + get the nofication file descriptor. + * Consolidate multiplexed syscall handling for all + architectures into one location. + * Add multiplexed syscall support to PPC and MIPS + * The meaning of SECCOMP_IOCTL_NOTIF_ID_VALID changed within + the kernel. libseccomp's fd notification logic was modified + to support the kernel's previous and new usage of + SECCOMP_IOCTL_NOTIF_ID_VALID. + +------------------------------------------------------------------- +Sat Nov 21 16:59:46 UTC 2020 - Dirk Mueller + +- update to 2.5.1: + * Fix a bug where seccomp_load() could only be called once + * Change the notification fd handling to only request a notification fd if + * the filter has a _NOTIFY action + * Add documentation about SCMP_ACT_NOTIFY to the seccomp_add_rule(3) manpage + * Clarify the maintainers' GPG keys +- remove testsuite-riscv64-missing-syscalls.patch + +------------------------------------------------------------------- +Wed Sep 9 13:49:55 UTC 2020 - Dominique Leuenberger + +- Do not rely on gperf: pass GPERF=/bin/true to configure and + remove gperf BuildRequires. The syscalls.perf file it would + generate is part of the tarball already. + +------------------------------------------------------------------- +Tue Sep 8 15:00:01 UTC 2020 - Andreas Schwab + +- testsuite-riscv64-missing-syscalls.patch: Fix testsuite failure on + riscv64 +- Ignore failure of tests/52-basic-load on qemu linux-user emulation + +------------------------------------------------------------------- +Tue Sep 8 14:00:13 UTC 2020 - Ralf Haferkamp + +- Update to release 2.5.0 + * Add support for the seccomp user notifications, see the + seccomp_notify_alloc(3), seccomp_notify_receive(3), + seccomp_notify_respond(3) manpages for more information + * Add support for new filter optimization approaches, including a balanced + tree optimization, see the SCMP_FLTATR_CTL_OPTIMIZE filter attribute for + more information + * Add support for the 64-bit RISC-V architecture + * Performance improvements when adding new rules to a filter thanks to the + use of internal shadow transactions and improved syscall lookup tables + * Properly document the libseccomp API return values and include them in the + stable API promise + * Improvements to the s390 and s390x multiplexed syscall handling + * Multiple fixes and improvements to the libseccomp manpages + * Moved from manually maintained syscall tables to an automatically generated + syscall table in CSV format + * Update the syscall tables to Linux v5.8.0-rc5 + * Python bindings and build now default to Python 3.x + * Improvements to the tests have boosted code coverage to over 93% +- libseccomp.keyring: replaced by Paul Moore key. + +------------------------------------------------------------------- +Fri Jun 5 13:12:29 UTC 2020 - Jan Engelhardt + +- Update to release 2.4.3 + * Add list of authorized release signatures to README.md + * Fix multiplexing issue with s390/s390x shm* syscalls + * Remove the static flag from libseccomp tools compilation + * Add define for __SNR_ppoll + * Fix potential memory leak identified by clang in the + scmp_bpf_sim tool +- Drop no-static.diff, libseccomp-fix_aarch64-test.patch, + SNR_ppoll.patch (merged) + +------------------------------------------------------------------- +Mon Feb 17 08:10:13 UTC 2020 - Tomáš Chvátal + +- Add patch to fix ntpsec and others build (accidental drop of symbols): + * SNR_ppoll.patch + +------------------------------------------------------------------- +Tue Jan 7 15:07:23 UTC 2020 - Andreas Schwab + +- Tests are passing on all architectures + +------------------------------------------------------------------- +Mon Jan 6 14:23:04 UTC 2020 - Guillaume GARDET + +- Backport patch to fix test on aarch64: + * libseccomp-fix_aarch64-test.patch + +------------------------------------------------------------------- +Thu Dec 19 23:06:51 UTC 2019 - Jan Engelhardt + +- Update to release 2.4.2 + * Add support for io-uring related system calls + +------------------------------------------------------------------- +Wed Jul 24 09:37:26 UTC 2019 - Michel Normand + +- ignore make check error for ppc64/ppc64le, bypass boo#1142614 + +------------------------------------------------------------------- +Sun Jun 2 13:10:42 UTC 2019 - Jan Engelhardt + +- Update to new upstream release 2.4.1 + * Fix a BPF generation bug where the optimizer mistakenly + identified duplicate BPF code blocks. + +------------------------------------------------------------------- +Sun Mar 17 10:06:38 UTC 2019 - Marcus Meissner + +- updated to 2.4.0 (bsc#1128828 CVE-2019-9893) + - Update the syscall table for Linux v5.0-rc5 + - Added support for the SCMP_ACT_KILL_PROCESS action + - Added support for the SCMP_ACT_LOG action and SCMP_FLTATR_CTL_LOG attribute + - Added explicit 32-bit (SCMP_AX_32(...)) and 64-bit (SCMP_AX_64(...)) argument comparison macros to help protect against unexpected sign extension + - Added support for the parisc and parisc64 architectures + - Added the ability to query and set the libseccomp API level via seccomp_api_get(3) and seccomp_api_set(3) + - Return -EDOM on an endian mismatch when adding an architecture to a filter + - Renumber the pseudo syscall number for subpage_prot() so it no longer conflicts with spu_run() + - Fix PFC generation when a syscall is prioritized, but no rule exists + - Numerous fixes to the seccomp-bpf filter generation code + - Switch our internal hashing function to jhash/Lookup3 to MurmurHash3 + - Numerous tests added to the included test suite, coverage now at ~92% + - Update our Travis CI configuration to use Ubuntu 16.04 + - Numerous documentation fixes and updates +- now gpg signed, added key of Paul Moore from keyserver. + +------------------------------------------------------------------- +Mon Jan 14 14:16:45 CET 2019 - kukuk@suse.de + +- Use %license instead of %doc [bsc#1082318] + +------------------------------------------------------------------- +Sat Feb 24 02:53:57 UTC 2018 - asarai@suse.com + +- Update to release 2.3.3: + * Updated the syscall table for Linux v4.15-rc7 + +------------------------------------------------------------------- +Sun May 21 22:31:41 UTC 2017 - jengelh@inai.de + +- Unconditionally rerun autoreconf because of patches + +------------------------------------------------------------------- +Sun May 21 18:07:04 UTC 2017 - tchvatal@suse.com + +- Update to release 2.3.2: + * Achieved full compliance with the CII Best Practices program + * Added Travis CI builds to the GitHub repository + * Added code coverage reporting with the "--enable-code-coverage" configure + flag and added Coveralls to the GitHub repository + * Updated the syscall tables to match Linux v4.10-rc6+ + * Support for building with Python v3.x + * Allow rules with the -1 syscall if the SCMP\_FLTATR\_API\_TSKIP attribute is + set to true + * Several small documentation fixes +- Remove service file as we are not based on git + +------------------------------------------------------------------- +Sat May 7 23:11:02 UTC 2016 - jengelh@inai.de + +- Update to new upstream release 2.3.1 +* arch: fix the multiplexed ipc() syscalls +* s390: handle multiplexed syscalls correctly +- Remove 0001-arch-fix-a-number-of-32-bit-x86-failures-related-to-.patch, + 0001-tests-replace-socket-syscall-references-in-15-basic-.patch + (fixed upstream) + +------------------------------------------------------------------- +Tue Apr 19 16:00:29 UTC 2016 - jengelh@inai.de + +- Add 0001-tests-replace-socket-syscall-references-in-15-basic-.patch + +------------------------------------------------------------------- +Sun Apr 10 22:31:15 UTC 2016 - jengelh@inai.de + +- Add 0001-arch-fix-a-number-of-32-bit-x86-failures-related-to-.patch + +------------------------------------------------------------------- +Wed Mar 23 16:06:20 UTC 2016 - meissner@suse.com + +- updated to final 2.3.0 release +- builderror-k316.diff: fixed upstream +- i586 testsuite fails, disable for now + +------------------------------------------------------------------- +Wed Feb 24 10:11:26 UTC 2016 - jengelh@inai.de + +- Update to git snapshot 2.3.0~g96 +* have libseccomp build with newer linux-glibc-devel; + "multiplexed and direct socket syscalls" +- Drop libseccomp-s390x-support.patch, libseccomp-ppc64le.patch + (no longer apply - merged upstream) +- Add builderror-k316.diff + +------------------------------------------------------------------- +Fri Sep 25 12:14:37 UTC 2015 - dimstar@opensuse.org + +- Add baselibs.conf: systemd-32bit-224+ links against + libseccomp.so.2. + +------------------------------------------------------------------- +Mon Aug 31 15:09:16 UTC 2015 - jengelh@inai.de + +- Update to new upstream release 2.2.3 +* Fix a problem with the masked equality operator +* Fix a problem on x86_64/x32 involving invalid architectures +* Fix a problem with the ARM specific syscalls + +------------------------------------------------------------------- +Sat May 30 10:20:06 UTC 2015 - jengelh@inai.de + +- Update to new upstream release 2.2.1 +* Fix a problem with syscall argument filtering on 64-bit systems +* Fix some problems with the 32-bit ARM syscall table +- Drop 0001-tools-add-the-missing-elf.h-header-file.patch, + libseccomp-arm-syscall-fixes.patch + (applied upstream) + +------------------------------------------------------------------- +Mon Apr 13 15:05:05 UTC 2015 - dvaleev@suse.com + +- Fix ppc64le build: libseccomp-ppc64le.patch + +------------------------------------------------------------------- +Fri Apr 10 16:52:55 UTC 2015 - afaerber@suse.de + +- Fix some arm syscall constants + libseccomp-arm-syscall-fixes.patch + +------------------------------------------------------------------- +Sun Mar 29 00:28:59 UTC 2015 - jengelh@inai.de + +- Update to new upstream release 2.2.0 +* Added support for aarch64, mips, mips64, mips64n32 (BE/LE). +* Added support for using the new seccomp() syscall and the thread + sync functionality. +* Added Python bindings +- Remove 0001-build-use-autotools-as-build-system.patch + (merged). Add no-static.diff. + Add 0001-tools-add-the-missing-elf.h-header-file.patch + +------------------------------------------------------------------- +Sat Jul 12 11:26:10 UTC 2014 - meissner@suse.com + +- updated ppc64le patch + +------------------------------------------------------------------- +Wed Mar 5 15:13:35 UTC 2014 - meissner@suse.com + +- libseccomp-s390x-support.patch: + support s390,s390x,ppc,ppc64 too. bnc#866526 (arm64 not yet done) + +- disabled testsuite on the new platforms, as there + are still some failures. + + s390 32bit: passed: 3823 / failed: 91 / errored: 43 + + s390x: passed: 2410 / failed: 879 / errored: 68 + ppc64le: passed: 3914 / failed: 0 / errored: 43 + +------------------------------------------------------------------- +Tue Jun 18 01:14:06 UTC 2013 - jengelh@inai.de + +- Update to new upstream release 2.1.0 +* Add support for the x32 and ARM architectures +* More verbose PFC output, including translation of syscall + numbers to names +* Several assorted bugfixes affecting the seccomp BPF generation +* The syscall number/name resolver tool is now installed +* Fixes for the x86 multiplexed syscalls +* Additions to the API to better support non-native architecures +* Additions to the API to support multiple architecures in one filter +* Additions to the API to resolve syscall name/number mappings +- Remove 0001-build-use-ac-variables-in-pkgconfig-file.patch + (merged into 0001-build-use-autotools-as-build-system.patch) + +------------------------------------------------------------------- +Fri Dec 21 05:47:29 UTC 2012 - jengelh@inai.de + +- Make 0001-build-use-autotools-as-build-system.patch apply again + +------------------------------------------------------------------- +Fri Dec 14 17:13:12 UTC 2012 - dvaleev@suse.com + +- code is only x86 capable. Set ExclusiveArch: %{ix86} x86_64 + +------------------------------------------------------------------- +Thu Nov 15 00:49:40 UTC 2012 - jengelh@inai.de + +- Restore autotools patch (0001-build-use-autotools-as-build-system.patch) + that was previously embodied in the files in the tarball + +------------------------------------------------------------------- +Tue Nov 13 15:40:20 UTC 2012 - meissner@suse.com + +- updated to 1.0.1 release + - The header file is now easier to use with C++ compilers + - Minor documentation fixes + - Minor memory leak fixes + - Corrected x86 filter generation on x86_64 systems + - Corrected problems with small filters and filters with arguments +- use public downloadable tarball + +------------------------------------------------------------------- +Sat Sep 8 03:50:02 UTC 2012 - jengelh@inai.de + +- Initial package (version 1.0.0) for build.opensuse.org diff --git a/libseccomp.keyring b/libseccomp.keyring new file mode 100644 index 0000000..a0fa211 --- /dev/null +++ b/libseccomp.keyring @@ -0,0 +1,720 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBE6TSxkBEACy+4BPGoI7vphGh/q5WET0lmU7LcDwuNs/satPRH/vPoSYLxYU +FmZ64A2zA4/imlohR+9VMfEVgOX6f23vZWheC2Z12bCtK0/cGLfoGMddFi7mg6aV +hJeAegYkC6hDAYI+Mc/mt0fYvDB+bSPUCUdnB/NegbWegJMJur2pc0/nQqeeoRdp +sazOyBEs4ipP1p05DZA/MifGNRASMHJg2bYG2FyC48Vx/xl0B+oactTwPODJlkQS +n6+yYTcvYh7wIbbainEi0jBnyRj6bi6jODPTjArW2YRzEmPEkqbBsfA/HYEpH4DR +IyZIJzqkP/+P+F+BVBjPVz4r6CWvCjnTMTlROfaUqIvfmpdKKtBDVN0Cjn6GVYae +t9yoJM5bcJK+KEp5aNmW3U7vDMG2XEttw4vdfIFc9ZEWnu2kyiltQw9cUk3ucsIH +79M4o24oVu2+J/z4QNGbRHdbxbO6c9R+IxAfiF/FAz5OhQfRHrDayfQV457cE/Ga +ZhE1AeT7EdnXFF3G1RhTTE2lomQ1TfBSK6CyIyabU7I0R2Gh0aITpAE0fP4heZNZ +zA8vPggdtRzgKgu4tC2is2Dg3NQnPc+k4mnU07LwmJuxCluN7pNhhlhtJkNWnA+a +C2sV8zIicH7SAwmGoeMkp1kluxcdp/jGKsdRIfIDnVax4/t6VPL2+lKQzwARAQAB +tB5QYXVsIE1vb3JlIDxwY21vb3JlQHVtaWNoLmVkdT6JARwEEwEIAAYFAk6UdsoA +CgkQp6FrSiUnQ2pXJwf+O4SbiPM1Ip1hIUe170rrTk8/Z8GoqA//RE/npcg8g+yi +7ZuxxF5TG8hn1KrV2ib+8TkGgNiaimmWgS7EFgrBpMAeXkpXTTZrK7BgW+M+RqvK ++A0QGyY3qG/aBv1oc7eFh+6pAxnrrkCEOQutu4kIz6X4wkm8N71HuZxbOrSM0w+Z +NfRzHXaMB/7Cdm/8CG/7ZI5nNF3AaQTzPxaPT8buEkX+ermaPw6JrjFgKcOOfC3j +PjFPnFSS7NMnlauKtn2Ub5b+CMHn7qa9VFKOGHFht63hF4cYFgN+sxLeHQdtZukP +xEWslW37jeELF2hFdyFQYvDzxHgSeJknZLVi9+S3sYkCHAQQAQIABgUCTpRq+AAK +CRCO8hA3lMrMZetiEADG+EsHX/R8YxWCvoCkZJ5jAOlm5Qac/yKQM8k+HpSXVoBI +W3kQV/OGTDQcv4OFXTAnXpL7IwOa85sF1uMd0+YbnoZ48oABLx0fQwlK+RhCLimK +QIAYpoQiWxaDg9HmfaJ/FVIJKafHBItiZC6TvAxGrjCc2SPIS9jA04EpM3emq74K +gxyDRSi+UyXf9wwqdoDF0naiUGMDmacG9Vtgye3UJaJ/d1NxvuAQFREt0Xw24SIU +ZeR7WKnDNwDdAgsLuP09BORSQOyOdu2e7atyR6yhJRQCDWV0kcdumF74qcBHRWLO +D8R2C6incJ9Kvx9sesh2/9WHPX6IaSHKMLcwn5F0FfTt8ICsjwC5ikXsoOG3dzm2 +ohCkAgBvas035P+4Gb//Z41R8MEWfiSNRGV6KGcmlp4kE6ENIfIiJ9XWDz0U9KvM +XKGsdc8Q3O0BFQ4B+N4BLEvIT37b3LErAQStjZre2LU/Z8EEJeqe45Ywntf/+BcS +MWPjUC2atNT15Jkzm37zaXaSJy2zPDyJZC5LfVwedb+4Hn1pfd6q0JK+RChMQLek +7AublOsfAkw543tPn9n1nrh6f/fIRy66muLux7+JVCXK5U7gH8ruSyy799anhEB0 +19k4MWJNU2eOOrU31YzRvX+1HyuQT5ZcKELG/icCVASy0bP1grBNNWzC7fRY44kC +HAQQAQIABgUCTpRxdQAKCRCRc49z4bdooDTAD/4ysjSNt+Zcb+qBV2cyLZ6Su9I6 +6Cflvm+ENfjMzHHaj0XVgKbMbc+J/m1+Cy2BSdifgDi2ogzEOhLyb/cZk6gcpRwA +NeKeQ5phjMypjyqCn+AJzsCnh/NjWLvuSHAgrmzSkH53T/dD0Q4WGy8kgjWaBOBB +LkaOABYT1wwJFsTfZzIZGbe8s5gFl0ImUeU0u5v5nSpmDmUQ3TTaNcs041x0+9zX +JG5DigalkCWyrlmdjFmyEficEXev9Hdhi3VkDpP5D5S/ggYoi74cB5SsQNNyTPWO +pWEusk0MGiPvmP2suefRswQOGX2IOIDSPqAR5TbCt4szQvknRPgDUL/C2XkkFMfu +d/GjVRwfC/zrazneBPfIALXSHK6cMr6/iYRt/s8myqxXdLQayG5cBe/+cUs5HVie +EfLuKY5joImqQF1FQ0VbFXxiU3K8brDL8FSBaECpE+FfxqkaKh8ROh335VAhfff5 +FnpxSqC1Mo6bDy4+R3395JdMhFnuLOh4YTt0503+F3dpA3ylnAdFB5Ck4mm5Rmhq +QIyrZwptDQx5ccxZiuiFpNVvU1h0ypKaBM7ZmeJLwpPDrz7fEf0vqaLCleZuiHnP +hMLJnhzZglXdpWGrNeoQ2yJ9Vp6RqV1RyU5tVk+JvcjoMMyWpHTghBbeuBp+lgo+ +Q7Zy/wVcMNfjUj9MPIkCHAQQAQIABgUCTpSo6AAKCRB3vMzDCGukeec6EACkyJxj +AOSEURBMITY30yufkgzyp2ERHgdeiV8DMZkrfD5QNHe+5tczNcJA4PKT28Xel2Nw +P6fWnizud2dGFpSjW7bxaVw1SqsDc+spDNxdkLRV8Zc06WoC4pe9Tc+P4ibseo3J +P2gC2EBjK6UxrkLXZAuql/qVJ6/oHHUx9W3jW3eiwTClRGMijSKjDh8irhtJqVnU +ACMWQbXjt5NmAR+s9aiui932FHucV5meG3WZ3poaR8vgId1/RrpGDrZjI7RkDEPp +RivCgv1sERW4Us/m5eG/Cg3O0qX4ynoN7gZGJTNFP425cRPJPdF5PDv0SUAtHj2F +7wNgVwHABfuFnHehU/bQlzIJ3LU8Hcd/DlXlVjeJmJrHGLxynvf53Nh5GmpLzQ5X +zVWtr6ky3G07DTaE9oqypF+M+Cad1u8bMkwrsvT2jRPn4ZLWnqE7b17cAaLg3mpX +kmrYo31SEaFua0gtnZR6e/ql0T2zYGFcVJNsgjPpYKnE3FD9UAv+cokvm0+ag6Cm +eKUBPKcUfE2N5hY36CdVXsWzdYnU2GkiLmIMvzjSKE6i1m9xbAv7AWRS1mRYXXwN +wfehWvgm4LomC76jt4dvMcG80IuPuj/FKhJUyAECEjMSuN6Z9QDsNtxcx8+TlSAM +GPdSPpJLyUKk4XhH3Zc9WJpXcvooiB4UieMH8okCHAQQAQIABgUCTpU8RwAKCRAe +mjtfhUCDto+YD/sGICwy0dApaCMHNqDOtpPA2qNp5JwzUPdNslphrfpIQj0PKhxu +arbwmi2wKEfIv/K36qqylPWapltug5MVXYUQA22YiyMJpYNRJXU2/hI+S11w8CP2 ++SjlttWHKTrUxKen/O4Vf9cQ3Xkm2V/h4qqurc5PDF9ZTnEGSk6gH/85+u6f4T3Z +Kjoov6CdZ96WBQZYPkI1iCsANnk58Zeq76oAyWe2z+Lyr8hV9bUoUHPcZ8RT12Z/ +ydbwW6ep4nuUHi7uok8xQ5iOfe8ofSd1veE4f2R1H5VR+CoBNaREFcT2DaoHad5v +Ot39LyEIR8ltpVqrCUCPxUXZTNODoNGflr2fn9M/aYP1bRoFyZ4Q5pOg7tMiyJ74 +CHKWvOvdi1Umwk06QXZyjwx6ISf2VgWH0BLpupgDtM5WkAM/qGB/gXGN9K/JqXtK +Dz7nhZKESzO/zh+0P5JD/QVLrym3Yw8Pf2o25uExdJO8hhBY3mBlHZAmJPWg04kB +QY+CE1yMfgnmvkABXA5ION6GjGRdg9j6/2agMZ7TcG9hL1e4YJvzvZM907Wq+cEx +WVRQctQ78PSDLMdWKvJKHFfDUzn7NxPaCnpbZl1WQMI1nRsUJLrazkd31/Ho28rz +if9ML74h83Wui0GVV4WCZTL2mCZ36QCzV/uW7RLKqRPUZgvBEzzBKqCFVIkCHAQQ +AQIABgUCTqFZ1QAKCRDDUDkSr76OZ06LEACnjnNn03amewZjoQrlJuoINMd1l1jp +LEUPuY3o/gr9cS+tMTZ+u0LcrkP281OOcL4CaeSEhz958MWS1Jw9cYLxZ1nvHAQA +3LCuw4WfW/gmCckPdEOvA2mE59cHr0XLIR3hy2n+4LDpLG3mNv8nFnyp+2HUNDOo +3bqsaJ5+06IXl0IOl8HUV53hMp2adBWODJIym5vULIC0lx7/Cm5WIuG2cQVHT645 +806oOnu73Y5axsu9+41TdnxujJLogWKmOdVGxGa2w34Xyq/5QiGzw92NPytaZ77i +jiPKkGVhZsg1KJmSsJji3qqSJWXwPpqT1iVdq6LgFTmSLdBsgbxJxzX0xDyPQHNY +sLmKXEvXKpTQazLzKahnpy0NN/w4jfkfX0fri53BHWyyyaxEX7yWB6YEKIWiMHkX +FmcU53xYyXEZKf9NQOE0qWm5AvrgHDK6uWRaLjJifHSy8tFxwkNpC3fgvcGnZq2q +tAJBvHI4pNPgYeCOkryC9pS6NJi84k0aezEBSHOe19WhWiXFc+Jxb1VbrypzvJ44 +FGkaMk/sY6+NkH8hnP+6vCF1WcUMtX1h/+gqLlytR1zJ4dqJVuVF+d812DXbkDoM +c5fSegt2gonGCLa7ftFQUf50QtvJvoZNACb5R/RTDeSr82JpvayFakAy5/Tl6yFH +k8xoycVqHlRO4IkCHAQRAQIABgUCUm6rvwAKCRC8Ur+iObz/Y7guEACWIp9RRNmh +/EKltxg/pj6LzUEbpw/2YPkEtTnzOBCLLybXWiM6EOBV4Rlz+ukEBBhYgKeLHEWE +PSbU2fXb2dYhBhny/EA9+kojXX++xxQoQslkcvhzEI3+ZzmtH7320wpPMoroV0Gc +pdQb3Sb6FLqPsg4j6NsGZYhsaMMSIcMD14IfXkopPSNKHdylNS2qInERNHI/aeJD +9IsGsMqmegmjFOZhO8gqPiFifXdvjijh8oXhEnZPSC/z5ifNal4+6FppSFcK2uBE +1M7vb8pQiB3FP3fxZALgGPgg9+tg5TNO6FpbqSsnVCa1BkWyQwxHFNAT0hOKNHKK +/rdlda3yl0LNRSog4Th7l9tdAZXiGCZt6Qdk9A8tHwff66uEFRI05IWLDp4TWnBF +e916/N9LXz/LUj01SSHqN86LRzLJ00f0T9HK5IGr6hzWFIxlim2l4f9GG46d7slk +7oyRu4rHoYHZ6SOjcgZfFrxO4599nJ4EN1gkjEBtIvgT0Zdb62b/pIwAWTRt2Rgs +D1yYR8DqRe5b/r7TM/H89YXGhT6brpRsbFqVbHHotf9LJAgnLiBkk2B1cFL5Jxtl +wxIje5RtfkX61vMJLooqhWoyB3FgF+pl5IiaaGd+wXrERBwXfSRnKg5teAR9VhIF +RRTLZXbSyv/9Xx5GxTPx4kjlOPD5NH8BbYkCHAQSAQIABgUCTpS4AAAKCRAjm5tu +O7CLIhgED/9TYC8EG2Kr3HmXQej7L39GBNZkK5mb0vbuQk4fMoElUxvNP5+YHRH2 +3Ad1PIjgQc1UZzvEGiED4C4rNoX2BxVpkrTFn2NoTT8W2Np44hvxOxxA+5n2Znig +407KPWM4I3DSJifuT1w5UL9OYXtADLQVasNEBphD0wCDzf3CrwDxEYZfvj0PhwXS +73xiX4SmOD37fRjWqKxYeFFxkkMNqzSSGaMGNpFORNo0dQwCLFyLoDOrvYMDdCHi +hfn4GmyJSGPZ6pdGzIrVBtMLu6LrO/o/ymSqL27Z7IoazPGm0V/8CkcX6/+TDXsh +4SOuv7uUPs/AbVODoJvv0xR10HJpdEOe9Q4jTwLZnPOXYNnFm2s44UzqLF9jvgiz +84zUDljbCTKhGyVAv7A+Q7qieyRyrBQPTrjMXAV3OfWU8rroLO2e2EZmeK/dL2oj +SrkCI+ZMa8R4eOE4xIlU278XWvQZwpA5SqsYjInFENtNwHSyFgH9m8FahbSjMaLF +YvuREo61u3TawIew8Pzto6cPOdYPCoc6hPDytcMcCyBSkRHxdS18TncMI0dSYbgW +IPmdQoDOAc6a66kp9ZpbZsi4J115GuUBy011KNq018Vv6KM38VdAJx23262y43ma +YbkRBX8xMaI8rE/htajd/KOftwBnzrqdEKhlrw43fN2CHHPbq5qldYkCHAQSAQIA +BgUCTpTj8AAKCRDBpGByW1HLzwsaD/oCX5NXocKWQ45GnjzyFv4iz65BnQAKk8uK +W76PwVInpv2KJsS3tiU/Yit2kWsNd1V00jdZaTEyYQoUExa/YFQ5h7kM5xg+zlZJ +Y2LLhTmz83AWCNIf7f1m5F+ktZMXjgpYfqhYhyAZCU8iidQAWiDcPzs4scz5vx8c +S8Kmt/Xs8CMy0StxXMp4XHruB3fFe1X2iAhkQTG81LcXprDFCdslf5hJaXZt+Gc1 +t1B0JfzEgRpZjCVSoYgBNBZL6JBpBFid0ZZqqRFUFoT+OcQ8TS9gAUJT+zJ2Pxsk +Qx9DNNFHYFb+AbyatMdj7Ehig80hKERqdKlL7OvU/3rmSelIPmQRh48YHN76X9LD +8RDxC0lSS5X2st9+3YJjJAKxjjuzvbHWIosVv/dgWogCrbAM6pEQDE11Ph5mXqsJ +rpwDrQqH7vE7fMuFXfDfs62g9RW7fJcKrWQ0v0OyYFJOiKQw1c8tuCGdJkGLGxFr +opZWXfJc5M1BhfCBviZqzcE4Xb6zVFmHu1ecEw/AFg8xffQYN1N9ynaMUPImBcwX +pp/k9RKUK9X9VKMhaVFz225obPGfusyYl9pFAKTexWIO6k8rbB9mSbw4ulxAABYO +mJRuvoMvaTXmCCObJQT/pw3nbfvsJg+Owz3LWxI7t+4VZlSCtXYNxFYdP8c38T8e +WHlxGDHmd4kCHAQSAQIABgUCTpVosAAKCRA3QPsffFR05ybsD/9I5A46OfY8Z0eh +zHmV7btjhWrHNeGXirjvCx9HA07S5CckQK807v8vMN3czNIG6Lqkm/nEVFAD6zxV +MZ6RaC+7Fepb1rFyvC8+jE998nWaJmXJQZIsM0BTGgu1fgsQ8q6gD1i7HlRd0MDY +jBjsvSiNJWZ782L+2FtZYgcvIzD18ePx8oF4MneXfiGOuwZU45AP81R9u2tIvGeM +2bFkeI/eo3P1nMXmOmh4pMtb7qOgVwSoJrO8ALZ6JTx6FelPn3x1MmDGYMKOH/AB +b1RDw+yx5Q+NjqZ7gGdcowz1CuBukJsqlAWBB4xbLvT7mjzZxtm75itbl+hW+NZi +HhabudMg+B5sWNh0hTuSAvy9hysugFFy/ORrZ7w1Ix0CwtdBHBOLhTmSL0cF8GQl +zRXPS7fmvNdHoK6jCK1rugN5l473t4tFWmn6ACRGpyviIOeKtrXVjgGwF3c/Iz6y +xZil2U6pZ7pcAiGb4pBUPNSmugz053eplKS36wG0v1j3QNg0edLF0LKv4e0V1XMP +VJocmnDLd2WQHjCIVu5MRpeecYOUd+SDzmgNMWonT/8HLHA5r30Twc0onk881VJi +ndHazWFfeC/DAGsaJtoaJDJ0hasckRMLmrYDPqQsG2YnPxqPyA7piUFNSkKn3sLb +DYa9xgiT9cd/dG++WUDw9OlO5zAxp4kCHAQSAQIABgUCTpWZMAAKCRCes5pJXdv8 +8y07D/9W4QFrsvW59PkSOL7nFGAYy0/AoFCMMsbKdq4tglxp/H4cNmBygA9Ax2EJ +aKLhSp1cNcUUrr6GH5VU8onhNAkjRzZagegRV6ySkq4MFiBQtusdUU+GRDtpcU8x +iTUKAEOojVpaWU30InbFhtMB4zxhwDNFQXA+mPT6qx1EpnmMOzaGi67BAUekzbjz +6hDp0SZjYLRJocEv2waB3wIQSD3s+M0xNeDog94/nQ/kMNcc59KpSQ+q6uMrb3kk +/Igx08nNaMOrG5P3fyAeRih4ZLBhRjP+81i3J1cI9njCGBsk03cn8NA6Q2ZcSk2M +7QefjyE78iM2UyWLmWzSbg7yPjKo2sA4TLEG5r5jgRqGPgWX0e9i/DAcOERr0U87 +7+lILgLdrAgklN+mGDVaZUCFYkz9LdMvcZo4AzGz4ga2uFLXh5obPSo5fsjf1EY8 +9EMgZJ4r2DM8qj1jTYpFyo5VLcGCcbK5Ep1dIQ7EV6LuhDUM6hdEP8LUt/TRkgh+ +T/m9097v11UR4PfMCeZxPFkwXdSEBesZTZPOjRFw8SwLpQzf+d27PyYbT+461/m8 +LnkYuFCQ3HLkzxaSBndYUd+S+8d3ebmER6GpUMswpUL4bb+QU6TA3LuKfd8EI8Gn +jV23/AMMCVv75ATJryig6GgBytukse0EoaC21a/B8n2n4OaIj4kCHAQTAQIABgUC +TpSlhAAKCRD0h+8YWHLXI21LEACRPtdtp542Z0yiJQPIe8ozYCzUvPZQ5u7cexvC +nRITVxiW8M3gG0m8Z9VHpL4DSvntU78DadhYC7EgdunPUu1q/0IgXQyz+563CiwJ +nBrtZaQ99T5XSDXtBamKFQyPSoHQ6ulD63K8LfmPQwXxyMKW4yjbFbL3nFk8uXNc +YQEo0EWZxUC9oKOV0fw4AD5tG+SJXaAHb63lKKzZbkItW6UUFuOEqKCxAQLweSKp +ir+7IE9KLz+7dacH5m4Uy+RmIdqLgg9+qMiqROvNCi7u2nBMuDU71r9HZlitJ89T +SgaSPjEo4jayJzpnVqgFJAMTx7koFlq4nKc7hl/py781ZNoyCiX8Ru9lFCn50YHd +mHUKYQgGxZYTGCwlGQwPVdf3L5wNUwT4hZH4XbWmDrEVTw9AcgWXFyqDUXz6hdil +Gc2gCIPzB/QtEaHKMcB9VVK03pfj2jnL45cbFnpakRujzvkSDS9qyIaKN0WtxsEs +gJivxHDBYCJZTlOXvQ9YmxXjYIeMdbJdFY3AQiwUHyrXlqlh9XgRrhKs7a3McWaY +dCnt+8fIBRZyu/V/ePwNL7yEx4VFzwJTgdDu3SL0rja9OyQiYMQ1URlbJXEy7rsA +jTWIv47X9tdJzM2CBS2vAfDNaywlHKQlEo8smQX6voLJOW5Y17hQ9mAb3ep44/ZK +4GS4vYkCHAQTAQIABgUCTpW6nAAKCRDg08nvB9L4tNErD/4m2Tmpfzx/llDIhwtD +4ugpqWTyx4QlaRAZAL2Aw+9O6KQZsY1bplCJ5WcV00iPUBvf8eQuaX5wry5Ilhuk +QaKM/he+GfBIypI0DuTwBrphfknwQAjugFwqJzgM70wNhWkonKOzI4iOfl99DaOG +/Z7W6ZTo3QQ9LcrX0Gv8AXIio2KxnuPBzzLdJdhSd08gAkFyYnyWUV7kTH7w/PUF +wavNo7OGcmHCMzPHizga81EhgNSHqyV3jfNl9N1wduunxK8bYb2rOTDaEh4/zyKM +g7nCSDSM3dB/+HUe268nVs9cMQv7rSeBqtg3vlTeOB9MgXwNVWjTiD0F1I4IZxvX +3mcHXvJGgYqQflSEqvUZq+HDToq6Z0effEhDzrKe1oLEG6M/2bSVrr5s+A9NrYhw +jWP3pXymi6xV56DYoOkifyxUYJSuxOT/rEipptxcj/uMjckX8Q0cKcxOvX288wlp +6YTweUqoYrftJIiZ4nTMLv8EgDEvnSOmr83Aem4UIyaAR6P9Df7XY14VA41b6DFk +EP0cIBdoEfARq5zE+uecqkFFh9sSdoUUAwUjwn2uiA0VaA61MCZimzd5HpPpMjFV +fbiv1fzyf+lx38B6OcYupwxqkMqxs6VBltvldMziuzaLXdwF6H9Ut9CXBwHs/oIT +muvaSmYrwncNj/nC+VCegozphokCHAQTAQIABgUCTp2g8QAKCRA4cLQA65GGU66S +D/sGEph9OtVExa/eV+1K4TspYDfTvXzOoa03H6vc/XIKljY/XlQqybhnimvVBz/h +nAS2H5xGpRBXFkC7CpJ2i7eDIhgZv0LoFFYsE2ma965tz6LveCBv9GwsB6d8cmwi +M53dQ+mI62XLoDVKgkUx+UhEqfvMG6XpKzj/1CM9CuZWu959idRFwUajEYnHTkjK +vjyHU7/8pbqvyqDhU/DisiaKqYuZDlpD3nEGv23m6xNwlSw7xuRdHOij9BQHTJRR +i0V7qiFOOlacdlkXBUs/dgmZVpj67OJ0jxvR5F+beOeWJU7WmbnbmqdLQzh/ZPi/ +o8VZVMyYBjeouIuaS6MlyzCuGiFcAzVyDWcC3MGkZ7hMFJZ8Yb0MvteUxndnq35l +pPlY37d6c5Qao2laKH2TrhYESM5VXRWgb7O4+jugnPkcp+LeEeQSnZUE2Py6QwAd +l7rCKzZF5GmkKPbUmSKZ7yAudAlcExHVn4RgTXuybQQVIP0jV3KujDBSEUvF6jt/ +0pH2+ePSumIK4WyyedYhPliH1jGgMBFnNwF9JzycfkPQM2frKcuq6tlUzvhi3N0h +jEp+mlF2d8tDRV+btZ8fmwpBxU5uj1nhZ1gESamtCRk5mu4mP47zH4bTm6BbpWoh +CquAN+DCv6vUR5dQLmKR+64SOJT2pYoTJRn6Uq7ZxzLbeYkCHAQTAQgABgUCTpXZ +4wAKCRC+huu0FRBP35KREACID9HKn0NGB2Ct5VfGK0Fh/50W65fhNgaygP4p0bbK +Hca65Fh8UUW54/EphJPraW6gNzCCNKW4SEEUse/zbnUkLnMEtAHHpeNV/Bs39anV +oFmURhkltHgvc+fQ394eaVvB2R/veKNMwz6CZydRtq+YPV2bD6UFU+v5JYwYzJS4 +YRtuezLyoZXEJQy5SBcVBPmkoYIBdI87NcnJx26GPn7AHYXrZq5H14W+5ywfS/1b +P0zPa6Dzdd+e4j7cWhSUp+uubI7F4bD4AFg0b+I4FJYqw6hvNJFEdycNjmvfGpBF +mLcRE0SHephwJCXSZAJe7wHmALemhgAM8U2NlYEQQzhSvRYjtgdrN2vQrBeernLr +mEmDiyxKCIqLDW/dbEmf9RrWYcBm37vnpfG/qXsOUT/Lx0vCVTs4znUlVKZs5/9j +50wpI+1SfuDta6YNP6AVDiT0oWcIe7g3L74svUHAVKL7AsL18Odl3V5RXoCLvsOC +FGcj+3qIBwnoMvxqUxaNldF53B0yRSmMuJ7+Ru/xxEBx7aqPQIgjC5nGrj44XBgE +oAhzG9tdr0xN1Y+cD7le0EgU+1IFYizVXac98A5+Did9Ev1W4tGVkDzbMFXBM/M2 +xjYKYGF8JONW3tOxuZWnAuQwX0jnixRRS7zPkWQKvxZJJCHUcaN/dupaFYPanf7n +rokCOAQTAQIAIgUCTpNLgwIbAwYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ +VeRaWujKfIqzkw/+K3xOpXohVdmH1fqKgltyE1yh9P4vvj4GMdenOZ2V/RrC60Ks +p1lNbPnMLgDteudqbks2D2NpmvjihQ6GfAgrCbXHGbYoEgaTLucoyKdR+xKViV8n +JtImNYDeG/d0ojgWl3vGzLXkINyZ8APk19B5bsoPkjRTz3Mqx0XIYJlXTfFZuu8Y ++K2dw8H5KJ+Onb2VaYbA7Bjm01yDsy9vLm+LpmK3rzpDjCNjOaCgIMoqCTpBKj9U +Cpcmfw9G225kCsN9yStov6EtezHHVbTNopWL2p7JHef/758PE9xzmtAix31NmPue +iOP/moaOgsI/AUNlpH3u7wy/v3n4hOswItE9gB3wMT3h7eyNkrxH6EK0PRen0qBo +1ah+cDhwgdDJZoojmKzg1pP1jrfxZ7lGRNpisULR3FKCJ6SacHSmiANTr2yYU1rb +qvQJfzlxB/hgphRFzXGduZILKH6C8gddVIaCWYZeAonjfqpQEUKrb8GV5wtmb8uT +S9DI90KvTxnM9zsBR9zWEB74+JntEOSEnNBpQ3e5+O9zJ4wYehR6No7cb04MT/JV +npiLwdA83sgabJ6HvfFqpy/k+lKt+kr7KNHXdYZ2Lo9EvUgF+96tzV9e3FcHLAWF +Xij8lq2PpetLuGxTkQnjcCcj0Kpr7wUGMsiurN8AoeeDepgoDdHfjr4vSk+0HlBh +dWwgTW9vcmUgPHBtb29yZUByZWRoYXQuY29tPokBHAQTAQgABgUCTpR2ywAKCRCn +oWtKJSdDagq/CACwb2j2bMCja+VR2ypBcSgE0UrF6ewrqL0RRUZXVRxbyaAZr8cC +piGOVSAqrvJ1xAhVoEB30+RYlRt+iiY98R3leSyhhn0PzAu9WtdfdzAixmhtVtps +gDZ4t8jegT8mU1O/EBTnsTJ6aL48gctAV6XEi2HTrkqUzHZCs5qYxI4CFliniEeA +OmLFmV2qmrJXLDZqHcxof3NU/Q7b253E9TrzB79c/w28SYMi+m5ydizMyeLPE6Gx +jGu5vXtjP3rR5kp8cI4Bn93N3w4BXqpeLHXSN0GG513jwHHpvn4xE41fWsdXdbdh +T+cRFPdG88IyQp+axqYbpDTh+n91yY5qmKECiQIcBBABAgAGBQJOlGr5AAoJEI7y +EDeUysxl1H4P/3JTlyiHmTupCQrkB4bHEq0ndMNDErOTgDoqRng6twYoOEwXfYyK +7362iZ/+63N2dlvjCz2hjjjgZtl9NF+7nTEfbADSl5iXVUkgYqywbRLINQpURgTA +e7sV2o4zyPesrB7x6mPmCaTQMqLxmXEol2QckdVYlfMBwVWV53be96GDSBqli5hq +9j69lFj237EMcBf0hbbFI7V8H1uxz1Qe99vip1xf8AHPXRMnpibl5vdTfVzwR4ba +BOky+rD5tiCJsfKkopMqYMvW3rNyMBlIn2pTrWtv2JfXtOiS44W/7Ubpjg/Zl9b8 +43JvYoTNO5f2l1XS1nd5CcbB6dpv4ShLAjOXwd6MPvqa0aH6Fc3Yth8fS/gdJM/U ++jWZU5Vij5Tduhq60x0BhZ4d0eBGLWu11c+6X+Z2RAvWYpi7gC0uFu2CV4AWrqK/ +PjKhLgg/mYUPIr3nsR6ola2skL8r0Vcy3qtdo5BjS7PaWUOa2EMM+6i1qWcsnWkt +YHOD1WsoW0FaHed51N0c+qsqBs0jn7eruiMVNZUMRqYiFvxTzlKVJB0oPB1DAoXZ +B9Zrswzh+lI3spK1XBgOT29UiXezwl8fkZ2AdRqYq97EevJviFzXekT0RhVKPvjN +PmCY47MGLy+c4AdYtuum/fwrJ6JtfBG7THquTt9qhipazBPjaSF0QRbTiQIcBBAB +AgAGBQJOlHF1AAoJEJFzj3Pht2igASYQAMZjpgdFYd+371b6lCbQfYC50nQN3Q6B +dYjVtWZJfsbRNumUMwEdmhSnLM+cfawkkbiUsXr9d0/VsYD3T/ix1IsiDETLZ173 ++r0Uyn0Kl1ensF8UatJPUFzntp5A4rcisMY41MEXU0ZQF2GpKO4b/zyM/6QFqvKc +oRYMOIEIF6ua6cRNYyCT8We/ohPg8e2cOYpxjJc+6EIldbEIMYZvwoSO3hwkSXwi +v8HR678IDYCx4FfLpiGn2a3EtWA92DSlU7WB1Ehw7w8uyDRYWT9alUbZj3Hp7XKp +4piidghZYS/NVXcv6tHZX1+EgyLcblQ4yPFWb0tTwQDjjKdjMTUPa0lFoStT3cqn +1arnjCmC86ouvuzPC+7XDdEZIzVB2hzPIO+uk7gcYpmkpaCZXoC22JifxP4frrJu +hlAOmAHsX/AA6fvHFWL37SDmNhKVQ/1cFrCEZcb2DKWAJDl/5qSxYjHHaMvHq+l3 +y+/+5dsbnjui6cA0UdZNDtVqeDhRsLLI5oHXve56D8rXBXQkHPTvY8eFmITsGkzY +ozK29ZBXXvfn0Kbv5WH7GEn1kQh7GFgG6eBIBkPbbvbtzoFAUTwUC5tY0/M78z0T +Gzh2sq2uUUl2Nt0l0rtjcqzePjMslGPhOx5cLM7Dnx66oyog0ONy3MB4/CpXOMrf +m9BFVZhbDh/1iQIcBBABAgAGBQJOlKjoAAoJEHe8zMMIa6R5zVAP/2nXHzhwIfvB +xntdhOC5EoUuaPeFzwybdC/p/m36/grS98XvqqApGmA9DownHGgkTi7c5kEwdHKB +XnZC8rCcXtvMqc893YQL1VBPEPbmcWJogZXmN9ZtFFmfq7Y90OYQEWlUK2MvoAzJ +ab4wuogcV4E4HtoeHymgL6QMJoamLty5Je8d5xmiYpdM+O8+PYVI/KefZ+sYuJGy +mHecqecLvSXe1YB7HoVbeQ/DFMTIGNUrd3nlsxKeD6fa90+ogYPKw2MA1Y9kKFVN +XJRuCZXVm39pblqXdH81LpAB5G8xNQjnqsjj3iVSToY+6g7lblJc57NT3RY1p7CI +G5mUtAudBrEPrDv/j1FjBHBwMRmLbFRmcNKfKg4y2uGqDHnpzIGRarVjxjKqknpL +p9SJZHtUDZooZDrDu2Vt2oXL9JwwpYkdl7rqKwvodTkosGclHFMmIPuvJAjJ9HB+ +vNQPlPPAxLKgTy235XTyFBRl0kNL6UJlRqskbiT2VNEPGdhL30VW8UYg8eLxLTlj +AvhZD5hokRBJ7Y6ZlOlQ8Ie1s2N7zzznf1njO/3oWh9o68axK6HhbHTYPPEf0LTR +g4SMAd4YLr5oPiLS2qw7mH5wrwIxg50kXBZBCgLcPmXWYAdFuVezzsAcl2fsokiQ +jSc71HrzX8MOl9w/ePgFCbDhro2Q0sqFiQIcBBABAgAGBQJOlTxHAAoJEB6aO1+F +QIO2MwoP/3cnOUhdB7F5uLgCD7KMbDfgycPGgbRnYstWht3cWRaeC9lojnqkqtiq +qziaBgh0EbxWfZXCfJk5WEkKdLcnI2P31ptgfkA55V+sV5hXf56ewXyDDLCNue4P +KYdQKw//dY0dMpoi06t5ipxfxRF4BjlUkSu/9nQxXk4Qj3aFsdYxXzL4PyMBk+Wk ++MV29fHSpQ3GQAqrH9jn5gs6gQDF2IItuw7BiISR7UqSSIgGvNMD7bqYTQ+ew0QP +XRjF+oPIW8302tZZ3sVmgyNAQD4vaexrAgzBIQbbyo+4mXrI7ZT1dvQQxxwXhQdF +Yrr0lYIx9IlLKPvH+WbD6ynTpnngLeuf+oqWcCPib8fqQM5zQXoRca2mv4qZoce4 ++krp+UhSCvGDYNtS0hWAiaUOOCkhulT2DAXH00Q/Kn1ANQnkH0a/UFBXjtfQC989 +FuuPaiQzI2QkKI0kBEiMHFpAf/oaA72dcwN/6W8jDZrnDCHTlu0eFlVoC1JxG3QO +tRu5mIWBrFxpS9+lO7E+9J8VExBc4xuD8wRzeb+kAdYEJ9BgzCc5UJLKCJqZCuuQ +nDd/J/AVNihMaaw1Nr+xrWFGTgZ7R1Rojkdo+bsM+laT58KH1S50vXuDQKpBwXcX +nMQvcud/jx4Pl4SgZ+O0mJvFDryPlKQ+fWtzKB1GOmK/paM8HVWuiQIcBBABAgAG +BQJOoVnVAAoJEMNQORKvvo5n5OcP+wSgIxCrJAGjUQ++HTUirUfxtiaGmfegYlId +1OjAaK5ukL1UgSo/H4ORhzcMmiXiO/PEGAL9TleyEjWt2pEYKVSuwsHOQ6Y+Xej9 +yeggJG1TvBEl4IKHvxSCCriCj53srXNi36oWhqJ+60EmcCwfcA9QqzrWsoiZqhnh +b6zQ5WeTN9wt3bihBMxYpnOXRUtmgsCdCQozNILjI6pAzN5RIiAbhHG8YSGmqdzG +imUjnMQC91/vIBMsIsps0fnmSMoN9XRu7TYcPVCnRnPUjRF1/Cn3huvd6vb9q/4j +PbQ8joGL4sHtHioEqVv2lDL4aStcBJoqJ7Pg356dwLj7hfnmUt4xqxycf8Ub6JEN +BdznjgG//qJ6yzf3gUHThph+A/kIssQm5Ece8Wi2HLOAQScg6nvASapu43+s35VK +8YX2nQnuaACxeB7N2qYDtJCwjbtxaO62FsdwA/AIibFpv1gg3z0vD6tRruSZRFIh +WUhvSfNFDEkSwNsKsze3CxCGA1U/aTOkLUZtNM43OovzUvZLqWuWdQ68Mww4ng0H +e/yLB8RvGjCUOwSaUyEg/Tn1CwzVrKMXMSzoJw4yrw46J22FhVprXYtzAbWI1Ri+ +B56Bb6KzkAFoTvK4eQ6UEsvwR/Wct34YptpxwRHFUvwJuMvkxSI2fZzOXALaXAGw +lZX2B7zFiQIcBBEBAgAGBQJSbqvCAAoJELxSv6I5vP9jCwMP/3aGPUk9wDeL+Qu5 +stBZALReuyHszwd9G77e+Lqv82lRC/uxUYqgJNc8WHEz/34uIcN1bw56DlI1s+NB +7JHv2VC51nseUAXzv+tIzQ7/63InJp1Ha0TmbcQacEU1qdhXLAm2Msz/3PYaCQbm +DCNCgEqkdkxT+OGMAOCtkZXaNurVTFWDDyeisy547SN2rXzE61vv/my9Xy4NH10J +MxCuz7cP9LWKYapUJmc3Ao9DcE7MgqWKAsH4eswgxp/Hg+Pody87/dUjn2777AR5 +EQ3b1ikHx7rl76WRN0A2vx50iegT86ibp5zhq1eJuW/OMGrCQmOMW886tR9kBNC+ +tENt193ONPAlHse9v502Lx4odYhrpDs3sWUv4vcJa1fTKn0lYqGazUX9n7601BLZ +3j/lfUHsz+ll0gwxj1xa2XrNBKBYyrIRyLpCBYVkLwds6Oqf9YufkZ+JGbREDmI3 +FJJCAdStvxpKw/qQW9H0XaHAwRl4FJZNQ82KENQv3MbSZcB0GQg7Ipb+/F1fpWS6 +vFSjzRE7CxbGFtOm8eZ5vhKN7w94eq1u+4oGOFvQzNCP8Yy1k7v5Ec+IqNRM9a15 +G2BNqzSHnt9Xp0am3AwipymxRdmEPjBR7hrgBMxnpHXV7f5PGrNoZou7F2ViJOGi +9rEKr7bY53Aad3I/JSPXR9LvS40iiQIcBBIBAgAGBQJOlLgCAAoJECObm247sIsi +LYgQAK1N9XHBx0qf/a81BTFs9UsREUUVABOQnjqOwv62A+F7yVQB8vaZp5FnR1Qx +QvDXGU4Kh88DkVatfKmFQi6KUkV4tANsMtCB7A49QQAsGzFG2Gx2du47SuyNwor8 +ePJd+SNuwQ8VopEoaFFRGY4i2M7INLehpIP0F5hIwkMXtLztECS7Iv4M84785cSo +nX9jfMJqGWDKNHwpmU+IOIW2t4LO2nDxqTIrbAmTjjGpda5p8n92J3/MENNzJuSF +GLK/gFPyYOHz2MoZuD7LAfGbUwC6qZ0hevb2B94mxnk5GkSMz5q+HgZm+bmrNe+C +JR4+RlC0lOk8uj4zibyXISckTgkLRiIO9qnoAjkx2NIkaavVDRrz9gBO+tClwRO9 +SKRMtU4JPeUtlrCRf3YBFEAht9IsLhs6rBvyfEEPm0j5+PFASpK4t/lW/NPmMwXG +ellG1pb9YeQ5csphnyGOGRUcR40j8l+KYTEPdsE6KEyCDgNtZ3gbBqqmxX41EV44 +Kb6QGTf3ch9aXG26MPA/gvSt7NFnBX5ahF26DCqN784Z7JbNMuxJQMvw1P7KTzzA +Hso+Juns1nDcMgqEST7JrlaTlsuljiWTXUHFyNf4u04mQ8ZYthDkoRBPHN9Ivjk9 +Zxa0fnsWFyu7wiIm/IOMVA9bn21f6guoW/seTgeOIzf0XkX3iQIcBBIBAgAGBQJO +lOPwAAoJEMGkYHJbUcvPGKIP/19/zohAV8v0H44CKLGqAIcOQQkcWZMmT7hZNgQI ++wKt05Uxef+su/Zv77C+bqPi05IsIhjUvqnelxzMIgIyxPi1mq8hmZBLiZaalEa/ +ybHyPhthEXP5vWUWXX8Yf/7U/RmNrOjdN8MeS87s3Lrosk87iUnDg+4B0Ptj7jEH +ngHV13MlqY8dAN8NHFj3NBfOij+vygT8yKowFm60q9mlJykQ+5NARGqYJ0040ZMK +2gnCRInWjuzcqTj1NZBpR9J3dAzC0PGflfNrX4O0vddE97wts1ea6Xc23n4dppYh +pmilxsrW7sepRBXRaFcn6nMmIoifYUGY/fuQjnvEY58tzZWuf9WG7GE1ZvObixpg +a6QmSXbWgL8rNP+/qpzGerDvDFabcP/QUxHSCFc5rzq6T9j+SCt3UdCPjpjyfZOQ +pyZ7CPy4hy51QdKP29kZLMtm85bTZXhXsqrK8cvwOXTdI2pbCdDSQ+vEJwN52Akc +q0LsviBqc0uQz45NweIJSiPb0KQibDODRd9enruOYbE6Ux6gdaFqNzXL0+7JU9BI +9TGqmHA9b2k7JpgiMKhFCjKsbmjtYqPF8VB9upYThXOQmPVv+OyMbwJkh0+VrwGO +ERGwkxYq8g6Itnrh14TqQ25SDk99nNKoXFPB81/6f8Kl4cK96sR7kqW/Ca4/7Vu8 +mA5biQIcBBIBAgAGBQJOlWi0AAoJEDdA+x98VHTnB2cP/2mKj0xZKjk5TL6t/pVh +SAg38L30DfW8rWye3TEp4YAIr1R9CTEqus7YeYv514TWO9y1+qNgQXLBVvfN0oYh +K2SmD12Sk55O8SNQiveB0toKaZY777K9M7xGC9HmYhOCGThAdrbFsYdTFVUo7At5 +g2ZK4ADR9VayWSMBEIUQLPY+CwkMA+KMoP4T6gQC2YG8NgdeeYqRp9s2j0VR981+ +dBt+5rTBJJDnr5Fku1zjpc+4nSAp2Ba8CRpryY9E4SnGpQGDbZ1EpUsJgR+f1+wS +lmslSRYfddy2rU2W1JJ0h2ePZpUBjP2Sm8xaS3IaQ/iQFOnM3LOCc8XCTPeVe82F +Fbw1H0hHL2ulGijD7/oIiYEhoJ4/Hl63hzykyln+gqfCzggj+lguQi5YQYUxkbAo +C1tPmSDPfYmejxW4fteLqf0qHULXzXUGVU1EaUyDqrSgtapm+uwnZNW0RXozzc8E +rXV7Q00at1MGBCoWZFwTon4j/uZlllkjQaFmOhvNV4gAeEz6BH7ejrTtsTBK5+Fq +jqdavX5mNBORrVbOi2AoWF6UUjOZxj6+aOd4Jk3KPpOY81nvmKKd4fL3JJ9ya369 +XIn9XPV5k1ep8uv7E8ezo7MVwZsytej0N+0Eo6auSkMLQ4g4wTPLRP0SKOK31eJg +OzrdFrMtR3Dh09gEDfRaLHVfiQIcBBIBAgAGBQJOlZkwAAoJEJ6zmkld2/zzlFcQ +AIwu47WXv7geZwCrRoJhDbzDfLwmzD9surKcSzVAUtyiHq19auJ7X1N5eiRF0mJS +RakFiJ8+pmyQfwcj9/8Pt3rs+V8AsfYhVoBmAYxSaFkCTl+HtQQAJy2RivkzyTQT +iZYmxmzcp2i8DnuzGHsWZTqk/EydKlFROxW6wzqwlilVyBdxnPnDl4zqkfeZ0gEl +WqEhg8xIwVW9HBx2UlhRm1Vcoqb9MQx7dNTppDI42AuaqEMRsIZauVhcubT7OCur +Ig3PBg8dNaJCViJoIx++AP25U6XPlpmkcG8iY9C+mHAhq1/6A5jxGL/BD9C1X00x ++8YiEX7fGVJZQse64Cee5mV0v6UCrcpGilyFJYlO940JagDif49oYkwoONajMbgH +aIO8tICAkRPiiq9dLD8AT5Jl+jqSAyPbCKKJmW+mBCeUSkuTNYAZMzBKpUbCY1Q2 +PvykHgBTsia2VD2Ys9Cn3H/sf6oYieiRHgCgWReroMmX2MlM42UpqcmvOKxbn2CA +XSV+XxXKoHB/mkDzF7iDGNykF8gx7ZnDEQOksHoTc+1KVpOZKZnbB9P0F62uDx5w +gVzmNYYSvgU5H9S97X9hhDfUbDsUWVDSxIZXwIrsWb5/cM9nL1Fh73BiJiZVDc8j +2bQDhy0IVNEcCyWTs4/nsrQBKovoi58fuyY8In9ZIhkriQIcBBMBAgAGBQJOlKWH +AAoJEPSH7xhYctcjiQQP/2K5LeezbwuJNdvTqhgcZA0afyCfQo0rFdMVLzpT4NfN +5pmT8SueHRQWjr5sOKNR6Q6F/LDVZF2d8f+FrC+xmH/1MV3S0NGs2srySAJdl2wg +4YhjxLm33mpB9Gh2bMqW7Pxq8qned5CTF8itLxo5obFYctGMfK/eS7KjYcTDF7nU +BKqj6anVwxRHeyqGs4eVIJaM3WfuFQE1fm6xm3GXswfGBIu6iVkjncHqdJAZXA/+ +Kpe3yLIhijQttXBgBMrc5wDZYdjIRK3Cgp7jg6n8uaMrAOYXwR+A5oQZBv5CCuWj +qmkJusN+GwpFNhl4KkqSnMMH4C9hgd4lltPcrxfZRtJ+Mv6pBUVhaJKQNikPxTyy +b0ctXU8u9NnQHcfHS4wQXMGNEYeGBlvpeQyCIgcw2l/dX45msMidmPHv9Lzm8jfc +UcPSUAX4cunXKcnaxRZCjo/rRgluap7Ml3v0MrLNTs7Lq4vMVfQh62hD9H1qmRAn +4+Wxv52ahrlV0qg+3LdgatB6UaUYTElqEJDgcw5mpa3jh+CqaRl2dZ0d87NMeVVE +hiEhu/1EY6eT4bCK9/CuGIHsL4Rx+gyLtRekYeEtTAQrKTX8BHNyH17ceuIbSUeu +OvQ45KMjZwa+iTpH/4MZo6narpUNLC8pACkElPQezUWtsNxvLvy85rq7us44NUZ9 +iQIcBBMBAgAGBQJOlbqdAAoJEODTye8H0vi0uTQP/i/46noXtwu1MyNzETRiUln8 +9h6spDXLoO/rQVzUoGzzNLtS9uGaoDkCrt5YS2+pqOLVa0pLI7vI/Sx0MX9WAN0F +RgDjgQBofa/ziU0JkyxeDFPZ1mCBxLodU07EmrmAakQsX+XlU3+fyZWtQyWONJlD +dJ2F1G94sAkZNgjhktfEZ8wmXQFn/h4/kjk5Y8X+eex9jozKxBZNF70pkBiTkWaJ +oA5AO6S0YAlh53u/DduP7U4DTeYtaf0rtVwQZjMzbO5PQe80qB1Eu+xBpAkEluOh +rOnWrPIBnrk49b3XWPNMER1PGaWYfcmyJN12tW4aTKViU8O6MHeZADYSXyMMfMx2 +JRj1c0WKvpb1srpkZMmiFaDXiLjOOuNUhaakQDxZ4hEnFZi8fEdr6sNwk+oP4Dr9 +2HGESA+2DmImODABycZ2/cTm6ak1/eG/mBB5brF5fZkZ6FxcLW5eXpsHReA2eh5C +2A/eJory9iPOqupmJDT5IFGv2uJ+329uZuxw9bNPj1cgHlg4ept/h53R43pp2ivb +6NfV1gA/CPvhWJaTabKDKCSp7Kcu0CPj7LqH4tmZvdGVR6sM6BmsYMPR4fqc3gYI +k7hppl+7Me+fxOKNcNqJrIXit3dZKPzP92woA8tx17xDUiFtWQfiDzpIB76/Scjs +gecwYcmoQULdBPnQUHahiQIcBBMBAgAGBQJOnaDxAAoJEDhwtADrkYZTtQsP/24D +SVcAGd7YdPsElXyX8XWRe5tMJ8AmtsK76tnBfnUgcAL1pkIXWSVpsu8QMQ5qPZpE +WmdNnb0SDK1bBC9tuWvKNrDh1lWRJZdF9AWhzXqn3/Uam0OSlYD8R/C7YwI4lUDy +6TuLAAd8SW6d8pUOkLddv6kYZpyZf72ONu9z60agivNsJOpgyVhSqJNj9tBE9Yy9 +rEwfia/fBDrRQ5wfSZucKAaDaJM4ot6XkQCg5Z5xxxlaS8Gxub1VJh1zT98ekndL +he4SFhPPMfVD6cl3Snz9rKzmieNxuG8QrFXFlUib98qNXiuEqyW1fr9cm+Ytal+1 +E1ZU86HdRb8at9HctKRLhXH4VjzvpyFgytXYaGfJ7kDPQK9FaFtFT8iNUtfCjPib +VBuSLYehlry1soecikIb0Zc8xA/XGH/DOSTEB9S+6cMahqdjN6BZ1F+rBNE0Ja9s +4DQ2zoS6iUfKufNEFCN+0IQbAy5Rphn5/Nwsj3HwH4nrtS44B8sE/BbEAfFkwheA +AdbEhWijexFJjf+3Jps0nn9FBJfbAfmlppisZbwczIP6zqDaVXJzRU7AsQhYT0q1 +krpTNdmbP+f3cWvo994zXWSJYbAeBzVRsu7aJ1q40H8ICfYLlEnKk4WF/MXJ64EN +lZBQWgoMak7FCx8j+mOFJvNvNKd/Yq8OnevaTP+9iQIcBBMBCAAGBQJOlI0XAAoJ +EH/Z/MsAC+7uvX8P/RhEjSrNtjBtSXh1rxvDMY6et5x6N7MQwdwPNfTESE8MMryc +vmc6TcR0xtqQEJylxOJhgg7XZXPE9LJTDaWBR5Af7ahV5kw/fyOQ3GUcrl3DV0nb +YZm0efZ7wVxeyaphFjjz6wym7tE1BuZcYFpiavyldnhZN2fDJ8uoulAxn8MH5zkA +KqPez/Nl53EqQPl0mwz2ng/d1QZhiAMRa34Qyh6497SDrhk2e8Oz8je2rcqk+niP +tfhtmAoa8ULmNx8GvXdd5W3c6iR0J7RBVqW8qmnrJAv2SpGpvdi54bMNuI6i8/e0 +zpR5YEPaStU5oHQVO77beWi80f0eT/Vha0vXFA94GQ/SzgMy9c+YmMNFtJyGANQx +5wr+C8bwPVc5tCEiFcV/IypncRotcnKEzfqITXWPWcVI7o5XobH1ubqte3b6dRpA +Ab/Jh1jwAy90y5dACqrA1xqG5T6VoyKiOpRxwttqqI+Gyd6poAdhQYQEvyTHARSV +Yg0uk8Vvl5UgXUfXKJ2c3IE8U1Nbmpy9IoMLT2EvRXoFNpTLThtTpdUFaGRhiFnW +as5r1HPca1DAVavCxWd3ciJCYSoeNrvCUbVGCKrjRLHviUwgXzaRGzBPLXecKDtD +nhIvoe5YV0pyWfq2pXXYei7CZ2RwHLzCvYoD/r/NCLZnmZDVIYy/24c2ICWbiQIc +BBMBCAAGBQJOldnlAAoJEL6G67QVEE/fMccP/2dEjDAYNlz29hlQIlOVvV/uWmNn +okL0PNEzXhVQELx8cXqmlT/+RINGcoEhJTgmgLZwBHKSBjgxJ/6ux23XfgQKZSXI +1s+K24MZww5WSjZAVQL7B8CjhVCVw4FBAIQAkt6XzyH4q+EJSil0HIVKpCnfA9N4 +Hj/EK0JacF/UElB8+/XcwFViE7dsdhmrzNSWCUR+r9iLWUixiv/HBsHIZDcEkgEy +Q7EAZiSl7l0x35IgaCelc1e80bgu4dZgZc7sfJtOvTuXJ4EvwiWVyer2tVI7u71T +oT2XYcRSjsrUScXf0yS6C/K4+N9g3YNFF3A+vMS9v3ibXzC1pNjPtWkrqEA1oJKl +bC2Gnb5nFqbODtIiWadB20Ba0B+AjD1+b3z5MwD1VOVmbL+PkZ3P427Ghpzr9ITV +pW4/A6/YYqeLmlaj4DCm33yfkLQm1OYSA3NJfrn6V7P0gB7/Gk5Kyd+RNS8hGatz +wXZ0cQM+R0FoMJPb9+rvQauk/7Kybvef6vjrc0POTWmg6AkuW2stMfjHKHU7iX/4 +sdN5R+YAyT5Bsp9wlrY5E5Qj4FpA1+lbYfEf9CNYyIrgkz9noMI3hxwbZwHgH9sq +A+xrP0dDCYEWiNBruMR92kESHbam4gpY5KjHocsVRLLDpdv1hQ6KzujB2to+0aKZ +FRqvqrbhNfF/P1pKiQI4BBMBAgAiBQJOk0utAhsDBgsJCAcDAgYVCAIJCgsEFgID +AQIeAQIXgAAKCRBV5Fpa6Mp8iivAD/kBTsRnd7EsTIBIE409n1FMKow9KEWVKwt0 +WaZXfn6pjCKBj9F0UGCKUmbm1/68p9Ayvc3ew9aPJzs99pc/EH3hMLIYfigCPd1d +CYiBaa2VLQicVyiDthrh1YMKss0LPg216KL+gYk5mzRwxstcU/pseGdMW6B19mcy +nJi4+NsO0L+XJS/F/uA9xInjwlnmsOXv6dsZTxFV32mJbt57FFK0cHcdUWUmf6iR +OgmSy9+PL6e5n/Z0e2xgcfDYh682xN54e6H2fGov3VE5JCvnBbMa+RpLdZx3oHb9 +rUN6ZPyqEemGLxmCA3rsmQdMzLNlVusyyKw+6j3PbBSyMALIAVt6Vss52fZma6W6 +qST85IQ2EB+V505C+YNLauM93g7TgjgwdqzUa4/yb2XL91pk9SCtnd8dxNOgX2+K +MqjIE8w9s/yB4Mi/VrfssqIAdGNM8ho95Vd3yEiCDU9pp/lLbrWCKgxHhm0hLUK1 +8ciL0BFYjzudpjvkHTrXOWTH0PXXbECm2sCv6am81TET119c+YWCssf079K6AawM +4w0gSNrz9DZn880lCmdzzjmSzsRNONuQGHjROtt0gp7azljWHYMH/RH5wHDILGNi +pWtfHtuGR3QBhZiVgWMfl5ZYXiOnYlO3TmQJb7rrrJVSX7w/Isc5u0kffHpZlJOe +5MH/RTvcsbQgUGF1bCBNb29yZSA8cGF1bEBwYXVsLW1vb3JlLmNvbT6JARwEEwEI +AAYFAk6UdsgACgkQp6FrSiUnQ2q4Lwf/Q/O1EIfENNCDqmYBNS0B3SDojbQjPiDz +ZlYbKPL0R9zA3J2thIKEdF01maGYH2SrmsDrDZzeNezRnIeJRl+OMzFnr+X+dAQW +mFNIvVk8aTCLwuYEsJfS0XEL2AnrY6G2bX88Rw4XOEc+onjPQ3Kq3SdXWyIIvD86 +d3EG9LvMU92H7fPF62oHlRzgz9dZ8evWGrfNUgAVA43yBVSEBbTO50T8JeT4slfy +3Hx9vvWJQlZNtg3JxQ5hUB+qSqI11T4P3zpwUlrKJT7k6rogfYnSDDyKTz5OO50j +V2CAKKbgO9k87D/law71wLsZZ8f2lwqmIe5E80T9Jey8zbJ88WKtjYkCHAQQAQIA +BgUCTpRq+AAKCRCO8hA3lMrMZQv5EADRwSCS7PRFhXuCycY6lzXrrRexez7UNscy +NZOnyf75t7AWsPhSF8GRLpdQdg9SVdihCLq1CnSCBSsmZgo5eT0B5RPhaLKdiSx0 +Ac02SB9CwNjrRrUVIlMvyFb/kRjrOjpEE+ePWeSVcAKBetZYOuK0aTF9nRaSGZGo +dalM0d54rEo8OZNGYhW9LmVtWcaK4cel5lBZsadZvGrG8MnogEVfP5+hwwZ/qsoT +pmq9WD/WgEaE4Ysu+6/IQNElTPF6CQQLQdehUSvU48H5TrS+DJXxY90+2KWzqU3G +bzwhySxgb8Nl3jKOSIdfHPQ1B01wtU6cfiztydZYR+yeo7P2kRyOcLSwGZQc1uzH +BQoPZSPC/Fo4djsEZbjDwUYn1rWNfsyE1eN33kcNyO31Ugfhjw6glopjVZDZL5tG +i0eTg8oxBX8PekSw33Tt3d/HPNsTDTglbkhYAAq/uAvV+PEQP893p0jYzy+9QpSu +wz8lsv3Ix6q1WKz+FPCOZBpgKkBPZe9pPsDIx02PSlLhGtNa0wlNtK6gPNF/hd/c +beY47YVe45v96ZKfQBupQWzkUSGXkxadrfmkLQJ2y27/CYcyA2JVc8RkYSf0Ay4W +xPSV1c3erlBzZoFcTX9hHJ9RDoHu2iWIp7ahfu7Ax0hxM0q46fJQSo9qO0O7Axua +KfRRaNZcvYkCHAQQAQIABgUCTpRxcQAKCRCRc49z4bdooFcuEADLJXDzOqx53yRF +LeIr8NcDA2sa9DHVJpAMskriqoYLKh2qbhmxyGYcSd7infpAaw9FzomhEHRWJKM6 +nA2rGXjsSartMeOoPedqnBECsEC237/BJdb+C8li/rZkR4DFnl1mO/fdjgyMuIHq +VyUYI1zreDG4MkkvA13wpomrHN55E68mAmVrxYWu4GZsfCQf8XaC6F+3lKgCxRa2 +A6sxbzdpwIrfppxzbbqOvVoZ2FgeupxCNx2w2AvFxmt5Ss6gLYifC3v/6/o4otIs +YF2mImCu+ojHDqU0DN5wcZuDaOHtTB7fosb6hASjy4st7iQQ48edhb38wcmyWKZs +QNND4EqkC/Io4kuQkiIDmT09CAILf+YbToB0X0octY5jIo+MJyMvTv+QVs74WAR2 +4NWfA0GA7myF0H+6nrKs9bA7DI99buYHbpBNs5BLtlUvP3Ia+mgkeszGxo0MZXdO +TjUjaVGBH7Il9pbsILgxhISXeI79nv34s34ULLoIM89I6Cn74SmNypSZ/eee+Sz4 +9NFcP3A/sHb+8zJXU2hdiKIyC0Wb9kD2IGKIYo1MCrIMECgqOpilaQiQvOu4Os4U +eVJCoOVOlIvkM42NndvONDQVCU8ZzJbDIF//rx/sNAR6HRY4h4FEkqQjLPqhzUAm +a3Me95OjKrYiOR8l5zTsB0ffd4RS4okCHAQQAQIABgUCTpSo6AAKCRB3vMzDCGuk +eXU0EACnSMrh7LXUo230Xeoy+4CjZ69ZA3tdLkCB2cij7win183hdtwQo+eRfNTl +ro4TgwUUb6gjeHGjt2DdsumGtKqCqGlTNWdVZwKcW3hptF2p8hlacguAgOgCYqQs +ODcNWwj8mnY7dcSLOmkdQcq5/PwT1ufJFIfDbuN9qaPZnhS7chZnQbx84itLFuUU +dB8ycFEn6GCyfl0FM+9ukdFmK6P8g4ExpTpUCiSQfOoHL2JlsRJpHnGlMFdvpv7X +brHNPK0L+CTbKv0gqYNjF+i/DkDzWT96FsX0CqdeRQRm/0PYDgp7Ae3EgNYZElcz +KZIeOGmdVNRDqCt115LShAYivKz72WkIRUVy7Ag9YzI/9dEQ3jrX9b3BMI23kwaE +V8mZaYwx85omXLLt6y98cZZDbNLpa36eU+Qb03e2hBqveLr7Jax04Hug2g41DI26 +o69udvv5d4NTxIB1Vet8dUpwdLhPFHVEWM9+cDvhscDAydyLVzzdFZyUDGWpnzWV +wdyxFfxu99i/iTMhEMpPb5QxXv8pSUrqYy+mUdCkhJCFGfOnAwJoYiLFnH9AjgE2 +EAQ/wWWvruRrEWuMyu/+zFXXMqy+T5dRoW5UUOIXTq1q6MBaWl/Q8qWbK5sRx4QF +5Hr9YYwdXELYMnBAFXpRxwiOBqhS4HJlGKh/f2lSucjXw5NQP4kCHAQQAQIABgUC +TpU8RwAKCRAemjtfhUCDtlIyD/wN3Lzzb/+7P+8ZpW1lr98XFvTctkFi3yXnNuHJ +mKBWk10LhyN6wSdQ1H/2HvQJ5iEUgvPzWry2q9WXeVUa2u5Avc2NaomG+JayN4pw +iYPPwtw3LzH3W595t+Emnbr8aWJanDqZ0jy4iKAqxaxz3fSSONQaeAEM8IuUs3Dx +Ym/5YkSTPK4PnlPKQXsj6xk4/d8i0au6htWluGbKtB/A6a+TmFRmJ84cbwYHI1rq +3LagwDkNe344OZOiWe2SPEK+SnyL1TPwp8YsIHqc92ekNExMSke2DCK2+zXQbmd1 +u3dTqUof8hD9f/VqPsHo3wQUki0Z32B3jhRN8/0XoXtJaBqy8hUpocww5QqjgAKD +s1eN01wJi3kLSwU7YA2h61mY3T2YuI/fFaxqEAy0BXI6XdFeph7ZSjy04ZhH6Lie +foJfrebG46frdhtT2g454mwOPFcRyqmpxj/VzTXjoiVAGui71CwMnd50M5SAhdrJ +5v4wKbg/Y5GrMJwyc3n684YetFMGVwW7vEvPaXdVyLDdk4BAg7YpdSUGuUzmP2lx +fkDqQiAKPaRv6RUXJWMijoEQy4OcpX86tMbg/fIhm+hsE4Y4bbpdC66PnpfGjeTI +qXdPoQH/3WIiJg0WNXILxn4KMU/eGPnVfp7Os4NCcHtbpXfob6etLiy2cro91Kur +umefbokCHAQQAQIABgUCTqFZzgAKCRDDUDkSr76OZ+tdD/9vy8JAVvynv0WxpAlL +0S7dmzEGKd8AV9Na3S/X+ZL1MeF6Ay2f/89W7lmjEBctu1JZp3mh+iWJCDjvEALI +fo/tAG8hAORy11A80c4cR4P91lpAkZNkZfgugKpr44wHtbXp9V++ZpuXRc2R3oMO +d4AIFYEi4m7mVf7XFb3PwAN80VwT91KDoZWjOYItXUgOWMZYykkuTX9BIavuQTIt +8YpMtfgoQA8j6rtKS0QzNJajDzqI/WK2NLBYgBH+VQoAlc9BuXr+7o95Zpjdk/oY +xRltpyMbRoev42TsRKPz8aJcABgM28N/sqZm1olwYUTi01L/rIPJnb/UUXwr/fQc +uLa3EqDMQRuA1UxLjLOty1GN6ZSRQw4PjGckxiVVHCVR+FjfmvQi9NO6uf5zHDJx +5v73ULYsJvnGhO/GM5QWoVlUFg5jagsFiXU3M/5rBIflZ+CRrvR8jyEatRaxl0jl +tx46Oi0V+cqjFhuiepyBN1hB+tdp1j+8u9sbfK+Jz3ef6OgS1jXpZM/+FSiQLV5j +rkNZnIooTf/3PtomrC0a/ZEefNruyBn1aZH/nmwuOBTM+PLVTcDRZJa8TCvEOh2H +2qiCFSvn1H0m1PLNWSBNdhNYwl02WlIci+Cuex7ztcCneYMP/D54CMSwkTeUnSth +meA3dCawfxvHOrEjr4urQt1USokCHAQRAQIABgUCUm6rvAAKCRC8Ur+iObz/Y/f4 +EACvaUmu9mI1711ltiJ/Ap0y8bjBcixYrT6M0dKi2CFnYQyJXsXmVIiRaeI8UXwc +KDGQpqspQznPyzxKcjFoPcwW/uOERanqnD5MrWGaNiudIpBbsaGYNgBkxjAORqX0 +LLcl9C6Z+K/q9Elff7UlQlKeXDfxtDECJGVJ0RvvuWLbt8MfWacbxYjz83IbpD1k +pwL4mDbjaqhUwgs32GXw+9mzQ8blq7gwod2lxQ2tkIJM/dy/z/2rfAs0NjT8Ap62 +VO0VTGUFb5mmKGkgQ6HG/Tt3nZsp9CPAPBcCHQ1wFhf6Jem4yTbZZT/QwLlpmVG/ +HKh/99y3VwWqHIOKLsgZujw1MixB75Jzz0RXD6o7Rpn6DLHl/4TRtc/qZ1ApMco4 +ejqPBhnkQ3q+8sWjxyEfZFb/U7r3A7nKWMfGA4boQYlxX/uRxebIC02sPwGUNQ6y +ghc778VUKB9dq/9D5GZ0Nzviyv+RlioVI0qDMhz0Gc36C3dMlH8iLulPZlJqR1L9 +D4/3dntbFSJvag4ewcAu4Tw0TOeEt2Sr2WxwFAwqvZr8AZEgDTh69SEOFLu2onG5 +m5obokh6H93gMHB3HJhyuwn5pZPTH6p8uNqsKWljtce6pSvr+8NVl/+OeRiAyN6j +Ine5mXtukP6PaA3RkH1peYiqeOVom0bbXX4yFol7SST8LIkCHAQSAQIABgUCTpS3 +/wAKCRAjm5tuO7CLIp3dD/0ZNLsljaOeK9DE9jWWoJbnogzIvd1QerXkWBo30K83 +LlbrDxISqLtlFakb4tgLQ3Tk5AdaiQmCTownmCbBWq1oe1mMcMLY21gdhzQRgRAE +AgCKToIOmuqMVbXy2GalaAoQhdZoSVmAqpamb+uZy1pMIaFRj1WzUASHIx0pMrd8 +jnsKihMRVMIKrLyKCjUYINt7uSoXHS47xYSZ63WiwcgWdUysSK/HyaqwNIpGidED +uQKITaFez7maK/dutDwAKY/jcwzTJ4XD4sGBbv2AA3dyofRwW02tNN2c78P7uwuN +aFPPOoWRv4H2bHd86LthkNTqo1Wpt0N1JAr+JstF1hG1PLA8I/B4VBS2jWXTvxfK +Behns8M7yYsOQ0EBAXXj4zNgK+OMebiu+aQdc+74QxmFtnaGBDIxOBThWK9TXkA5 +tXZGpxzWLm1n8X/fTMKY6FhGH2JcSNY4buWu/Zv91VwsabRRR/SlGXppmOGlb/VU +lmbRc7ub2CWGzlqKAnwvMs7k0vUdun9oFFujSlb3ih+cwx2O62Nt6D5nM+kPl9AE +oxhogRggxY9+xEom/eP+Dosc3xvrMOdijS+/YfdbweYW93kh1hyDmGl6Ep0tK362 +htvELQBxkjKJ+V9sCUt2vcJ2jOuHrmVkvRFWqyxqtZVg+DGiLjWrlvD9nWeqBa2R +oYkCHAQSAQIABgUCTpTj7wAKCRDBpGByW1HLz+97EACG9T3cm7mH8gTAC4CJRYHt +1pY+3EbCxnUAG3FeoCVnEbHrWb/ZG/9ALrEFbqOZr4LlGIo+CeygOvO/QQtWKFN4 +MaM0CqRDmdSqYWYm+cBzUK24llDzx0SDX/6YyqXpP1dOgVdlsGNyb3UKMiXX05NA +PMg78Km6CYE8f9gD5QgXTLZTBT6oJVLH8i9jqSKo0D6vj0qwJHpYTR1D3KvpD9MN +6Jews+byULgeJ1pgormBBykvlD/PZZzMk8sWmfADfsDEWFqB8rMQTTT9jvV+GwO8 +mE18a/a2S6MNTaUkL4FtGqdlvBJJBQLvJW6YEgOaBpmBeJ8RUR7Of8GgySufzztF +Y0Hm1rLZpadEjVDIBJQvYuAPSf3HNRXiuuEj5+0tCReOqRzdtbGuLWJlcOwTxHi/ +31ydXqsHF4kcvKCYqS7uSI/4hDPf7xoMOFLAdVfe5gLW+8OL8bnkkqMbFd3q68lk +3+WR5D8JbGHuBzMidt5/eit7doCf1JSWuUHv7QS78hFTD4pM5dXgKJq42zitNaw3 +ZxscNyiXH9ILv+4Nb9D1f9Qs7xegofB45mI15Jg2ogouXTOywVDUhkVSSnKQbzYP +R2H866WgjJCz6/WYbI2MO593+I4zLoRflPksHxDGwbCvhCaCe08Zp5jatWwnix/k +SF7W69CgBECkfmeerGBwj4kCHAQSAQIABgUCTpVorQAKCRA3QPsffFR056vcD/sH +ER+2ex0+QbskZkfxQL9vpguj7c2YbHJ9OQ3VtRMYB48MuSW6icAWpOU2qILXPZAl +BlaGzpDkTWSCIP1gW9H9owSR+FqW9KtcA2qjF8ICyj/eOWPy80vB5my5AlKLx1ZU +3ngDL1SzQNwtpM3DzW9iuE+w0bKs01GPSp09Ugmqa/kSNUD3vYRGGD0CeYiVLLQy +wj2Uzfrns4HlGAj1rcfftEiWwH6HF8u+XcZCBxGOAUgEdZMHUq1NH3DmVj5zU4pN +RtLS2P+0F5SWhXBudVpV5T2ybMxZoepnWWBIg2HLzUUUEF+e70xAuvS/I48qVxTC +DtwIu0QvmTE7FVkBGM98mrxUPIe1yAbhJnjId2anZesq168f00HLoR7tJ/4sLBKj +TYOG6sWfADkOucabP2poAvioIvNZJS63CYbi2pdJNF9at8ap+wWheZmcURRUJdla +MioxumAWtUPEK1aC4J7VHxHbuNK37YSDvKOmT/npcJ+NUHjZWLG5Q0HeS57SAx0j +zngDCNEFqwcnD6MchCxgVtLygPjl81f1BXdf2APoTcPnYBeQtV3H6flLPYjnmNlt +9P/35v+Gi30e8IqKH0TV8BSGH9rqbSdkhj2YNdgR7UqQeOYl18f7r4O4gScEQ1WG +udFyu4nXx1JdoxUs15HEidvKBLElnTE5reMyNjI5BIkCHAQSAQIABgUCTpWZMAAK +CRCes5pJXdv885AjD/9TzXF3DmsjEEGF1lrgC1thQNEQDbnCTsI6WcewSiNOaxdV +kj5tptiYV48l1kyCP9iuCNy0+rrr+Mqzmojt8ud5626IqIauKgEE0Uk74XgJxwfE +/zToRj+6lhLBbKXaoD2qafCdNtu+lAvoKSTAinBn2uAhTBGRTax7WTV9WoUolnqE +norvT7iiwku++tjHEqYsWm5Upraib1RWhEnlXPom8aIasHXsmU+DEPKX0/BsXEjx +mUGW40wKS7atc+1vwHNY+KL12LV9mTyg0qfQ7SxaHJKC3gehdGZX3ZzhKzo8ILRO +2OLnTckeNaYoqbEByK59K5+MReWdCax2pxLxMb5gbNQbRKcGCR+IW6428X6r6gth +2f2BHW75Ln8n60HNOXKHY9e90KtqF7J228gjXWIcPvXzmC7mED9vTgcI/b+WZR6v +aLWBjwdqkKp6PCRJlgKeQvp+W32/FHp71j969XsZ2Blr9MUm0SyxjwGCXLm7NzF4 +IQfPG4g1mkOQigz60Llnfi8+SBmd64sCUnXOPcJCeDAWuCJKqqlMIOruARNNyc22 +SkwtCaFORRAoPQ4n5hAnfFqV6CkIB90Ppp+8RrPAayYPEos2pNa7xm1WwfUCcSnz +YWRMZWBNz66pzGRidx3a3SDC7aibPmaZ+idsRs9hdspk2Zqu4nHIG4mJwD20QIkC +HAQTAQIABgUCTpSlggAKCRD0h+8YWHLXI/PmEADOkhXgzykcmr8hIZBYTEGyhg+w ++aFeD/+MmQrmXb8q+/6jsT8myR2HRBR/S/TKOaWoWr2s4NTK4DWyQnd/JmsSo+jN +neDaA/smp7RFAWiRoYBrFk+4ZvTVKrX1um9zdjI798IlrL5gelrFpGS4fSo55yuv +BCL1RGk71d/2ZGpEjFTmnb5znBP7LWQdTUGg3CRFU7PP2LBgf9h5MrHR0pjcuA/p +N49YNQt51psYw2gRB8Mq76mwSuVgHbL0jf1qMmZPAx2Rtpubp0yfB2Hl010C0njq +kdrn9U8Ht3HA/OkSkNOR6DgyxFf7VWvYthSWZ2zRzk5l1+WCCAXJbgwrXI87he6w +zI3UM/dr37KgHVKkCo/GwIlWdD2VXzyG/J9j88BVdJ1tFijWzZokXtJ8cyHl6rVr +fr1x4wqjJqLd2Ud3c/Luasb7WVsgaXcjKV0HwYzzeYxGgKWSfoRaEmUMB7BatzeP +bfcPOP2tYcGut07ggBm5xfL09+qJDP0g+82bH6ZDGBaSHK4IIy2MqdlHuH3zjNqc +h1rKP9QgeIUfKFk6PJPr09PPiua/vPgSNOB3zlrf/2kSNq6nLjvRzIul95vNJIj4 +Lv2wuaAiVQ2nwozMX5bjTeTCFkDvUFnnv9ov8GP33amCTvjdyyUZbOI/JvLKostq +ZQ4YggYWZgvsZSxXZ4kCHAQTAQIABgUCTpW6mwAKCRDg08nvB9L4tFMvD/42fnjm +5Ssx6h8pwmsNlMiAo4BA5thqhKykTVbrnoXEsM+eeDxqYNadHvYOV2BIKIBOg4bC +eb6Jgrl1iGsx08CKs6GexXLZA0j+r04T4LIRamgD2paIlRx+BGYDJwCvPJYwMyBK +RGd6LjI6skB3TF2mfguTwQmTPhc/Ybjqo1E+owf1X7wH+TbZeD5GvDTUL22xzyXk +nPNik5XEOEnEICnw3FvMFpLiB8v+932x9O9YRTUW+kxnfPmrURhK5XqoJjC/vKXp +VrDlSueXxC+qDW8GKFuPElQSw70B4mkcG0M7XmM0QCHD7w2VVjxVJcQv1iTHcObf +bsFAJUfbWhEOY2NSbukPNTs713DpI/ROQ7FcdLtw+k+uhYaBI8UZTtNvZf0ks+yw +Ll/+xCWjCXbNEAdKjHXgEt9lZzbVXsjMWC2y6lr0qb/oL9q9GHweU/6KTgAID9xn +pkW6uTNVhipvXc4IBLDvd0ELXn9ZsIQuTnHqQIF9mTpcmJbR/zau1ZwRpyWR6BVN +EPK4Toj58lpEDB9kVbuM64if92L2x5/kiADrrVGr82N1mwrquIJZrpdX6Kd0Z0Ni +jQkrL/tyPmMiTBLZ43iF1ZBbn/E1c3sumXWfKbZOKJZeWibKyl5rV1drY0uQDMQb +28AnduZYwZpM0HKWLWZNIwd6aECmZnvtk0KOl4kCHAQTAQIABgUCTp2g8AAKCRA4 +cLQA65GGUxt1EAC8BL0MBykT0sFzxHbD3aMKZc7k5LUG5IiI9FLGFqP1nPq0Y5+3 +40Sl5CoEFq0LbFcIg0PyEtlbRgLb6A7+JiuWknKXXgBmAOwVjHvg66SQtBSTT+wE +PCfAgQMvawVBOSLEf56NTDJjnzXT3o5I3RmJFnqBz0AHMDDfvz37ZuJJYkDyTSPc +vT2OiG8H3WtWdOD9FbC7jkY9sS9klK+LhZO9eDvpqJ3H3oCOiTnBreA/n2RSBvuo +NsFiAqGJOQIqMEZXONNppWH86+jXSBpfkTo8MA4O3CubZoTEBZyiGk2nONodEstf +7lsQ0c5DkjInkCs9CVsKUzaL6ZkrEwNNH7pcl4pQ1A6dnPdaBzF55T1SYqXukoC9 +7r5HuVGjRDBfFmtqaU1+5sTItH+N12yUDYEELts38XUGFMI8836+31CA7zpLm2kC +d2InRZERLsCN6ehCFTgSG8LF5a8FRUOEgD+zA1yze2yVFZhey1aBAqO8PSGVVkG6 +dGRA17AdewTP8tYjT8dmFFNkjpzf1NsvmxeVyiwK0w08O3W7F3njJjravX5sFaQJ +S6WSIgfoM5TGKTgoKh7Usxl8XemgUwsvmL1AVL9ARdPtXj2RZqEnRREc1gNdWTHG +z0TShKqSwtzq7vScPXYQWdpBoJ+2mzdJ+s2cJL4mM9O7AOIRCerZ1fDDsIkCHAQT +AQgABgUCTpSNFgAKCRB/2fzLAAvu7rKLEACphvNoxBGHu4aJFSu04V2f2Xgoin2o +2LJQPQzWozTX/f9whgEfwH7cLaMnnpY1FulwrBDOc1bKiCs14Q2yBbWOz4XuLnGw +YjTxtZxP2Q6EkodAf1ICTxO0Cl22DK/HiB5sJ7NN0nIEyMlVx52ZTNqTc80Kb6Cz +j/6tIk53naPL2N6VMSQG3+Xfx8PHMN1u1iEvz5kXdXYKqLQYW5eqtOpxK+K8SKVt +j2xHXq7YLrTT+AyrhxEl4JlOx27UFwi9EsRSvinTnYCtVKnFOFrqos/Cw4QBr+q3 +AxOXU48IITkewPmwU6fnlX3DGYK2ZFrBH1O+A3ULISOoTsyCGwwETMTgCsPWiSDQ +iN1QxgaxHEiSuFTwKVtPhn+7UMIxenouPRPtpta7JLCILtlJj4EZyGTJV7fVNySK +bW3i9zIjeAOpv9wmuvcR6+rPk6jR3iJ3M8d2m4jCjCEbW6a/yK+Fs9dew4f+QrNL +woRMgcogcR9HpXNOWoizlsH53BTQF7AAzHLZmExt2nu3ehR8w/2CtY0GVyxlVDeT +bK+8y6nfFqIoYHBaXJnCn3DhWa5L97J+8I7qjZFoMMRu2X092Qkqk2ZWnxIFfW8l +nLlxnXdLpyTIJWuzYWUR/CO9kXtcQeytkvUVvm4yeOfHypY1atie3UFR1k4WIcK2 +H5FApN2ZMtMYO4kCHAQTAQgABgUCTpXZ4AAKCRC+huu0FRBP33SSD/4xdfYJErAK +/ukzGl1P7KS1sXWV7x7zCER+NYKbqueuOAWJdaCsSbFoCuwJhKIkZcTYDZ8o+Qse ++rQ6s96dsSFNrC2fO7mll3J4MN/Cbmy1DX8nf+1Zxkd6Jd0e/7bugrD6+XsvUhto +EqqB3xMYD4zKApgAlnfrzoTV8i1sNe7TpZB9uiRDMKFMgx2efD3BZVWImYEdgnnJ +ZjkdiA5sw2c0j368J0LlU6d8RQUeo6j9AvJ95rsgUmhQOcfySO5knB4+Va/dA72K +/UbcMxRYU9o14t7ZOrW7H/okfHMuqVvMMuDHjpy0T35xer4NAKjqRlUOUxxgw4AL +o9tlB3LI775Hy3+U2Ogym74b/74fQcC47gN9vPRxNN33d+3VK5EhKPQmGy32OOl6 +EYBXs8Xq/jwUiCaRlSKkGBiQM061oATGmlcinS+vBsINjmqySpiOUHQScTy+sFwz +vl/85Ec1IRWrBhA6fBFNgdUSuL1jXcREFhem91fhM+rqKrashHsO3NyfGJmFCUh+ +B+fV+gBaPFIpGGkw0UYqfdbk8If18+B9fbJl1LwcKltkQD38gaT5YTBMoL5duzQT +xutPy2yCUtYHWoIHePLlamQaYQEY1rMx4uYnW51z7mZ1ohOu3v8UNq8pl5Mpldml +JEpaSR5Gc0VLPF16XhcwxvxO3qpcXXe+wIkCOAQTAQIAIgUCTpNLGQIbAwYLCQgH +AwIGFQgCCQoLBBYCAwECHgECF4AACgkQVeRaWujKfIphARAAjd4H9UDBeBmQ3YYz +kqlx5C4vtTO/TJqf/8TgrKW16IqrN78TWUkkc3N62OMZ2PvZgynJThT6cXlUDDXA +K0430GVytfnAaLRntjrSi18Cwu6UM0SstDJnm7G31NOFa6aCgnP1eHRfXxH2F9nS +AUumDpbxOZ0oy7+Edh9GaVGb6dCk6ZbB3o6WIk6+qh5pBraZAxrH26nyjBSyU84E +2UNzLXnLvyZGwO9DcGlBw2k3tEzEdaKwn9ZcK+xiLezY+Dqtihfftrqp3ksPer2L ++OBR/4B7SM2Dt6wHOj9tydvICKG+yv1vVEswpc1F7KFkz1bBM2IzAfNbOJgLjS01 +XiDellZOQIzk+Ttz7uc0ugo1vE9UWh5T2qDINSsJRryuxIW9t5toO0WoW1ru8YZf +rzd/lgHM/w++acbXROd6ii1VOgO3bdTCvJg8Vkv42YoiC919fCuK8HFuajTlmFAl +KqI6SLCrD/hfRCB6dF4jirxCkdvDp1NjyX3YML2XwyQ6T8oThzKX/lIrxkoodRyV +1MnddFMqcDLZ8bkZSFNJkp1+ukV663fYGhrCtc2ASQwgL+WAd7yDQSfCZM3N3HWl +kgc5EiJQSHNd/bwiDCYnraXQPECjJ0xnUIxyxyFvplIBGnIGVWi25mtFy/kIWioZ +X6EV5KeYdaH5Ue7HGRCBRe9g8YCJAjoEEwECACUCGwMGCwkIBwMCBhUIAgkKCwQW +AgMBAh4BAheABQJOk0vAAhkBAAoJEFXkWlroynyK7a4P9iq9l2Fruo2A19j0lni0 +P+T/1YBs42SPgCmo+SchCA/+Sd9cr0iiAoytxVpfpR0aPy0M0MfH+oEPRRAXg053 +aWtbdt10BpgYBAwHr+hR1945oXhU5CSfnRGKXIF+0fo045q0WIwBbtSaNnyG5QU7 +xAsJSi8Q70swL6eYIh2I/Ew1nGD5WXA6n6vQKuae1I5EWLwAFJZMEsTxNvM3Fj8I +ELopHMlcPzmz6TVqJ/tE367s4p3bMipzLLO5hKcVDIURwFjPCgAgVJknD9kwvecS +s5virZU+hP6XT1yLT14hYObIPFX+UXKPI9evmw874ogAttTKevcLZ1fDHbJdY4i+ +ucKLXJRvkjHIFJsqg964AVt40nnQxRbugh0MhhbrYVY9uXjVEl44VTjAlkEsToL+ +LjdY4JPPaWhybgah8Cn5OeXs0CRQdVJZCah+yzSdrlXdBqOT0xNpgW5AUOG70sn4 +ZTlGG3IzVJWTmUh7GkD1Vw1FwlvdC4x+Gs4PI3pO2Ip8oL2QacULq0Y+4aJ5qKqs +gX7zsHgPMA3YyGFERawOJMGMDfHfsXSA7+T7ufFP67rrPsufTHm0A4TK9QWjNukI +YD2elK/7x705FumxaPkNEYPf2mzuuztNDmV//qGpLdQWd0299C+pxru2aLE16LPr +PS3rXq/8HDpOPSTXeauFp2W5Ag0ETpNLGQEQAO5SBPx8kOaU0mmx9DiSmu/JjSXJ +EPtjbBMFKRI+OfQmubNw7yQk+2QTlEGi+XLZJSoIwciPtwUiE/dLMIpur3TGMUq0 +uyKUNe8296XVeR+SxUEgr0tQ3eOumplhVgsm+mVpd4O5Jn+cRBCKG/TyzJQnt+4L +CF6fTNIW0SDlSEnqgolqeR5HDF8DBHeVx8RjeggoBvOr88RDpyyqDHV0CMZHpwOI +IJOXAgaGHdBTFER+dxM54bnHkt3rjUs7u9fh90iYyHYyI2EA4aRxeoF6CPrvDUlr +GfXRJ/7PvXv7j9nGLwD5kdNWu90MlSGUtt3qPa5jKpTyTYyW8m0PNbmh8UKgOZYw +u1lqmJe7YmvkEimDBMjJB706pzz4Sb4IbEKCTmnjeo/6iEFiJeX0BBDS0c5HBjuk +ixAzisxIAAWUsD/Vn3+O48sw+CVW+9agKSOtJt0xgfNvbwWrxSJBzc4b6/dZvugH +3lL2ZVpRZgt7+AbKh/90s8MEFNvHMcud2vxAzsJtjAyS+MJFSztmIdgmf+MdO1Wb +Y5hphusMlTqvvRkN3J0zxIMp32WLHT2ppf0SZpGwgJg2x28leDYU9UQoPNN7YWWV +/B8yXDNp8sLrRpc4tMcb+t7T+PLX0wFemo6skOY3kRigqv86TBPRoa/6B+NeDZRn +KJmFNFEORY6XZPHjABEBAAGJAh8EGAECAAkFAk6TSxkCGwwACgkQVeRaWujKfIqk +Gg//S9szHc2M50jpwKU89Uh4aYG4vESmisvPI1k89AMWRq2BenCr/AR9nxYAO6YZ +TjXFoVL1qRBKT9tPBGOdnPNdZaIUaHDYUpV4Flx2Aohtr8nbEHvRxHQQem1DjtM/ +INgz3KAbVBlntYA2XXUVtlW6jdrbPFsXm6INmGN7bydKHDKNedLeXNJKJXZUrWr/ +8zNnoqc/s0437DeF8tOKv1kOtxSG7m+aOY3FCY9aNe+yNVbQPHhLprH5zDEYEAX8 +9LdmxCHP2Zq7Lkfo/x+FpQQLiGqzY1rSMpR/3lSYcRbVxpwiOZjtYDfdEBuiKcLM +3MBDyX94FO3TvK/h13kwYny2AfyZ8xlosT2npA4AqzTmV8/uPChCRKFV1MbJ6mvD +0SFDuTrVUat5pNrsHCB6jxAS29MgehkUI2/Y0KgXUT7p9hWr48Vkbk2QRktUSLS1 +vG5gCc9Xf8klos0ap6M/FNLPUshhh8eTrMiSbhTuhRa99Zu1mRuSz30CVDYskdsv +Wa43T28F5nIcsIUy6sk2+Teo+UXwHZ++B9+/bYpVIR+XO4nlS7f0S07VlxJ5Gc7D +uy7z/919Ix7d3mQ9ls71YOJZWRb57onvAtP8gk8IXNsTCTi3dlqR+mShzW0ar9Wt +sYPCtihnYZWa0aPwGG1/xY2f5PZJWcBIxbHn3dBX+JqI6DaJAjYEKAEIACAWIQRx +AKrfrm5ulA0uCtZV5Fpa6Mp8igUCW8Sp1gIdAQAKCRBV5Fpa6Mp8ihk+D/41514Q +flRJK/jS/OjLLA1PkvRs/pAmBDksRTxb4caZpMfkPWNkl7oGk4afYfSCFB+pYbQG +XmIpsxguuzm2YfhL9EiHzduMb2dpz8yy49aWsv9n/zkNIOy2pQu0qWhf+5yK8a2E +j9y8r90AMP2Qnj/PlNAgldDcNia8XJOtcklzkVvXYshik7MzcM1kDj1ATi5TMNgc +Y7nUFtA48vJmKKsgclGBFrW3BoCdzEj8xNEYFjy4Fbo3cw7pxg3iXfUgXiNttCC8 +QB4gfeiWWMZpFaM+Lawez8MgN6ZYNfQl48GeSXnYimaL9NiRtGhjaS9uu/GMCQBg +wizDYQYvYA6sd13+q786ivwr0d8ULOv2wI4gAhR0lI79aEPqe+csrdHJVayTmgd5 +IegyAq/nWWLgbzxm5bNMjE7xLwkca49K5qXfcLSNmU7zempPfuXPWSOzfrUCmET6 +J361YoFUflYKFktFDIeSEHnZHHzDtb19kuYv5pprQz0/Gk8nmqy/2aUaG2vFL7k4 +v45LBk5EfUMCsQUHgViMuMaSrXXbadvUSRQBZpt7r7B0xn0SJtKABp20oAKKEEqm +Yr/W0L48z9JmlnOwPbjSLKSo+AmhIw7bajMzxruRsqZTAxp5hLpXV21Icgi5UV81 +apsbhOOqtBtr5fqsIsMKGA2rjaMry7xytADmW7kCDQRbxKZ9ARAAqZyNg+6knihh +IoR7SL22QITesd85JBC2iwdvjJoVmQHU5s3xZiVNvA1zS7gqscsuxsQE2gXT0eYD +8quC5AP8ak6guZyvc02asbasIfcUxQnIVIZnQr6EpBct0dXGZYny1Wq7biAR0F3f +V32JCTKKeMIbGz3G8wyfSWFKh6bqsrDQAIR4HryiM2fdwe51uSSAR39f4lTEpwu/ +pd4EizINJ/tFGpRokEqYM1Ep8n4J6CYwW28kEyTKzoRkiR74ns3Ak9zjnLZ59I+S +NA7lNSESeYfjGeDaYFdmMhwk13RxPcdQxhPVrhMbmxY4gLybYHGJMHH6sqqW3Cti +CAljlL/lyW6wKZtD3WnJcl26yWUWdPEATlvXGfLZ65L2+D7ZLYoIh808vS3p6Fj+ +5Ul1Xq6I7t/oPooJGmvWW4FZBzpA0a647SYTZd8jxGitEaZS6Seif8rBr47hvW/6 +VgLF6bbH0jeEwgiiAKjoOP0SDYsjOWM8yCKi3L8Ac5vGsBaaDLHsYQQVCS3QQtxd +rOdwGSVJB/jWCf5WYJwwPfxFWDwDhgl7ebvzrWcgsic8mA+n2bS7IUIkUXQzJHgm +flvPPh5oMQNwpOr30jyD8lVBmEGKkRM2anwVVRbgDbn66/nQWGMRNEetc2DCXVy/ +H7DbIR0eZpXB4OBDg3Z4TnkUniLkvrkAEQEAAYkCNgQYAQgAIBYhBHEAqt+ubm6U +DS4K1lXkWlroynyKBQJbxKZ9AhsMAAoJEFXkWlroynyKriEQAK00HLBi/+U8Pi+I +NDsVHh9fxO00OeFK6U/X+D4z49Ej2Xr6s7Ff27kXpq+m6qTceWjLy4aHqAKHauGt +BpgvgV/bnHxihC2r4EXkFqcgJRRaKfPzAm6J6qvtOz3TvumSYn39FSDBhQHVjmm8 +0PVTJGEOImxfnrU44FjaSdFIhYVDa4nPnk9NLRzMxKtlnYG50v28ADbBBe5CAN5J +Re5ZGBuTBTeYE21rLB3mr31J93KEfQCVapsfpmyXVIjMYjK80TkXqVDtc7PFycyz +JDm+YdghJZNbptC3xiPU/0Wd58j+br98VOWhv0adqML+BLL44aQE7fr6Lat4mZNo +ZMMpmJjGyqWevdLDU+7U2EuROnV9POTUZhEKcv1PoF/1ea7FlCz5kNlCRKCIs8ka +4cavzu92Yp2qZA2VTvg3njwa3Vw8AzipYQ0NlXTKf7i2zoPB8bNjfga55+U7OhQA +3j/edRfVcU2kVq6aTrfXkUIMWrGBPYRMxUutXlmN6h31k+fT58fij5rkevUqGwax +uWO6mL5UMR0FLIlYUZTww5TrmZNJ2yu0EeP2l+wMDcadm8qO3HbgjnnLPrkrAHFo +APijIn/Mhsx8csB5t+HU5+yWNDKKndN59PVGONyyEjQtWrXf6tAU4ozKc66FPuIt +6Jni90khyUQSSUjMUsVOUl1fwwTGuQINBFvEprEBEADkKGgC+C0itckM2yCYOIaI +4ifojiDIc9gRvc1TadgieL3sn44B9HlG0q/JFw9TgZHcPYSbskFyLuIQEb5IeNR9 +TfQUw0TF7eVc3omVEAUtJiZU0OhCa1+s/mOPe9DsD1x2E2RuxHAbU662PbPgZtCZ +wUK+ZWeE3aBloPLEMRmSGO/c1GGI5Xup2gWUNEBVE4H8im8eJ/IM16iGW6Y/0q2x +nLRb3t+hw/mFcJpHIyCbsSgSjHFX00UNQBtT1aqCMlf4E3Jj21TCnAvC/UtIsZFq +6plYZDSRG5c5ExITdFheV482rG8QpFBnCduAnaDOedeS6Qimqjk0srqL9mgyXxqz +aF4tC06PdzPsWgaui4v5FVG/UuymNQkg+27rsPQgK4gFSWQWArrwcqePbQcGFklY +Z9hlEYe5nsfdTbCdh+zr3i8oGBB0r0/ktgEQNZb6SwxBvC7yLiqPEK8JgpBOQDuF +lOnOtoJ62o1sEw1NEd/L1zmw9HaroLob1ci1ojhFVmnFFF30zeoQi6KlJTgIoyoE +ph1YYyLNp54CnUfzyzkIlYyqTMcQ6MkrTCZH4JIS/L/Q/1QVN/fEMATgR1xQ6Lym +S4Tc99ilNzGtqRPkRmWAREHggFgSudTDXXKbHUNKdujt9x+jafhlkR0sK7bztNBy +tFneHjpjuS2NgIklHStDVwARAQABiQRsBBgBCAAgFiEEcQCq365ubpQNLgrWVeRa +WujKfIoFAlvEprECGwICQAkQVeRaWujKfIrBdCAEGQEIAB0WIQRLQqjPB/KZ1VSX +fu/qIPLalzeJcwUCW8SmsQAKCRDqIPLalzeJc9H5EACCxvzjdeuxKiatlTTAg/3u +EruTOf0c3KLBJPtMcZh8ozk5/9+kxvbp3jUq/iGjXUnh/dui2laXGrkhXQim3oCo +851E7ZjH3SUF/ok3XzuyU0nWQAhR0FEr2uEbOt91TE58oSXUXq8axrzQC9GgMg3U +xua3PwkkI4+vNwCRivU+4mbm4JASlqGGPI7SYp7Ernj6foBXrSIQkMhtp0quMqyI +F23epf5CXbKqusRM+NpmxiX9rj0PwRGw/4M1o5vLEVACfdbtJR6s9yo0ODM3bFPj +Jv54GXcl1s8JXwtuEGxwK/XJ1sGb7S3b6Nhu84oDF+z8jMHxKuZe4t4BUtDJ8ty7 +bxqh9QEv2CXMw3sqJw7UdoAKbWJcgRzgX7XY+4VaGUtEDTbLNgdJMB6klji7X4DB +1ogVxavG7p7cFhltq1F7O+4LymBvUwdWtDWKdR79hTjlAlmPac7P1gTpFtLORDom +rcaA3wBSKCh+xZag3+wp69yKWikurVwx/uwd+UAabWIDCGON7/hoaiBBC5GmKMN1 +Z503G0BYtFXwcYfxoMocnYRcmlLOXY5JQmdPdZ0UWHg0slIQdZ5a+xZ7iyvdf65u +mCPiFpsNo92erq5Zw+kzWDxX3mc1w6CYLZUbHBxUC9vxwiIgnDm1RXfB2wrx5jaT +HUcSHfKqIDq/8uS7thWL80cxD/wPDTasKo+811pOcOpY+LVZO/egeIDzWdDVCF2H +lKGxLbrj464eEkElTpbrwAwlef/Krj+H3cP4jbZmqE6mKpoaRwKxYD/YIx0O7y9/ +nhwkCKldIXYbC5tLfKJeQKz9wYDbX0t0XEH95EPWkHSGLHM+Yk7wqXJ3FazFw8c9 +8Du2CspczRw1Be26NRTHPRz3nXCm8xvwURZ6cGDZ/MNuMZa/fqNWBM8IHOPDe3Y3 +ALGJeygiCqvNr1q23njzRywOMqNK3aktUT+4yJTpTFn8RfiBjg5MAn4rjFlaN+Ye +bjD7ngNMchHxqG19TrSuqZHhatW9ZjWAla/vuHlmiY+uHL94o8f7APjYudaQ9XR6 +8FEbl+RSIsUSZtGsMKCYMW7Fy8ueDxlYGrTaGtVseJZ7f+hwN9jLTOyJtDTCxgLd +vfBg/wCK92wJ26L3rzU42scKTvCpTDS4QDamLRoxZYbnBn0I1TsTlNHN0C9cASeb +NGzZbc+QvC6gkaaoyXON79wn0PyGc6mfoOdcCVloDfcAI+tnaA+MeiZVYNewGZul +kaBkI7Jcg1LgRN2bWXdl16XOz/625n2UAnK9VtYfJqAZJ21Nnjo4v3FC4BjN2PFu +Vd0cDYA+yBRwyq9SNfT8gRDK/kJPilR6bMNPUsTraiR3Y7Ssczq4C9Kxvp9FWMen +Zdi7eJkCDQRdwuAJARAA0MaeI38Zmyd7f2binLFeCcRvJobhlwZMzAdJNrhlCwqW +OMoe3bDeDwVOz7h4FDJMSZyZW4NMVUdp7sdtCDc66GJ/Mc0Xvo0pik1tH07zR/jc +cq+JPioKplWQnH8r8F7i+yDnxuZbnP6ElyVetrvixz/PdXVXCZVTdBH/YuUs/YkZ +JDFJJ8KE6zivatZ2TTgPl6CzIQiHcliD8eoxZj8X2aYBCcOmCHsjkkSD2LR+LcLg +4+dG80Lk030N6YfRXXF1S2MD9wWsr3xWrBocienGqlVvRqTA2vzj77XjZrdlm6mk +YHF/QlljiqJ4RapGlgF49JWBZDOuQ080lCqTbaIdjEVQO6shmds5R6HDVkqZUPFS +ZZcunIfTveVBF5UiCRcQIv+zQTbhvwnpB0McUGYXbJVHuyyLLo5SkvBctG6WLEwz +2/4Pq1LiB1gjoRAvgdKjmFRH/sHHPY00I2X+jT98yFeHTvjHPRlU/ndys9MtdYNT +jdG/Nqstjjb0crNTZqlwtrwp18ygkOlEx0WLfhHVdJ5aOfRvpaJQp0/LdbFu3s7g +cgOM1jCOoS8pNDS2/McDyvQU+99kRoc22u2uxGgK0wbDwN61rzmwtZEFkmsPrpXu +a5p0y+UOCcN6g4YDPW9gYN4S2D+f1FNCDau5Kx+Ndyop9AtvU9WjZi3zE35kuRMA +EQEAAbQmVG9tIEhyb21hdGthIDx0b20uaHJvbWF0a2FAb3JhY2xlLmNvbT6JAk4E +EwEIADgWIQRHpo/ON8fXAk/WXhE1bOYsK1JAmQUCXcLgCQIbAwULCQgHAgYVCgkI +CwIEFgIDAQIeAQIXgAAKCRA1bOYsK1JAmTS9D/9yhcq1l1uaLj7gM1njDFGa0Jss +99U+9IlUkvD7T1m/EtkMUHc4KXVT678U/sH6ucyW3c91+bj73Tl1Hsr9GwEEamEF +V/7ZM9dM7uvpvgYMdB+iOV5PRexA72oNRAw7PwQ0i4fVW7E5ZUmjaS4RY0kY9HVZ +hNQ4GlA1+Reup6WDIEiLKbAIxCNTGdTw2EH4aMsRDIs9JXdeMr+hxO4QT3pHEFtp +gFs5aWZoMPTVSHKkoct85yTRhqUFGyxLRm67/8ETDVoxljycnxOXSw75H0I63bE0 +Vr+fknef8938KdBvHVKtYlnnoLuphXtCkSwec95XHPkCUpVnrcsqGFjoatSc59EB +42pGadjW+K7aff2/U3Ybw+XDo6bBApi+ajK4tZp/4+BetwBuMi0GmK8MI1sw3M/o +0PMDbspe3F0BQ+lGG8sAtbQvQxNFaaVdpzoq7Uzj8/PnrVzMerIONEkyeHW2J/4C +S4YsnEmlAKhpEh6QtuBW3L5FcCs+TAVGLixIDR90cjSlYJ2+SVmaHxO3oTlQnPlQ +JszMqG4xPu9RUV5T3Zqg/4puL2A7Ks29ecF+/VbF6iNG4o/sVWGkexqEG031UNGu +n+rJVnsej5ijp2U43yy+7BLtSYQLXqpSPSNDZTSQRf8t9k+pUKTvtwiRoWPtq0og +qZyN9TTLrAJHLn58arkCDQRdwuAJARAAvUXjs2H+p68ky5/JRoOjNJKTF9z+7/Bp +TldYWfIUw5VBE6aPscUdxbzY1hAzcrmsAqbzc/D7tziqsSgyIr8lXSTRHN9+YJbD +GOwZgHry7wLcn429Kzszl6i34XbJ9dPDa+gIvpZDLPMZStocRiN6qQx8yJjmJoVg ++CdfNYMZY+Rmo/HzslfCWb32OgGXHotrc5Zh6Y/Ukoeyufba1GbWlA5Y1HlQBD+C +n1NbCxGMtwVM0vnm+EMNbZXrovvPRPyeMz64MMLi4OTlPknE4oH2xBf9OTDFAMko +ionioafCBbE+NfhVzpaLQZdMM+iW6OB8TbWOT7a6b+gTqwZWH4X4WXgDZOPsuTpy +6kY44E739afQh5rILOrMf5ZDcl6c6MSkfPUc8R8Z64FAE0mvNCSvaP9LT2ZDd9xy +iZZEp3T0BDOLi607CMbzbAUjjyCgtPbIjG2wXiNLfNdT9aTIfM7050ZdhUkI4rpi +6FYa/scWdsFoj8c7VUJDC7rll5M3MUFH7sOZxEAh/lnamCjZleq8NpFOo9dKtJL7 +7KVjzE27CP7wWNysoj9RfHU6F4sLpTU9VNOTRidtGG8xB52BCmrQavWSCy8et3PH +i2elaaZABNGZZoLDr5/syHL/NT+MfZgy77qkzs0Y/0bgwGOqiR7iAqbFdxeQNN8/ +Z3v2fbtJsEsAEQEAAYkCNgQYAQgAIBYhBEemj843x9cCT9ZeETVs5iwrUkCZBQJd +wuAJAhsMAAoJEDVs5iwrUkCZIkAP/AptO20H9hSCk3cERAiTu6b6bnN8xNV7Eri8 +ruNKqbFl9uC5fe0u3KTiu6zdo0melA6F6TYF1Yjs5mucogvhjulFFsa/MRPwg13r +msMR1LdF65/lEJ1rIq7K2Yn41T5F6Lu9UDPpGkPal8uJYjqUWiY3/Ae4s94pYDFA +ApzHMDlZ/o27MC0KTXrbCpPr6y8EJSCz5FnChsSLtSK6NxO1qCD6Ixx7U+wqO5kk +c2jSNNFVO4zMGcFxUC/yG3hrCpWgMsYdQc0S5y3TzfIcYmLRKtiBuulKtxJooLcD +r4dOnf0Iv4AR+glsXWoUZOx8AE8qzb2433bszZ4RfpTwN/YiqyOfiBmrCui6fR5J +VCQ9EPSSu8mnP3FI+S6bWPzwRQu3iShyS8qIZr5V2IEUngFxJu7hqVOZP41GQzOG +daOSW6IjVUKKg1rOog2CW/NnEYyipbwtndpRSsbQTkd8SWVFLCKaEK7LcZ9SwOQ3 +AaLD73fSEsiGbN/FMiTU89OxlHnRKXhN2IS5HrHOp9oi/Q9mI8/0uADbpMZfWGQ1 +vhBUvC7U3IbytdTh1rm71sVhVe7cSxZpAWEMJNpKwotjFYLkWRo/G6Hao7ctR/GT +HwOTWMACnskJrJkx6jZkdVrP3HUAle/t6vUbq5VLWNQFcceC7Z0tehl/jlQsm1s2 +ytbqi636 +=l1C4 +-----END PGP PUBLIC KEY BLOCK----- diff --git a/libseccomp.spec b/libseccomp.spec new file mode 100644 index 0000000..838a353 --- /dev/null +++ b/libseccomp.spec @@ -0,0 +1,157 @@ +# +# spec file for package python3-seccomp +# +# Copyright (c) 2022 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/ +# + + +%global pname libseccomp +%global lname libseccomp2 +%global flavor @BUILD_FLAVOR@%{nil} + +%if "%{flavor}" == "python3" +Name: python3-seccomp +Summary: Python 3 bindings for seccomp +Group: Development/Tools/Debuggers +%else +Name: libseccomp +Summary: A Seccomp (mode 2) helper library +Group: Development/Libraries/C and C++ +%endif +Version: 2.5.4 +Release: 0 +License: LGPL-2.1-only +URL: https://github.com/seccomp/libseccomp +Source: https://github.com/seccomp/libseccomp/releases/download/v%version/libseccomp-%version.tar.gz +Source2: https://github.com/seccomp/libseccomp/releases/download/v%version/libseccomp-%version.tar.gz.asc +Source3: %pname.keyring +Source99: baselibs.conf +Patch1: make-python-build.patch +BuildRequires: autoconf +BuildRequires: automake >= 1.11 +BuildRequires: fdupes +BuildRequires: libtool >= 2 +BuildRequires: pkgconfig +%if "%{flavor}" == "python3" +BuildRequires: python-rpm-macros +BuildRequires: python3-Cython >= 0.29 +%endif + +%description +The libseccomp library provides an interface to the Linux Kernel's +syscall filtering mechanism, seccomp. The libseccomp API abstracts +away the underlying BPF-based syscall filter language and presents a +more conventional function-call based filtering interface. + +%if "%{flavor}" == "python3" +This subpackage contains the python3 bindings for seccomp. +%endif + +%package -n %lname +Summary: An enhanced Seccomp (mode 2) helper library +Group: System/Libraries + +%description -n %lname +The libseccomp library provides an interface to the Linux Kernel's +syscall filtering mechanism, seccomp. The libseccomp API abstracts +away the underlying BPF-based syscall filter language and presents a +more conventional function-call based filtering interface. + +%package devel +Summary: Development files for libseccomp, an enhanced Seccomp (mode 2) helper library +Group: Development/Libraries/C and C++ +Requires: %lname = %version + +%description devel +The libseccomp library provides an interface to the Linux Kernel's +syscall filtering mechanism, seccomp. The libseccomp API abstracts +away the underlying BPF-based syscall filter language and presents a +more conventional function-call based filtering interface. + +This package contains the development files for libseccomp. + +%package tools +Summary: Utilities for the seccomp API +Group: Development/Tools/Debuggers + +%description tools +The libseccomp library provides an interface to the Linux Kernel's +syscall filtering mechanism, seccomp. + +This subpackage contains debug utilities for the seccomp interface. + +%prep +%autosetup -p1 -n %{pname}-%{version} + +%if 0%{?qemu_user_space_build} +# The qemu linux-user emulation does not allow executing +# prctl(PR_SET_SECCOMP), which breaks these tests. Stub them out. +echo 'int main () { return 0; }' >tests/11-basic-basic_errors.c +echo 'int main () { return 0; }' >tests/52-basic-load.c +%endif + +%build +autoreconf -fiv +%configure \ + --includedir="%_includedir/%pname" \ +%if "%{flavor}" == "python3" + --enable-python \ +%endif + --disable-static \ + --disable-silent-rules \ + GPERF=/bin/true +%make_build + +%install +%make_install +find "%buildroot/%_libdir" -type f -name "*.la" -delete +rm -fv %buildroot/%python3_sitearch/install_files.txt +%if "%{flavor}" == "python3" +rm %buildroot/%_libdir/%pname.so* +rm -r %buildroot/%_mandir/ +rm -r %buildroot/%_includedir/%pname/ +rm -r %buildroot/%_libdir/pkgconfig +rm -r %buildroot/%_bindir/ +%endif +%fdupes %buildroot/%_prefix + +%check +export LD_LIBRARY_PATH="$PWD/src/.libs" +make check + +%post -n %lname -p /sbin/ldconfig +%postun -n %lname -p /sbin/ldconfig + +%if "%{flavor}" == "python3" +%files +%python3_sitearch/seccomp-%version-py*.egg-info +%python3_sitearch/seccomp.cpython*.so +%else + +%files -n %lname +%_libdir/%pname.so.2* +%license LICENSE + +%files devel +%_mandir/man3/seccomp_*.3* +%_includedir/%pname/ +%_libdir/%pname.so +%_libdir/pkgconfig/%pname.pc + +%files tools +%_bindir/scmp_sys_resolver +%_mandir/man1/scmp_sys_resolver.1* +%endif + +%changelog diff --git a/make-python-build.patch b/make-python-build.patch new file mode 100644 index 0000000..3b89687 --- /dev/null +++ b/make-python-build.patch @@ -0,0 +1,595 @@ +Index: libseccomp-2.5.2/src/python/setup.py +=================================================================== +--- libseccomp-2.5.2.orig/src/python/setup.py ++++ libseccomp-2.5.2/src/python/setup.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Enhanced Seccomp Library Python Module Build Script +@@ -41,7 +41,7 @@ setup( + ext_modules = [ + Extension("seccomp", ["seccomp.pyx"], + # unable to handle libtool libraries directly +- extra_objects=["../.libs/libseccomp.a"], ++ extra_objects=["../.libs/libseccomp.so"], + # fix build warnings, see PEP 3123 + extra_compile_args=["-fno-strict-aliasing"]) + ] +Index: libseccomp-2.5.2/tests/01-sim-allow.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/01-sim-allow.py ++++ libseccomp-2.5.2/tests/01-sim-allow.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/02-sim-basic.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/02-sim-basic.py ++++ libseccomp-2.5.2/tests/02-sim-basic.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/03-sim-basic_chains.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/03-sim-basic_chains.py ++++ libseccomp-2.5.2/tests/03-sim-basic_chains.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/04-sim-multilevel_chains.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/04-sim-multilevel_chains.py ++++ libseccomp-2.5.2/tests/04-sim-multilevel_chains.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/05-sim-long_jumps.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/05-sim-long_jumps.py ++++ libseccomp-2.5.2/tests/05-sim-long_jumps.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/06-sim-actions.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/06-sim-actions.py ++++ libseccomp-2.5.2/tests/06-sim-actions.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/07-sim-db_bug_looping.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/07-sim-db_bug_looping.py ++++ libseccomp-2.5.2/tests/07-sim-db_bug_looping.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/08-sim-subtree_checks.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/08-sim-subtree_checks.py ++++ libseccomp-2.5.2/tests/08-sim-subtree_checks.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/09-sim-syscall_priority_pre.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/09-sim-syscall_priority_pre.py ++++ libseccomp-2.5.2/tests/09-sim-syscall_priority_pre.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/10-sim-syscall_priority_post.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/10-sim-syscall_priority_post.py ++++ libseccomp-2.5.2/tests/10-sim-syscall_priority_post.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/11-basic-basic_errors.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/11-basic-basic_errors.py ++++ libseccomp-2.5.2/tests/11-basic-basic_errors.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/12-sim-basic_masked_ops.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/12-sim-basic_masked_ops.py ++++ libseccomp-2.5.2/tests/12-sim-basic_masked_ops.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/13-basic-attrs.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/13-basic-attrs.py ++++ libseccomp-2.5.2/tests/13-basic-attrs.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/14-sim-reset.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/14-sim-reset.py ++++ libseccomp-2.5.2/tests/14-sim-reset.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/15-basic-resolver.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/15-basic-resolver.py ++++ libseccomp-2.5.2/tests/15-basic-resolver.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/16-sim-arch_basic.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/16-sim-arch_basic.py ++++ libseccomp-2.5.2/tests/16-sim-arch_basic.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/17-sim-arch_merge.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/17-sim-arch_merge.py ++++ libseccomp-2.5.2/tests/17-sim-arch_merge.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/18-sim-basic_allowlist.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/18-sim-basic_allowlist.py ++++ libseccomp-2.5.2/tests/18-sim-basic_allowlist.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/19-sim-missing_syscalls.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/19-sim-missing_syscalls.py ++++ libseccomp-2.5.2/tests/19-sim-missing_syscalls.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/20-live-basic_die.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/20-live-basic_die.py ++++ libseccomp-2.5.2/tests/20-live-basic_die.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/21-live-basic_allow.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/21-live-basic_allow.py ++++ libseccomp-2.5.2/tests/21-live-basic_allow.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/22-sim-basic_chains_array.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/22-sim-basic_chains_array.py ++++ libseccomp-2.5.2/tests/22-sim-basic_chains_array.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/23-sim-arch_all_le_basic.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/23-sim-arch_all_le_basic.py ++++ libseccomp-2.5.2/tests/23-sim-arch_all_le_basic.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/24-live-arg_allow.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/24-live-arg_allow.py ++++ libseccomp-2.5.2/tests/24-live-arg_allow.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/25-sim-multilevel_chains_adv.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/25-sim-multilevel_chains_adv.py ++++ libseccomp-2.5.2/tests/25-sim-multilevel_chains_adv.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/26-sim-arch_all_be_basic.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/26-sim-arch_all_be_basic.py ++++ libseccomp-2.5.2/tests/26-sim-arch_all_be_basic.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/27-sim-bpf_blk_state.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/27-sim-bpf_blk_state.py ++++ libseccomp-2.5.2/tests/27-sim-bpf_blk_state.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/28-sim-arch_x86.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/28-sim-arch_x86.py ++++ libseccomp-2.5.2/tests/28-sim-arch_x86.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/29-sim-pseudo_syscall.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/29-sim-pseudo_syscall.py ++++ libseccomp-2.5.2/tests/29-sim-pseudo_syscall.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/30-sim-socket_syscalls.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/30-sim-socket_syscalls.py ++++ libseccomp-2.5.2/tests/30-sim-socket_syscalls.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/31-basic-version_check.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/31-basic-version_check.py ++++ libseccomp-2.5.2/tests/31-basic-version_check.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/32-live-tsync_allow.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/32-live-tsync_allow.py ++++ libseccomp-2.5.2/tests/32-live-tsync_allow.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/33-sim-socket_syscalls_be.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/33-sim-socket_syscalls_be.py ++++ libseccomp-2.5.2/tests/33-sim-socket_syscalls_be.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/34-sim-basic_denylist.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/34-sim-basic_denylist.py ++++ libseccomp-2.5.2/tests/34-sim-basic_denylist.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/35-sim-negative_one.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/35-sim-negative_one.py ++++ libseccomp-2.5.2/tests/35-sim-negative_one.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/36-sim-ipc_syscalls.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/36-sim-ipc_syscalls.py ++++ libseccomp-2.5.2/tests/36-sim-ipc_syscalls.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/37-sim-ipc_syscalls_be.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/37-sim-ipc_syscalls_be.py ++++ libseccomp-2.5.2/tests/37-sim-ipc_syscalls_be.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/39-basic-api_level.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/39-basic-api_level.py ++++ libseccomp-2.5.2/tests/39-basic-api_level.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/40-sim-log.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/40-sim-log.py ++++ libseccomp-2.5.2/tests/40-sim-log.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/41-sim-syscall_priority_arch.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/41-sim-syscall_priority_arch.py ++++ libseccomp-2.5.2/tests/41-sim-syscall_priority_arch.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/42-sim-adv_chains.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/42-sim-adv_chains.py ++++ libseccomp-2.5.2/tests/42-sim-adv_chains.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/43-sim-a2_order.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/43-sim-a2_order.py ++++ libseccomp-2.5.2/tests/43-sim-a2_order.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/44-live-a2_order.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/44-live-a2_order.py ++++ libseccomp-2.5.2/tests/44-live-a2_order.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/45-sim-chain_code_coverage.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/45-sim-chain_code_coverage.py ++++ libseccomp-2.5.2/tests/45-sim-chain_code_coverage.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/46-sim-kill_process.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/46-sim-kill_process.py ++++ libseccomp-2.5.2/tests/46-sim-kill_process.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/47-live-kill_process.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/47-live-kill_process.py ++++ libseccomp-2.5.2/tests/47-live-kill_process.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/48-sim-32b_args.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/48-sim-32b_args.py ++++ libseccomp-2.5.2/tests/48-sim-32b_args.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/49-sim-64b_comparisons.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/49-sim-64b_comparisons.py ++++ libseccomp-2.5.2/tests/49-sim-64b_comparisons.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/50-sim-hash_collision.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/50-sim-hash_collision.py ++++ libseccomp-2.5.2/tests/50-sim-hash_collision.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/51-live-user_notification.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/51-live-user_notification.py ++++ libseccomp-2.5.2/tests/51-live-user_notification.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/52-basic-load.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/52-basic-load.py ++++ libseccomp-2.5.2/tests/52-basic-load.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/53-sim-binary_tree.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/53-sim-binary_tree.py ++++ libseccomp-2.5.2/tests/53-sim-binary_tree.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/54-live-binary_tree.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/54-live-binary_tree.py ++++ libseccomp-2.5.2/tests/54-live-binary_tree.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/56-basic-iterate_syscalls.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/56-basic-iterate_syscalls.py ++++ libseccomp-2.5.2/tests/56-basic-iterate_syscalls.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/57-basic-rawsysrc.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/57-basic-rawsysrc.py ++++ libseccomp-2.5.2/tests/57-basic-rawsysrc.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/58-live-tsync_notify.py +=================================================================== +--- libseccomp-2.5.2.orig/tests/58-live-tsync_notify.py ++++ libseccomp-2.5.2/tests/58-live-tsync_notify.py +@@ -1,4 +1,4 @@ +-#!/usr/bin/env python ++#!/usr/bin/python3 + + # + # Seccomp Library test program +Index: libseccomp-2.5.2/tests/regression +=================================================================== +--- libseccomp-2.5.2.orig/tests/regression ++++ libseccomp-2.5.2/tests/regression +@@ -253,9 +253,9 @@ function run_test_command() { + cmd="$cmd:$(cd $(pwd)/../src/python/build/lib.*; pwd)" + # check and adjust if we are doing a VPATH build + if [[ -e "./$2.py" ]]; then +- cmd="$cmd /usr/bin/env python $2.py $3" ++ cmd="$cmd /usr/bin/env python3 $2.py $3" + else +- cmd="$cmd /usr/bin/env python ${srcdir}/$2.py $3" ++ cmd="$cmd /usr/bin/env python3 ${srcdir}/$2.py $3" + fi + else + cmd="$2 $3"