From 84ca7c9251fffb94f9472e6e31643347606f1b09ddb5cc8afd4cd9699fdbeb55 Mon Sep 17 00:00:00 2001 From: Jiri Slaby Date: Mon, 3 Feb 2025 05:36:51 +0000 Subject: [PATCH] - disable sqwait.t and nop.t for 15.6 OBS-URL: https://build.opensuse.org/package/show/devel:libraries:c_c++/liburing?expand=0&rev=64 --- .gitattributes | 23 + .gitignore | 1 + ...est-init-mem-zero-the-ringbuf-memory.patch | 35 + ...gs-use-correct-buffer-index-for-test.patch | 39 + liburing-2.5.tar.bz2 | 3 + liburing-2.6.tar.bz2 | 3 + liburing-2.8.tar.gz | 3 + liburing-2.8.tar.gz.asc | 17 + liburing.changes | 536 +++++++++++ liburing.keyring | 837 ++++++++++++++++++ liburing.spec | 147 +++ ...mmap-skip-the-test-on-queue-init-ENO.patch | 28 + ...-ring-nommap-zero-the-ringbuf-memory.patch | 49 + test-no-mmap-inval-0-return-is-fine-too.patch | 30 + ...hot-wait-for-the-right-amount-of-CQE.patch | 50 ++ 15 files changed, 1801 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 0001-test-init-mem-zero-the-ringbuf-memory.patch create mode 100644 0001-test-rsrc_tags-use-correct-buffer-index-for-test.patch create mode 100644 liburing-2.5.tar.bz2 create mode 100644 liburing-2.6.tar.bz2 create mode 100644 liburing-2.8.tar.gz create mode 100644 liburing-2.8.tar.gz.asc create mode 100644 liburing.changes create mode 100644 liburing.keyring create mode 100644 liburing.spec create mode 100644 test-buf-ring-nommap-skip-the-test-on-queue-init-ENO.patch create mode 100644 test-buf-ring-nommap-zero-the-ringbuf-memory.patch create mode 100644 test-no-mmap-inval-0-return-is-fine-too.patch create mode 100644 test-recv-multishot-wait-for-the-right-amount-of-CQE.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/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/0001-test-init-mem-zero-the-ringbuf-memory.patch b/0001-test-init-mem-zero-the-ringbuf-memory.patch new file mode 100644 index 0000000..d287be5 --- /dev/null +++ b/0001-test-init-mem-zero-the-ringbuf-memory.patch @@ -0,0 +1,35 @@ +From: "Jiri Slaby (SUSE)" +Date: Wed, 4 Dec 2024 13:05:15 +0100 +Subject: test/init-mem: zero the ringbuf memory +References: fix-test-crash +Patch-mainline: Submitted, #1293 + +This is a similar fix to commit 8100d7b5f862 (test/buf-ring-nommap: zero +the ringbuf memory). The same is needed for test/init-mem as it crashes +with MALLOC_PERTURB_=69 too. + +So zero the ringbuf memory after posix_memalign() too. + +Fixes #1291. + +Signed-off-by: Jiri Slaby (SUSE) +--- + test/init-mem.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/test/init-mem.c b/test/init-mem.c +index 59973c8b7521..8b139fedd83b 100644 +--- a/test/init-mem.c ++++ b/test/init-mem.c +@@ -41,6 +41,8 @@ static int setup_ctx(struct ctx *ctx, struct q_entries *q) + if (posix_memalign(&ctx->mem, 4096, 2*1024*1024)) + return T_EXIT_FAIL; + ++ memset(ctx->mem, 0, 2*1024*1024); ++ + ctx->pre = ctx->mem + 4096 - sizeof(unsigned long long); + *ctx->pre = PRE_RED; + +-- +2.47.1 + diff --git a/0001-test-rsrc_tags-use-correct-buffer-index-for-test.patch b/0001-test-rsrc_tags-use-correct-buffer-index-for-test.patch new file mode 100644 index 0000000..bfbf681 --- /dev/null +++ b/0001-test-rsrc_tags-use-correct-buffer-index-for-test.patch @@ -0,0 +1,39 @@ +From: Jens Axboe +Date: Sun, 27 Oct 2024 18:48:55 -0600 +Subject: test/rsrc_tags: use correct buffer index for test +References: fix-kernel-6.13 +Git-repo: https://github.com/axboe/liburing +Git-commit: 91eecf3a88aa7f72898c17b530d3873331cc1661 +Patch-mainline: 2.9 + +The test is reading from buffer 0, but updating buffer 1. It's expecting +buffer 1 not to be put until the per-ring state allows it, but with +per-node refs, this is no longer true. However what is true, is that if +we use the right buffer, then the ordering will be observed. + +Hence use buffer offset 1 for both the read and the update test, then +the test is actually testing what it should be testing. And it'll pass +without full buffer table pinning. + +Signed-off-by: Jens Axboe +Signed-off-by: Jiri Slaby (SUSE) +--- + test/rsrc_tags.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/test/rsrc_tags.c b/test/rsrc_tags.c +index 95f65e930ee5..e78cfe403bfb 100644 +--- a/test/rsrc_tags.c ++++ b/test/rsrc_tags.c +@@ -184,7 +184,7 @@ static int test_buffers_update(void) + + /* test that CQE is not emitted before we're done with a buffer */ + sqe = io_uring_get_sqe(&ring); +- io_uring_prep_read_fixed(sqe, pipes[0], tmp_buf, 10, 0, 0); ++ io_uring_prep_read_fixed(sqe, pipes[0], tmp_buf, 10, 0, 1); + sqe->user_data = 100; + ret = io_uring_submit(&ring); + if (ret != 1) { +-- +2.47.1 + diff --git a/liburing-2.5.tar.bz2 b/liburing-2.5.tar.bz2 new file mode 100644 index 0000000..fd07780 --- /dev/null +++ b/liburing-2.5.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:319ff9096a5655362a9741c5145b45494db810e38679a1de82e2f440c17181a6 +size 217397 diff --git a/liburing-2.6.tar.bz2 b/liburing-2.6.tar.bz2 new file mode 100644 index 0000000..9d95c7a --- /dev/null +++ b/liburing-2.6.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:78bcc0dc0d004a238d8b5f597adbb4ec74926352a3983b872db7f0efdb72565d +size 244371 diff --git a/liburing-2.8.tar.gz b/liburing-2.8.tar.gz new file mode 100644 index 0000000..4de9015 --- /dev/null +++ b/liburing-2.8.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e4f02c87c718858bae94dcee71e0b38c1af66bfcf234575b01f422a33896ceb4 +size 390769 diff --git a/liburing-2.8.tar.gz.asc b/liburing-2.8.tar.gz.asc new file mode 100644 index 0000000..a2ec574 --- /dev/null +++ b/liburing-2.8.tar.gz.asc @@ -0,0 +1,17 @@ +-----BEGIN PGP SIGNATURE----- + +iQJEBAABCAAuFiEEwPw5LcreJtl1+l5K99NY+ylx4KYFAmcbrDAQHGF4Ym9lQGtl +cm5lbC5kawAKCRD301j7KXHgpic7EACWTk5exmfW92IlhyE/lwiwpOMj6PKBzUM8 +MjY3qvbMGEvfVN4QFD0F3Tnlhdxy/H143ojOdFG6D6bka2sKm07V8i076p8locNf +XXUim7C/cmFEUHGO+SfYXYfnBBNGBzE/iZ4uKGSY6TYAxu0m7RCqbUm9YDtZpeU4 +RPXeYwI4D07uwJJVy7g4m0/FtGYGICdHAkLd06CkVEW1ZsQqbIMx01o2Im+RXPad +jwQKA9L/GyV92/VY59b3lk/CHGT1yEUhl8Av3wYrua2S7ACO7dLP4UVi9TDxSV9m +uYYeOVLTnXhHQm8jLJU/FVXBA/kVQNC/EqXLJK+gCs3SPyLinzK1lcu6STJQAaLL +e8nIYPQm+0+IiFrwfxCqY2x36hOXuutw9Pfg6SAjtfMC/oo54ezQoEsIyTpvau9u +tHHqQ3E6QcQzx2L4OlDAo369vsdIQuO0Pnqa8dIdKsy96CKvquI97dhZJcBtPHhu +QMdXtxleQ+m5J/T7Dg5ZwuM2STBZgctoeVRnEQbQkO6lfy0eGwDvlP+jGUvnTW53 +y8XBdaHfHgf2SXYvHuZvnYqV4xMZ8mh1fY0bzEsTGd2HO2ipSOdtisMwqjn6IoKF +hXNZMwduoZd1KXfvLso0XmfstnFYUfPXB2Fg1on9H24GoX0iaPI2zgnyiZjQarYq +IPuCifPL3A== +=7E4E +-----END PGP SIGNATURE----- diff --git a/liburing.changes b/liburing.changes new file mode 100644 index 0000000..57193bc --- /dev/null +++ b/liburing.changes @@ -0,0 +1,536 @@ +------------------------------------------------------------------- +Fri Jan 31 15:47:09 UTC 2025 - Christian Goll + +- disable sqwait.t and nop.t for 15.6 + +------------------------------------------------------------------- +Mon Jan 27 09:50:23 UTC 2025 - Jiri Slaby + +- disable more tests on s390x + +------------------------------------------------------------------- +Mon Jan 6 06:55:31 UTC 2025 - Jiri Slaby + +- disable some tests for older kernels & strange archs + +------------------------------------------------------------------- +Fri Dec 6 09:49:21 UTC 2024 - Jiri Slaby + +- switch to signed tarball -- thanks to Andreas.Stieger@gmx.de + +------------------------------------------------------------------- +Wed Dec 4 11:38:54 UTC 2024 - Jiri Slaby + +- switch URLs to the current location on github +- Update to 2.8 + * Add support for incrementally/partially consumed provided buffers, + usable with the provided buffer ring support. + * Add support for foo_and_wait_min_timeout(), where it's possible to + define a minimum timeout for waiting to get batches of completions, + but if that fails, extend for a longer timeout without having any + extra context switches. + * Add support for using different clock sources for completion waiting. + * Great increase coverage of test cases, test case improvements and + fixes. + * Don't leak _GNU_SOURCE via pkb-config --cflags + * Support for address sanitizer + * Add examples/kdigest sample program + * Add discard helper, test, and man page + * Man page updates + * Sync with kernel 6.10 + * send/recv bundle support + * accept nowait and CQE_F_MORE + * Add and update test cases + * Fix io_uring_queue_init_mem() returning a value that was too small, + potentially causing memory corruption in userspace by overwriting + 64 bytes beyond the returned value. Also add test case for that. + * Add 64-bit length variants of io_uring_prep_{m,f}advise() + * Add BIND/LISTEN support and helpers / man pages + * Add io_uring_enable_rings.3 man page + * Fix bug in io_uring_prep_read_multishot() + * Fixup bundle test cases + * Add fixed-hugepage test case + * Fix io_uring_prep_fixed_fd_install.3 man page + * Note 'len' == 0 requirement in io_uring_prep_send.3 man page + * Fix some test cases for skipping on older kernels +- drop (they are upstream) + * test-buf-ring-nommap-skip-the-test-on-queue-init-ENO.patch + * test-buf-ring-nommap-zero-the-ringbuf-memory.patch +- add + * 0001-test-init-mem-zero-the-ringbuf-memory.patch + * 0001-test-rsrc_tags-use-correct-buffer-index-for-test.patch +- cleanup spec file + +------------------------------------------------------------------- +Thu Aug 8 10:21:50 UTC 2024 - Valentin Lefebvre + +- Skip test buf-ring-nommap.t if ENOMEM appears (happens in ppc64le arch). + * test-buf-ring-nommap-skip-the-test-on-queue-init-ENO.patch + +------------------------------------------------------------------- +Fri Jul 12 16:49:22 UTC 2024 - David Disseldorp + +- Fix buf-ring-nommap.t test failure + * test-buf-ring-nommap-zero-the-ringbuf-memory.patch + +------------------------------------------------------------------- +Fri Jun 28 08:29:55 UTC 2024 - Jiri Slaby + +- Update to 2.6: + * Add getsockopt and setsockopt socket commands + * Add test cases to test/hardlink + * Man page fixes + * Add futex support, and test cases + * Add waitid support, and test cases + * Add read multishot, and test cases + * Add support for IORING_SETUP_NO_SQARRAY + * Use IORING_SETUP_NO_SQARRAY as the default + * Add support for IORING_OP_FIXED_FD_INSTALL + * Add io_uring_prep_fixed_fd_install() helper + * Support for napi busy polling + * Improve/add test cases + * Man page fixes + * Add sample 'proxy' example +- Remove (they are upstream) + * test-no-mmap-inval-0-return-is-fine-too.patch + * test-recv-multishot-wait-for-the-right-amount-of-CQE.patch +- exclude buf-ring-nommap.t test (crashes) + +------------------------------------------------------------------- +Wed Apr 3 08:40:14 UTC 2024 - Jiri Slaby + +- Update to 2.5: + * Add support for io_uring_prep_cmd_sock() + * Add support for application allocated ring memory, for placing rings + in huge mem. Available through io_uring_queue_init_mem(). + * Add support for registered ring fds + * Various documentation updates + * Various fixes +- Remove (they are upstream) + * test-io_uring_register-fix-errno-confusion-and-new-e.patch + * tests-don-t-expect-multishot-recv-overflow-backloggi.patch +- Add + * test-recv-multishot-wait-for-the-right-amount-of-CQE.patch (to fix test + errors on the 6.8.2 kernel) + * test-no-mmap-inval-0-return-is-fine-too.patch (fix the test) + +------------------------------------------------------------------- +Mon Dec 4 16:39:29 UTC 2023 - Guillaume GARDET + +- Fix build on 32-bit x86 + +------------------------------------------------------------------- +Thu Nov 30 15:26:15 UTC 2023 - Guillaume GARDET + +- Make use of openSUSE build flags + +------------------------------------------------------------------- +Fri Sep 15 05:28:44 UTC 2023 - Jiri Slaby + +- tests-don-t-expect-multishot-recv-overflow-backloggi.patch (bsc#1215332) + +------------------------------------------------------------------- +Thu Sep 14 08:37:29 UTC 2023 - Jiri Slaby + +- build tests in parallel (using %{?_smp_mflags}) + +------------------------------------------------------------------- +Thu Aug 31 06:57:37 UTC 2023 - Jiri Slaby + +- add test-io_uring_register-fix-errno-confusion-and-new-e.patch + to fix test errors on the 6.5 kernel + +------------------------------------------------------------------- +Mon Jun 12 08:44:39 UTC 2023 - David Disseldorp + +- Update to 2.4: + * Add io_uring_{major,minor,check}_version() functions. + * Add IO_URING_{MAJOR,MINOR,CHECK}_VERSION() macros. + * FFI support (for non-C/C++ languages integration). + * Add io_uring_prep_msg_ring_cqe_flags() function. + * Deprecate --nolibc configure option. + * CONFIG_NOLIBC is always enabled on x86-64, x86, and aarch64. + * Add support for IORING_REGISTER_USE_REGISTERED_RING and use if available. + * Add io_uring_close_ring_fd() function. + * Add io_uring_prep_msg_ring_fd_alloc function. + * Add io_uring_free_buf_ring() and io_uring_setup_buf_ring() functions. + * Ensure that io_uring_prep_accept_direct(), io_uring_prep_openat_direct(), + io_uring_prep_openat2_direct(), io_uring_prep_msg_ring_fd(), and + io_uring_prep_socket_direct() factor in being called with + IORING_FILE_INDEX_ALLOC for allocating a direct descriptor. + * Add io_uring_prep_sendto() function. +- Add liburing-ffi2 package for corresponding FFI library, given that + dependents will normally require either that or the base library (not both). +- Drop upstream patches: + * 0001-Do-not-always-expect-multishot-recv-to-stop-posting-.patch + * 0001-test-file-verify.t-Don-t-run-over-mlock-limit-when-r.patch + * 0001-test-helpers-fix-socket-length-type.patch + +------------------------------------------------------------------- +Thu Apr 20 20:26:32 UTC 2023 - Gabriel Krisman Bertazi + +- Add 0001-test-file-verify.t-Don-t-run-over-mlock-limit-when-r.patch + fixes test with kernel <= 5.16 (bsc#1209723) + +------------------------------------------------------------------- +Tue Feb 21 13:10:33 UTC 2023 - Jiri Slaby + +- add 0001-Do-not-always-expect-multishot-recv-to-stop-posting-.patch + fixes tests with kernel 6.2 + +------------------------------------------------------------------- +Sat Jan 21 09:19:57 UTC 2023 - Dirk Müller + +- add 0001-test-helpers-fix-socket-length-type.patch + fixes tests on big endian + +------------------------------------------------------------------- +Fri Nov 18 21:26:17 UTC 2022 - Dirk Müller + +- update to 2.3: + * Support non-libc build for aarch64. + * Add io_uring_{enter,enter2,register,setup} syscall functions. + * Add sync cancel interface, io_uring_register_sync_cancel(). + * Fix return value of io_uring_submit_and_wait_timeout() to match the + man page. + * Improvements to the regression tests + * Add support and test case for passthrough IO + * Add recv and recvmsg multishot helpers and support + * Add documentation and support for IORING_SETUP_DEFER_TASKRUN + * Fix potential missing kernel entry with IORING_SETUP_IOPOLL + * Add support and documentation for zero-copy network transmit + * Various optimizations + * Many cleanups + * Many man page additions and updates +- drop handle-eintr.patch, test-xattr-don-t-rely-on-NUL-termination.patch: upstream + +------------------------------------------------------------------- +Sun Sep 25 14:34:41 UTC 2022 - Dirk Müller + +- skip checks on qemu_linux_user builds + +------------------------------------------------------------------- +Tue Aug 16 10:53:40 UTC 2022 - Jiri Slaby + +- add test-xattr-don-t-rely-on-NUL-termination.patch (bsc#1202413) + +------------------------------------------------------------------- +Fri Jul 8 12:40:13 UTC 2022 - Dirk Müller + +- add handle-eintr.patch, enable tests everywhere + +------------------------------------------------------------------- +Wed Jun 29 11:28:10 UTC 2022 - Dirk Müller + +- enable tests for != ppc64le + +------------------------------------------------------------------- +Tue Jun 28 13:40:10 UTC 2022 - Dirk Müller + +- update to 2.2: + * Support non-libc builds. + * Optimized syscall handling for x86-64/x86/aarch64. + * Enable non-lib function calls for fast path functions. + * Add support for multishot accept. + * io_uring_register_files() will set RLIMIT_NOFILE if necessary. + * Add support for registered ring fds, io_uring_register_ring_fd(), + reducingthe overhead of an io_uring_enter() system call. + * Add support for the message ring opcode. + * Add support for newer request cancelation features. + * Add support for IORING_SETUP_COOP_TASKRUN, which can help reduce the + overhead of io_uring in general. Most applications should set this flag, + see the io_uring_setup.2 man page for details. + * Add support for registering a sparse buffer and file set. + * Add support for a new buffer provide scheme, see + io_uring_register_buf_ring.3 for details. + * Add io_uring_submit_and_wait_timeout() for submitting IO and waiting + for completions with a timeout. + * Add io_uring_prep_{read,write}v2 prep helpers. + * Add io_uring_prep_close_direct() helper. + * Add support for SQE128 and CQE32, which are doubly sized SQE and CQE + rings. This is needed for some cases of the new IORING_OP_URING_CMD, + notably for NVMe passthrough. + * ~5500 lines of man page additions, including adding ~90 new man pages. + * Synced with the 5.19 kernel release, supporting all the features of + 5.19 and earlier. + * 24 new regression test cases, and ~7000 lines of new tests in general. + * General optimizations and fixes. + +------------------------------------------------------------------- +Fri Apr 29 06:53:08 UTC 2022 - Dirk Müller + +- avoid requiring kernel-default (bsc#1193522) + +------------------------------------------------------------------- +Thu Feb 10 13:32:35 UTC 2022 - David Disseldorp + +- add explicit liburing2-devel alias to reflect SLE/LEAP 15.4+ naming + (bsc#1193522) + +------------------------------------------------------------------- +Wed Oct 13 10:31:43 UTC 2021 - David Disseldorp + +- update to 2.1 (bsc#1193522): + * Ignore spurious fadvise/madvise failures + * build: add -D_GNU_SOURCE to all CPPFLAGS/CFLAGS. + * man: clean up spelling + * man/io_uring_enter.2: add notes about direct open/accept + * io_uring.h: sync with 5.15 kernel + * Fix IORING_REGISTER_IOWQ_MAX_WORKERS name + * man: document new register/update API + * liburing: add helpers for direct open/accept + * liburing.h: correct max_worker name + * Change IORING_REGISTER_IOWQ_MAX_UNBOUND_WORKERS + * src/syscall.h: get rid of useless externs + * man/io_uring_enter.2: document IORING_ENTER_EXT_ARG + * Add io_uring_register_iowq_max_unbound() helper + * Get rid of useless 'extern' on function declarations in liburing.h + * Add (UN)REGISTER_IOWQ_AFF helpers + * man/io_uring_register.2: note when MAX_UNBOUND became available + * man/io_uring_register.2: add missing punctuation + * man/io_uring_register.2: document IORING_REGISTER_IOWQ_MAX_UNBOUND + * man/io_uring_enter.2: add IORING_OP_TIMEOUT clock sources + * man/io_uring_enter.2: improve timeout entry + * man/io_uring_enter.2: update SQE + * man/io_uring_enter.2: note that not all requests support fixed files + * man/io_uring_enter.2: add new 5.15 opcodes + * man/io_uring_enter.2: note that cqe->flags is indeed used + * man/io_uring_enter.2: add poll update and multishot mode + * man/io_uring_register.2: add IORING_(UN)REGISTER_IOWQ + * man: update notes on register quiesce + * man: fix io_uring_sqe alignment + * register: add tagging and buf update helpers + * liburing.h: make header clean for implicit sign and size conversions + * configure: document --cc and --cxx options + * io_uring: update buffer update feature testing + * liburing.h: dedup poll mask conversion + * liburing.h: add a multipoll helper + * Update io_uring.h + * examples: disable ucontext-cp for elbrus (e2k) architecture + * Update io_uring_setup.2 + * man/io_uring_setup.2: document the two most recent FEAT flags + * man/io_uring_setup.2: make sure FEAT flags are kernel versioned + * correct syscall NR in mips + * Fix 32-bit compile warnings + * liburing.h: make all file/IO offset __u64 + * src/queue: don't flush SQ ring for new wait interface + * man/io_uring_enter.2: further clarify what cqe->res holds + * Clarify information about error results + * Refer to the accept_flags in io_uring_enter manual + * Fix a bug due to the unreleased lock before function returns + * debian/rules: add missing slash for relativelibdir + * man/io_uring_enter.2: clarify io_uring_enter(2) SQPOLL return value + * liburing.h: add linkat prep helper + * io_uring.h: add linkat opcode + * liburing.h: add symlinkat prep helper + * io_uring.h: add symlinkat opcode + * liburing.h: add mkdirat prep helper + * update rsrc register/update ABI and tests + * queue: clean up SQ flushing + * io_uring_enter(2): Clarify how to read from and write to non-seekable files + * clarify an edge case of IORING_SETUP_SQ_AFF + * io_uring_enter(2): clarify OP_READ and OP_WRITE + * sync io_uring.h API file with Linux 5.13 + * man: Fix typo in man io_uring_queue_exit + * examples/link-cp: fix a couple of strerror negations + * src/setup: don't treat dummy ring init as failure + * src/setup: add some documentation to the memlock helpers + * examples/ucontext-cp.c: cope with variable SIGSTKSZ + * setup: provide helpers to inquire about necessary mlock sizes + * examples/io_uring-cp: wait for pending writes before exit copy loop + * spec: add explicit build dependency on make + * spec: bump version to 2.0 + * man/io_uring_enter.2: note that -EBUSY can also happen for getevents + +------------------------------------------------------------------- +Sat Mar 13 21:33:04 UTC 2021 - Dirk Müller + +- skip building the tests that are neither installed nor run + as they fail to build on 32bit platforms (like e.g. armv7l) (bsc#1181571) + +------------------------------------------------------------------- +Sat Mar 13 20:18:54 UTC 2021 - Dirk Müller + +- update to 2.0: + * Sync io_uring.h API file with Linux 5.12 + * helpers: prefix any helper with t_ instead of io_uring_ + * helpers: add io_uring_create_buffers() helper + * helpers: add io_uring_create_file() helper + * helpers: add io_uring_calloc helper + * helpers: add io_uring_posix_memalign helper + * setup: cleanup probe code + * setup: check whether malloc succ before using it + * io_uring_prep_sync_file_range: cleanups + * .gitignore: add sendmsg_fs_cve + * Added prep function for sync_file_range op + * Install man7 pages + * src/queue: never clear data->wait_nr + * src/queue: control kernel enter with a var + * src/queue: don't re-wait for CQEs + * src/queue: don't loop when don't enter + * src/queue: clean _io_uring_get_cqe() err handling + * src/queue: don't wait for less than expected + * Add inline doc in the comments for io_uring_prep_splice + * Fix sigset_t not found in liburing.h + * src/queue: update comment on io_uring_wait_cqes() with timeouts + * io_uring.h: 5.12 pending kernel sync + * man/io_uring_register.2: fix spelling error + * man/io_uring_register.2: Add documentation on IORING_REGISTER_FILES_SKIP + * Add two ring deadlock case + * Fix IORING_OP_FALLOCATE args in io_uring_enter(2) man page + * src/queue: Fix a typo in `__io_uring_flush_sq()` + * src/queue: fix `sq_ring_needs_enter()` indentation + * src/queue: refactor io_uring_get_sqe() + * man/io_uring_setup.2: correct 5.10 -> 5.11 for non-fixed files and SQPOLL + * man/io_uring_enter.2: document new opcodes + * man/io_uring_enter.2: ensure all IORING_ENTER_* flags are documented + * src/queue: add comment on why reading SQ->head for flush isn't atomic + * liburing.h: fix 32-bit compile warning + * man/io_uring.7: Fix typo + * man/io_uring_enter.2: describe timeout updates + * Don't enter the kernel to wait on cqes if they are already available. + * Add timeout update + * remove zero-size array in io_uring.h + * Rename SIG_IS_DATA -> EXT_ARG + * Update SIG_IS_DATA to modified kernel API + * Use IORING_ENTER_GETEVENTS_TIMEOUT if available + * Add wrapper for __io_uring_get_cqe() + * Add __sys_io_uring_enter2() + * Include 'features' in struct io_uring + * io_uring.h: update with 5.11-pending copy + * Fix compilation with iso C standard (c89, c99 and c11) + * examples: disable ucontext-cp if ucontext.h is not available + * Moves function calls out of assert(). + * liburing.h: add renameat/unlinkat prep helpers + * io_uring.h: add renameat and unlinkat opcodes + * configure: Fix unsafe temporary file creation + * Add const modifier to functions that do not change the state of the ring + * man/io_uring_enter.2: clarify POLL_ADD return value + * Add get_sqe manpage to debian package + * Add man page for io_uring_get_sqe + * man/io_uring_enter.2: add EACCES and EBADFD errors + * man/io_uring_register.2: add description of restrictions + * man/io_uring_setup.2: add IORING_SETUP_R_DISABLED description + * Makefile: add .PHONY dependency + * man/io_uring_enter.2: split ERRORS section in two sections + * liburing.h: add `io_uring_prep_tee` + * Fix build flag settings + * .gitignore: Add sq-poll-dup + * man/io_uring_enter.2: clarify PROVIDE_BUFFERS requirements + * Update packaging/installation for new man pages + * man/io_uring.7: clarify submission/completion ordering + * man/io_uring.7: style and barrier updates + * Add man page for io_uring_queue_exit + * Add man page for io_uring_queue_init + * Adding section 7 man page for io_uring + * probes: provide our own free function + * .gitignore: add pipe-reuse + * Fold versioned symbols into LIBURING_2.0 version node + * Remove versioned symbols not provided by the shared library anymore + * man/io_uring_setup.2: improve SQPOLL wakeup example + * Fix io_uring_sq_ready() to use load acquire to read khead. + * io_uring.h: fix missing tab + * Bump major version to 2 + * Add IORING_OP_SHUTDOWN and prep helper + * Add a few function comments in liburing.h + * Add io_uring_sqring_wait() + * io_uring.h: add new definitions from 5.10 + * man/io_uring_setup.2: document missing IORING_FEAT_* feature flags + * man/io_uring_enter.2: add description of buffer selections + * build: Output CXX on quiet output when using a C++ compiler + * Fix missing 'c' in sigfd-deadlock addition + * Add helper to enable rings + * Add helper to register restrictions + * io_uring.h: add register restrictions and enable ring defines + * io_uring.h: use an enumeration for io_uring_register(2) opcodes + * io_uring_prep_splice(): fix type (again) + * Use the right type for io_uring_prep_splice() + * syscall: make syscall.h independently includeable + * sq_ring_needs_enter: revert change to only enter if submit != 0 + * man/io_uring_setup.2: document IORING_SETUP_ATTACH_WQ + * update debian/changelog + * update debian/liburing1.symbols + * debian/rules: pass down relativelibdir in order to get an absolute path + * man/io_uring_setup.2: document IORING_SETUP_CLAMP + * man/io_uring_enter: fix openat sqe doc + +------------------------------------------------------------------- +Sat Mar 13 20:15:42 UTC 2021 - Dirk Müller + +- update to 0.7: + * io_uring.h: sync with kernel + * io_uring_peek_batch_cqe should also check cq ring overflow + * Check cq ring overflow status + * configure: fix typos in help/error messages + * src/setup: clarify that we always return -errno on error + * man/io_uring_enter.2: updated io_uring_sqe and fixed incorrect flag references. + * Removed misplaced periods from io_uring_enter(2). + * Merge branch 'readme' of https://github.com/jobs-git/liburing + * Make readme sensible + * man/io_uring_enter: update connect to note use of const + * Merge branch 'master' of https://github.com/KayEss/liburing + * Take `sockaddr` immutably in io_uring_prep_connect + * Merge branch 'dev' of https://github.com/CarterLi/liburing + * Merge branch 'fix-splice-docs' of https://github.com/gerow/liburing + * man: fix description of splice offsets + * .travis.yml: Change the language from C to C++ + * configure: Use $CC and $CXX as default compilers if set + * Make the liburing header files again compatible with C++ + * src/include/liburing/barrier.h: Restore clang compatibility + * src/Makefile: Only specify -shared at link time + * Merge branch 'openat_o_path' of https://github.com/MaxKellermann/liburing + * Convert __io_uring_get_sqe() from a macro into an inline function + * src/include/liburing/barrier.h: Use C11 atomics + * Makefiles: Enable -Wextra + * Bump version to 1.0.7 + * change poll_events to 32 bits to cover EPOLLEXCLUSIVE + * examples/ucontext-cp.c: use IORING_OP_TIMEOUT + * man/io_uring_enter: correct the description of + * man/io_uring_register.2: add IORING_CQ_EVENTFD_DISABLED description + * Add helpers to set and get eventfd notification status + * man/io_uring_setup.2: add 'flags' field in the struct io_cqring_offsets + * Add CQ ring 'flags' field + * remove duplicate call to __io_uring_peek_cqe() + * update wait_nr to account for completed event + * preseve wait_nr if SETUP_IOPOLL is set + * man/io_uring_enter.2: add IORING_OP_TEE entry + * update io_uring.h with tee() + * Merge branch 'master' of https://github.com/shuveb/liburing + * Adding section to describe IORING_OP_EPOLL_CTL + * fix missing '#include ' in 'src/include/liburing.h + * fix build on musl libc + * Use uint64_t for splice offsets + * Use __off64_t for offsets + * Merge branch 'master' of https://github.com/shuveb/liburing + * Adding description for the IORING_OP_SPLICE operation + * Merge branch 'master' of https://github.com/shuveb/liburing + * Adding section describing IORING_OP_OPENAT2 + * Fix 32-bit warnings on compile + * __io_uring_get_cqe: silence signed vs unsigned comparison warning + * io_uring_get_sqe: always use khead + +------------------------------------------------------------------- +Fri Oct 30 21:42:16 UTC 2020 - Milan Savić + +!!IMPORTANT!! +Version 0.7 BREAKS ABI COMPATIBILITY WITHOUT CHANGING THE SONAME!!! +https://github.com/axboe/liburing/issues/228 +SONAME is bumped to 2 in commit 25bbcbef3e0a8bfba8044be55d08d5116c51dccd +im master branch. +!!!IMPORTANT!!! + +- Update to version 0.6 + - removed barrier.h-add-generic-smp_mb-implementation.patch since + it was merged in commit ba97eaf8f9ef2030d581be10df9d875dbfadc91d +- License changed to match upstream + +------------------------------------------------------------------- +Thu Dec 12 09:20:32 UTC 2019 - Johannes Thumshirn + +- Fix builds on ppc64le and s390x (bsc#1159055) + + barrier.h-add-generic-smp_mb-implementation.patch + +------------------------------------------------------------------- +Wed Nov 27 08:18:20 UTC 2019 - Johannes Thumshirn + +- Initial packaging for openSUSE (jsc#SLE-7494) diff --git a/liburing.keyring b/liburing.keyring new file mode 100644 index 0000000..b2e9a1a --- /dev/null +++ b/liburing.keyring @@ -0,0 +1,837 @@ +pub rsa4096 2011-10-17 [SC] + C0FC392DCADE26D975FA5E4AF7D358FB2971E0A6 +uid Jens Axboe +uid [jpeg image of size 5172] +sub rsa4096 2011-10-17 [E] + 2C5DCF0DAFBC972930D1DE5F28C8BEF174494BD8 + +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBE6byYYBEADdvefbg3TpCkasOnrc69r8neDjASq9/0l3kL6tkpGVZZN/NF73 +CAEeqnafQM7Dt89w1/5k/dnIqnZ7FsBdPz7TMnjomOZUuMurN5j4Cv05R1gBriwa ++Ayz2/lQn2Bdl/X0qz6A0g66JzQxdPGKKqNZizZFZCPknpMk6TSavac8RmJRJGM+ +Uj16qP8beabAAcN1aS45DOlksHfYheJ0/GLhb9/zuDl0uzblmRvQVncIjN/XYwQy +pOFP8Y6UAwRHcGY1XZUhHbPp04lvmo1YdYnMCSJDmziTSUD3fx1HyeepeNr01fZ8 +s3rWps0S+E4B+zijZH9sqcmeYhmnvqvzv7Vndee+u5zjOJFi5KzDr1LRajnmBPPO +uNyb29pVHO8B7sV+sqVyOGyE4zW6gvwda7IjU9g+RC5HoRDYMyKzOO7NhG7TAX5R +ls1KzaWTIae43YU01Pr+Ewm+wVAOQr/xbw/5KCo9N6XsLpZXNqabiIsgyBrXiGG6 +b2FD6i+MC6H6BtWHnfzldXXtje5ZxV74I15jTPSoTwrljc6tAnrtw6Ty3pWgtReT +HESWFta+HBBlfSfj/vZfXfEmsGI303j3X61qUm07orYsYAM0tdFcNRpcJtm0odwD +PPBnIU+YwR26t6eDroGpx4TWyQlzcFQKhbyxePAfPimpgq/5QN6PyCDtRQARAQAB +tBxKZW5zIEF4Ym9lIDxheGJvZUBrZXJuZWwuZGs+iQEcBBABAgAGBQJOpxJ5AAoJ +EHm+PkMAQRiG0VYH/0C+PfIZixhZ//ezOx01DczmpWn91k+w+h1MWiGAK3F1rchD +VB6OMNTm0EUCzL6qOyaJFv79iAh0mq07pnGrYv6ZG0Fh+JyUFwOpT2VgNwmoHDCN +ugcu+LFKz7SHsYnMK+EB3ze1y8qKFZ+R3DQBUlJ7tn/j4TOapO0m+5OfxDukE5vU ++HDT6KJh+PSC+9lmSGDhreLzSLZZm7Zx1SisY62HyCcGBwxkVI1lGYCu7+5ECBsq +f4XlNOn9ZLtZeM3yiEVHQGJHMkVpTnflHO9dFeiyYHmP4hXSVzcxggpzJiIStKT5 +sP4QBVHdxAjAHNmKL0Gc4jvfgYvhx8Ny0QDRwOqJARwEEAECAAYFAk6nFtoACgkQ +yDsHRd8Yjf7drAf/b00lYD3Quxkl5yGsibMj0XF0MXV/IcD7BoXbDh8BWPyatdIV +4ok/SPVnj5q8Nf8FJjIww3f/wZWDVzRcNDX52IUe1iXGECggX3TEi1hg1NySxl9p +vxjn7q8LpOB7oy0WHVZIkwMX1dldJyvfSVlZ3dtQs3e9DBr7G1ugURIFMJQPfiA6 +oY4HqmBvaCopjjQoqHImwu1rpl94g7cqopUlml3RBFUu/IxhP6FnKtYRw5U/uiDA +bjl6HjHPXaf6OR8K1eKhEAXODQPVeCKch0Ma1GilEcT5aU0KKyGnOjSEsG6yZVhi +ClRGc26fMM3JzP4lmoiYFLjhPlgVGdQPU8RgDIkBHAQQAQIABgUCTqjMcAAKCRDA +rf/6sfscGOCQB/4jv0mvAhksvDvh13yVjtx/vZCbxc+QqMGzfJxC7cOy1GFVXpIu +1quetj7awnwQ48WrqLQAKyBgkI8afaRAlgtoN4gt20Oteg99wUt6RIWeQrpMZwfd +wXfBcXUy/1GRLwqtPcinVJzxkeZVxLB8xnswvmULpq5n32XRhNF1F8RAFmM1qEX7 +/tvF7edYUy+ybjJUqAYqa6OcIhSPebMkmtjGhnqKCXXWTW2gbhtqkqYCLsbWseR2 +IANUxN/+bdTn5rSHyFdnHlAhMnYJKrd4qBt52ulOM9722QL+FuQ0WJ9eP1UCqiG/ +PIV9+vD0ZTEMRio8lSZzRfyLDM7NBW0mr9lNiQEcBBABAgAGBQJOqYlSAAoJEEHd +Sxh4DVnETkUH/igHWmvobQuQAhh0ps1ZNhtNfjp1rdTWpNfqrjnzRvYJCSb3kqNi +hs2NY7+ri6jC0tETQsMps8oQFCeZyMQKB9ljVrcP+FD+8slTryNXVGpRqCng0/tI +g0YNHZs4LX0jDI0pAM5bDcigfrApTjnU7ADp+BIdgpo1Qe4MbZBju0/uyN34GfPS +VfqJhutvzZfk9C7Su6fGNsT0P6tPuolTHD9W1QlW1e+AXrxAXss3xhGbkjDpJrIM +ZLDdwpFyQNNOh9sC6OUWPd590u2QF15hLpdx+eZ0rR1QZ9TTmqJXG7GthYC8jM7o +Dh8rZw61eSCavzgfO7QktDOMEWq+oSlN6WuJASAEEAECAAoFAk6pDNMDBQF4AAoJ +EIFK5HwhSFTWdG0H/0pBbECbJHkvOadY+eED3HzAKzgWlt9Cq4rz0KWy2e+w2VuE +RJnGaLstKSgMp1IQMSagUqtzaVdv3WFvztEyIdHjpbL9dqcNoCKwXwfal4P7YVwT +DxoEkRV2oH0EQzLL929//wessFcVlkJIKsJM8pM2Sc30FJIcXfkkgDJAgH1TJIRT +8rsqrNjJpq4XlqmZMbnT+pgQKRy9v4ENvBPBOujZxnevK1nxhizZRNF9u4QYuhOF +R9a6t3zFHP2/g7wNyc/NTfbDLcuqKajSTMR2UGWyPjro+SKqhvngDIVbc/rxlJRw +Ih0yHzYeU87UgVc9p+SIzqGUXzE62qvBX1fq1VWJAhwEEAECAAYFAk6laG8ACgkQ +bDGAVD0pKaTH3hAAhW58VjybGFSz6mF1q2ScJPfiwd0xhze40ZElrG2ORjLQj6Sm +84rnJb5ovXJePfuXwt1Z58MH8/fgNzkJX2O3HONF+IIJ8GyL/HyKtVuHyWIlwBwX +SGbfQ+F1lyg7k67AqzSc5e0svzDl4DzQto/KK5XAZwxA5s438PCQkFr1djoo5xTp +cDB3WjcojvTV9MVytoCyc0xvQ+bUeEgsZywjyJTvdIgASRJbyJD0oA0bRybLMM6o +AL2Klemej5nfrvB01MdAHiQuS7U+W1xFiau7K5J0+6XfvmrmmAGwaOhlebhJ3oxc +vcqBvRVA/yEgXstxIh1IzF2WQNthe5Z9Z1+koACEGCXpUfC0TXqe4P2p/+EmeJWA +RgqVn4F4t8zeBgmtIsZKASVnRY02UoWHqGdqM++xrV/2JSTDK+Oe52FbwcpA2BNF +2/Fa0ocSKE7VkPYvz1csXmzSXiZpX3115y2kqVBTqCrfoIYmQ2Dlc8aAP/lQD+t0 +eSLIxmwo6UviByPIme5oTsP+L4viLNkZ1dkHk6V/5i7jWSsnuvEr8EXFmabZPzNn +DvrpK/PiHt+O+/LQ6OvJegFjkTAdUbyEZPcQLyQgVZW38gz2ZrU+ng6Y/l3sG3wT +5eGxfJ+oDxUtfSJFQyrsbB6oepqNc7FPq/WMY9RZyZSYPiffz6AU3FcHT/uJAhwE +EAECAAYFAk6lcPoACgkQONu9yGCSaT5VNg/9Fegj1GRLljZEpaIpbRzi89V1C4xV +3CKuJm2l7d1oIKQiLvthZLqKyJuoAQMjJTE4dE6nuy7H/GIeSOmfWIqrwe+V77bV +VSxS8i/DAZCi2cdCO6lEw/mFS8Xg9pJva2o/o3lxqhdh0a8GrE/BIC3kiDXjKPLj +y/Sk8memBhcd622OtFea2af3FPtOUUNsvCZnzEZZd1Pq/VJbWCWusIImKzE5rmy1 +PE1fQ8zUZs4eQIDT7fdcFMQC48z+9DxptNEdtFc0TVifKnmcWnc12/VifJm/RZEo +IQWVHnThv2pUFBzNaZwksQ9/Lky1nbIWftWYO0gZJLpZtxKVEN6rsnkxjTIu9SC9 +nWWBj0vo+GVDF+HvwkFcikRAi/qgiztw7MtLvAKdhEGPr8iKCJewfUnodMvwgHju +cpTuy2+Y5SDRnahcDWXvHeCqamJBKUY9jqs4E0lm0gCvBk23uWAGMvD+si5CcCc1 +an9dSmPpkZkB+fu4q72qGXUnWESC/1JvHSgXcmhmIHYSLRtux0RHy/gGuI60v2iO +t4D2sK4szKuT08hN8fuJPsOMFBKdJOP4xvSM6ZmZpaG8rNFZnXUT60Ybbuf8Be+P ++49ewTGzddhdsP58iSPLIjFd3f9ou+sWhjiItOlgVjB8GsrefHG9TR6Fi+TcwfmT +a+PDsXbP3ELzQVuJAhwEEAECAAYFAk6lf3QACgkQqE5/uaXy42zafQ/7BJjXzBPl +A9z0KIF5U7b8VVlDRiQlqCez+9MfM4w/KVndBdDvnCLJUC0WdBi33ZI8cR8nMW/H +Y8GrSl339WEfUku089KupuSoLIo4p5e9zK7BK2199woJBZP4FLYbOtU6QG8ZpPHv +jsv+MwJ1aE/HzZY7i+aILosX8S1Y4SQm2c6r9L2rfsVm02kPtVcxu5AIRae5NywC ++aRHXiIm9twkuEyF7a//DyoE9fH9I9zmkbHjuLzGpJwDJPTS0/JOc9X+8Cx1xvmo +Mh23kRINQx7f1NFCw9S8adN0sbLANkpdM1TtJClwN/m214wOlODw9+/ulMkaCgpn +7/ud13Z7HznHALL3iFV902wT8Mm/jKI6wrVPpUeQye3dXjluz52RZY1OVE8SYyJ3 +3E32ezvbwK8AKd6KV/oDYA25HmBuN/aMCWnjaqB/lbtPQzCc/f7qwE0YfTMZTrCI +HMUlXg04uckaBDyyYo1LMJkYiAZSD7LbeB6HNm/5VbBQ07Olilb1aPMQrI0cUWZc +v81xTT7CW0UqvoKAE+yEpqtLFd7SCha39ZCmtcRzxG/4gkSMHTxSORbe/lckI+G6 +ZGo27nXgWxiyOtjOAsrCPZMhesiC8+7AUoGDxOMgT7zHYfVT05tVWY6G7gKHS4F/ +GurxtfXwA+1OKZOwvO5mXTKFxaD205qU6QaJAhwEEAECAAYFAk6nGCgACgkQmOXc +yBZHtyrXeg//UVOu4VWZP9zCMylk3Vxv4FeraFKGFyYWZKEQFxfr11ZL6j+f48bI +u5XjQlw8tDyHUs5iw/UExab3863Cz78tGHO4CV8o3dLTi9TV2XodngSjXdTnwieR +Ha8ygi4o5KrTb9FIv0O7iUZzNlQT4eIdJxifJUAIRFJ+4/U27wtzs0Rz/6vz3yCd +E5H36LyCz/6AkTmrUnW2xSswlsNySBvZ5cpJHf7NekRNKg/PiGdZx7veoIoEXj1n +qPIquJ74/mFoEC2SOnGiN7n8VhlXcInAGapkq9WddKkApzbLI1b7MQkpOs6BXRZG +9zJU6dV6YITYG6+aywUbtmnxNJhT/8Ex/CLIRfiYMMoohAOg0a4XMKyyu7NqPZD7 +ROrxT2vaGjGhLqmNqYO9Z218G/aPOEO9rww9J/0tQ/e/I47F6syaS/HhjFPPgozJ +dXB+08+G4RgErxW0sRMvLCIThK/A9/gvuPllPY+RJqjzH7TXnOS73FtLlZWpT5DY +8KzmX2uS7dJtGsPNO4AivgWh+gLg2ApYlZb7Eay3Wos4ML8P+BP/QNnKAEklnECl +DYFDG8Qt6OoV8AdhB1QjUDxmhY4b0Z4idRbKHsBcZUb23WbU9Qlc+/NG/ifSS31J +nfzQI9QTEdoDPsVWYxZSESU2lGsLItUqfq23Flq2Rq0E70JC+/uXSDKJAhwEEAEC +AAYFAk6nHDMACgkQvaBghUk7rOQOHhAA0nCsvNcG77ZZez2dzQnG8dQWedFi+VGY +BuWqE0t826TU2jpRE3rhFahdqCSC7mRv4Z11hugPADU9mzHlSembzsMtPJpTocQK +1iQauw59x4XN+r/nhNq6xxDlyBzlsT7aJL67JPGvYl5TuBWELcWyeQyhjDg7ON// +MEaRa3jwDgz7i3EfOOAiBXt0P521vkmIfgCoAWafA+2HFecB+615BP5chZG36Pak +HgHhLGajhXVT/tJiPBDFhJNPEU4vkZ3oLRUGhc6cKJ/t8wIgPE6oJw8N4QPynE44 +w5sm8NIp2FZ7Kjkum0abKBiiuAImZ20lL2sw56aaDZRvmy8N7zB7vsjVzCwvXTJB +AFRkYgiOv94dM5zk8ZekpT8/rPTbX8NU9AQIJZF11UCVkY7Wx+3Z6phSLfbDEaNr +0+0Y4JxjnDINWdLs+1R6oU/QIkozejTGpbT6KynskjAKwIDXF7VqhEoLLcsqqksb +ogzbT/yBsNxQVnTxUmUeW8CZuSDreihAV2chcZh4eFOVa2ZSiov3vAq09OI5Rrjx +ZWv37F8xB8MDVmvmUuVj9ymj46CoezCdg86fUN9Tw5GamT1CDCx8fn2TxloWseLn +u2Sg+1p4oYnw2oqy9Pa52LkFYWFXpn59oFPuOQip1RFLD1dx22WxYAbZ3vp/qu6A +KarWhHgvGgSJAhwEEAECAAYFAk6nHXIACgkQ+7dXa6fLC2u0fA//Up1o99wHI1Rw +HTigyQuDOHXmpJijjDWBapOjrLAXpAl9hBqDSt9fLUHw0Y/ueGuGhQHiQzqBtIES +NZGvEuNph0GoLx03W0c4oRWb97QhaT/KLNim6Fbz13/pobdW65AzYYL6/2qzC6Cr +3VH+RzwU53fyIKKlAUtyx9NIV/xqxUqVtKmbV66uPSmxoFdcRoGR04vs4VHPLUk7 +wuaKm2/uTIRyfnePsbvu5++srG+T7kG+KS+sLOmBbWmicU3/Bm/0xSAS2gVZZ/Gi +SACqQUTAt2HrzPqGIYrrJSyJiTC7EqvZwE/9LFDx/teRH3dKrOON4wj7ttbyB8SG +Fnb774nX7g7RANGz0s6SN6c6/KykJLelXsTemosEtQqpFGBNexdZBg4kL7lvBYju +porW0LB3lIoaowWqAbaBx9kiJpM8jsrmmQg7UYuz9sTjpg+EqnZhle0trYpLooO+ ++JJDJH0hX+o8cEwWjVDx7kfKUC1Nlh5FYrl9H1N/ZYIJ8RmozA2LmVmzzBekFBXK +jaSICsSXQd3YTIyP7MzI8jYnqn6hNOJrUTW9Fn6X9+uocP6BsMYE6RdOf19yu7Gv +j57uHEbZYMQyngxiMlsm9I1488MOfNLzHPhvL3yVrltuhE0w6dKTz+5KBCpB7Scb +h8j1yswuPTdT5XkkKwjZZkd6IsaxZTiJAhwEEAECAAYFAk6nL1gACgkQLqdrnCtG +bZ3n7g//Z4GX5y11wr9Zeq7GrjR0qfZZVcdbt3+14NELv9fcrdvIWeJ6meInopGv +ezyUesUT0UiD/fiy6/Dk/VTWk+xECdNfBHZWZGEOwCA1Q85riRDiDzsKSXXGG5Di +e709kXiKZoEUPLV8ENU+TsP/+H3aScZUYbvAXJi1G7CudgdLBIOzw/KT43OceICB +uU/AM1JxMO4T0rMTiN/RxYf24PqKnNWnW8riyd5FoE4q8+0zD9J5Q+R9EtGWjETA +l0+MoQ94+HPSnLUMVZ+ckXvvvVMfBa+w7aHrjMYHrex1qEGXo1fc10jOqkHFmPB8 +Nh9YyGzSlanshWCCunD7J5t7Ej35YGcdyso99idYHgSXqhdgnSoj0ukFq+Fr4uNB +uwN0l3syBRES6dh1SuBfI5Cz+wKQFyJrlWT42O0VakOU+UwCsiEbp7j9FMPnFv7p +IK80BKITeMWW4tB7GtDg6JC2tuhrzZAvKKtpvoylhco/T+TH+TpFGv5Yw56F8Gb2 +md6kQnT4yuIhkG0LC7aa48gtLnyFBO8XCG5LrWUkf9C9Fv6P6Fjk9QjtFqRKeiEI +rFAvA9ftxgc+LhHoNyhBzwjZcifRhDe9Xhbc+c6gwYjBL7PYX0NLFROUhTNicXtW +5amAT2OP2ACcb3rj+CUwrLLUxII3E/Vr3nJ6XPvymEPqVAIgziyJAhwEEAECAAYF +Ak6nNT0ACgkQ7ulgGnXF3j1kYxAAsP/cJRR5jIWm5MJIin3hPWkmqGmi54+1lPKX +W8bzRuUkxF3rIxSJRawkbe8vKW5Ovbu4sXnoYAWzBXu+U34YbVHH9oj21QOBneNj +r2ssiUxgMRczHEuTwjOeiqCHFUFNJjpJ9owLnq3uesdpHPZld0Ft60jsk6iJFdEo +2gO3aFhvrRSnULO4FUnef6nTYwtx6gCCNW2n2bMBirzieeBUTs4NJWdUMKx4Tmpi +c26x5yTz+wn8GmdmF71WinGSUtOOlI8NRGI3gYBTJigCHrytM8F3T+IN1jWV1D7m +Sh39syb8wNm+HMqXXnUyVLTlOxr11Oa7FfboMk0rwCkjBQe9xIBPo8eqq97PqqBc +2XleqlAkhJbK/I1O8qRZB/QJFidzI6S7kJXLp1OGjevkmi092fb3l6czZ49hRQ5h +MFKPPjryLFnNhLah93cD1P4+W3kKEPLw70PNdamrP0Iahi+U7ScWs8eHJFJRo2yF +eRBcnj4PUQTRJvbmhOe2dyCzIlGgoSiRWKiOVckKM+YAGBsCzOT4iLiJ1UmPm896 +WE8qHIYQcIwvqDD7enn7uOyj0Iko026JCtFiNQkwpoCqH7B/+pjAQthnwpd6L/AR +DI3IhZrGPjKkLAdWbEWjsQ46skA8Rw03ySp+nrIbSeI5GqnjWHWy4Je6cM9O/71O +CZPoGXuJAhwEEAECAAYFAk6nQOEACgkQY7TwGX88QucdjQ/+OyUPrMCvByNBGTRP +PXrtjy7+wOxhvwZBIWEhoaAPLhvIcSx+7UiOebMoBIuZWUWNWQ/LVFEE5XgxY9nH +f0DNW8MHQgptItbGz9iImu2x/hBh4dnAEO0UhEHs2+BF4X0nMrzkOjN4Ge3j6S3j +0lIFInVbY+g4ShQ5g6//IzVHdjSBwj2mzJ3QfqH0D2KaMRZys3ctKePmgl58GpM/ +xfRZ2uoQTX3azUidMKAMeUtUn95QwyrCV1qfS0VF3AU6Qs7aRgfnB8Y99hwnV4XY +cHsNK1kK6p1NhCE1NXyKGTAUep6cS0o6ac5ZHOCKFxmC5PSDREFw0Wi/rrs5+VEE +znWvzLCken27b+BiZQ6cJQBVyjpwE+c4IH7yDDIL9/mSsvq4AeVM529qcgZwMd05 +fpvHzRNRcAxnTJG28m7qIlA/j6rID/7HbLLI+bQkpAzUd0uJkbmeSb8Xm1XRV6/S +1NiDXUkt/gST5wST7ADfcK4l+m1zH57vVCK7zEgQE5MfFKJD7i/h+UE4FG94nCMU +DbfQ9QefW1ZyHC55BTWXbsOId2nNVcNyuau/yegIqSgbTox/1AoH/zaf40WCfuCp +vxoMwar/v6j3A62Qq6K2d/sMoD9pAFY3AwNolKC0HVEOXpPYcAEdDecmV5kgcDum +hCykKHj06Vw4hkE9Zuif0MmAkpuJAhwEEAECAAYFAk6nXfIACgkQHOUKkwgYupzf +Zw/9HCqiq8hg1OU7mnjJsk6wjFVwGsKmLMueXtH3paXZ5KCsH2lV7FmnGGJiCNay +M/DwpbH2brOZg+OQ6hoYC89XIRYXESqYyxklpLysDBIsrs73a8EuGbz+0xKmx7xm +ZO725TnV2pGrJRTRZ61brkGSHtvWfOhMC+C/xppJNxapjwa1MLkQYuSEMtppopO2 +xoEWFUnRMbSA5zDwfh0KqzUj2PmeEK247NLN7AcrO49bjTlPqCX9+4h8mEKZ0aiN +UbwK+fLGYLeTaP+60a73oUn/9Al45NBiVAwkQteR25CtGOAIzWpj4aTU30H1QvI/ +c+5IcUdIInKgzPxGAB1Wxs+X4dxD3EtqLDp5ExTUarFNmea6syq2E+OSWERCNfgo +vUh1J3zhsK2pCRwje2QyKSxM0fayDw3r8GD8tyQnddEzRCWc3FkapGCkAUw9AYUp +mgfS/VXVSYlDgR+IDIcmh3SlQEnbxGV17oR7u2NZNUXxhnaI0oTFNht2luDQjzVO +nect3nDjWdZL56aReg0GrOPk2PASKPj8/ny196dMHu1V9apQhAqKWIyOi1I38Tnv +RzmynR4ZeXmXirIqEnKJNv6BE+bvwRHHwDsFaZXsGJ7L6Z8mVa/90rd9SuNO5I7O +Tp72q7LkDx5IpjwwAVlvEO3xslCVcpxwy1UV6PslFavRkTiJAhwEEAECAAYFAk6n +q/kACgkQFbyDNEMDjYzQng/+Kx9jaRH4E/olx3PQpjFXP7UhZY02CECwJe3o6Gu0 +qHYPhclG4TcYIJ3ONpoBmUe5dMGGXM0JfKC4ngyHgNCoRbPsVDSp4juEEXZv6xAh +tBDSwbMvj0pSBQwk0fG+Kr98Yps7/2zKYiEDbnuP75zfXp2di56j0RciKtpvZgaK +yY04zk/aLknAz5WkWLNx4Js5f0LxWFU/YeSKmYNydHy7idbNJCgkA8Z8xDzCex7N +PyKhqJtHvg24/ExhiZkLEW25eDmG7PVcDtj6JGLOCs/buFQW4UPnJGPdkoZxNzO2 +usyvTdEcBf5aRUzLwaJQKh00UmhLKxkv2/TU2EtZbW9qrfoy4ZIn/jf3iZflDuG6 +m+1spKyAiLWnBSFLqlC1D1SCJCKv8ML/J81CUYsLl2MtKm2IIYQHdcaL7du+X/sT +A0jV7Pj3JXSQtP1A4htgMh4EY/9hJoy3f4KhxJKlAzkyLbID+3mRmDGbxJr+u2eH +CBAXxyzf+EUYbOkc4aYw9/vT/YPojPTeG/6Vk7xZ+BG3YNBSxoeyxRSZ2mzCM73V +5r+p3wd4uaGZl0G+a1N3kv/L5PyMc+pOK9S+TEHIqrKwEDRN45HCKjnc/usdLc71 +FG8Ue62WMtSaTJ9v4ZsX643h6daHMP+ZAy/5Ixq6fo2tFPsFsNeZMh39ZVn4Zdji ++0aJAhwEEAECAAYFAk6n3o4ACgkQvSWxBAa0cEkM9Q//dWZif/5QP9nnqjdYcStP +6ewn8uPzLO6LSQ4H2avcVsiVzYkP/k78LPBg4DMsK7J1nSbBEqsD7F37HzM/yX9R +ScQpDDxot3cgq5h99hAtVnBOD58CYW/HNZxOE/MBWurKpNKi9XcshbVVGM+lSNSg +EpE5JpCjUhlKqZRKsylnqGbYRTUVNMUcfFV3xfmj49rC/SzklngXmU3Da2kJJeZI +AjMyQMTXKJ1AF6CJ1BwnKmbAGf011HJ/yY53zhuQBK843scV/C/1Om6HMzivDJ4E +OmgoSvuFR1w7SF/PXJTgIujOKsTkhva6R7bzB3pGP6kDp7rJSfHcvooMwO2mXRow +hmksHqOHa74bG6ydaVW7VD/e+3HK1c42NxwtV69w4FeuUwRcDWyQuOttGerfaSaL +XuILcwyxyT2CN81RL5R31o+iZKggOMhur9bmbTOMIt/vdZUTYdyiGBDxq4wnUJV1 +smT3vR1JNIm3m+XwoR7QzYMhWdcvtadL1Fm/mxzH117A3OE28fmFa7oL3xjuNPTw +nGRAmt6jHQgYpHs+LzvUqaqPN0nGUlLZhdFuOJ3ZPMGp3RVUVBcLW8hAHWZdnUDQ +CIzxDR7bI48PWHBoX0wSXIEL8s8gLZYm/Jc4ziN5+ihLhWI1HtsU/LpstPaq9h48 +4jvPZCC3SjjMm9MTTpG+6nOJAhwEEAECAAYFAk6n4xwACgkQnr8S83LZ+4zcTg// +VcVoS+DERa6n9aEArxz53siOC4CcqqyeA4+lUjnI3E/NQQgy5DN6naNIhu9Yql4l +Hkh4kHozd7GzGEGxCa4jffreeZYMAQ0Q6nUvPgRPrir9m3Dk8FMlq+ROxy9GFlwR +N46XSxlE1NqVVfrnDzut6byfejx5nQ93nse+cxNX3i/KeuELeQ3DwrTirnzkqeLW +q3d7NCngy7JxyNIouBGI0eDJ7JImDDuTXn4r09Acb+rhgIr+2xudyHXPuJmYnZGf +8oA6kTqu4BVry6UGYbK1qotCIZSJIklpr7aaknEvwIlHf/oHL8jl9v/93tKVRSeJ +sSO09MizSZaPAEuiZ4L4J1V7J5DiWarLKKW7OMfhkGvqWgU+JeQNGcKjwpcVaoT8 +67u4xIM7OVIH1QrjN8mjNzvyDHeXSMCfUyGVjJE3rohnwBfakzwVzpdtbLlPz9ts +JCuDEbCRLho61qA5CPES4CXdBVWI3/i1n9+C36c71L40ZKUR6QZmULhtgza6G0QF +r5NWs7Xf4gXyp0SifgFv4B/rfcp9aSs15TosQjAeLlUfYqvL4XWNspJyP+AxAvnr +/nBKFIHgDRPGt5XVuZXX8oNr7/Sj8sogkosqWAITlW0/UgDt+TT6d+jOgFtHxyhx +5WT2RIRpKNHdBSnj3JbElgAYKVf+aQQwoy7KhCtOF+aJAhwEEAECAAYFAk6oU5AA +CgkQ63UUWPoRgyCE4Q/+OBGeuJgm6ULZLU8SQEc77TgVno/EzuuXxsNGolD383P2 +r6yrgkWxxcHc/kkCQuKP3Ga+MXrCjfJiwU83EvUPZUZP9eqdeeTfTj5tbuoMe4FR +v4ezkvD+hfD9fER8bKq9rPyKTKRG9uDTmnwlpYy11tm3Ria6WIRpOsKt0zkYYMfv +D/YDS9viXaKzoYgOrueV2u8ycA5jrTQE+aDU1zG2WO8dJ7Tfe7vVtlkJ8B6YzAVs +q1+S4DwrbfEYleVjcYAKj+aKBLbHA2AgpsXoS5X6swbqTzcAdyLPj51E+/spINqn +2y8DLkNHlzHsvl7pwXCgTMhzGEwy+fmd61gI8mnp2RRS3Rolmc9GhRgVnVFYKTxR +Is2Ox6Xu0EzZNfK+1ip3VM5PhnO0xvPdpD7AdcwT7HD96yqxaH7EfHUO521vgqxB +R2imL+sYZ388BJvko+AsyeLYvChmTq8qa1UekoTlpfcx4+m759uPYkplkLxrS1nD +KZsybD9oFCqQNF5y/AzjlVLWJjZvDxh/lk0LPl/uAk1bF8e4TV+K0FDJk9JdOjgI +kgY0m1W24gzIQ756OuDbPiInD/1DuogKYDfGUaNa+F/JQ1GKyHvKK3ZLmpx3yzCd +Uu2VkUK3Oo1DzImIHaJZM2217NMAURTLsB9hPtxRP0z/41IvRMFDmStwp2JmGumJ +AhwEEAECAAYFAk6oaBYACgkQfMb8M0SyR+LG2BAA0su0g9o3nM+a9NLzAtzFu5rh +4quJQAW2XGOn8LRRG9fXRdhaj4qj9g/20y2fR5qBI9RwC+YVc1OMyMtbVkkgg7E4 +hHca3gbQ/2s91OLZSnTkfyfiVtp4KDsUDcT57DB+UJGYjfDU58SLVk1ab49oLUwc +V2sLeoyjoNb2PRAUqmoQzNtty/qjlNqqMgvLSkKzbhZtOHmc+bz0jYxfAXZqtBPI +iWxM4XcJ8taqmUsjLGSMWzM0EJ/cf8gUhkVAttEzKpGRfAV8wdN3wdius4QFbmdp +aCOs4FFjWDLFWwORIhoklDq1ac41wOJW2xExBKVisZc+lxFL61bc+857BzM9nJ9V +/mfX2RSZ7k0SxPSOpj0TTzZU3F+GNHVxWAuQUMwf2clQNmQIDDWzgDD/ymkqbqSZ +Cr9k7/5ZenSP+utp7emqe6Kd8OOaQ3GHXlU0R75WBG8obhq8LHcowjDD1sVmTwlg +Ei3CSDaEqfyXQ3wlzQ9TJG0G/OoAIP6MpQJGiRKvfZgVUuIbQnC7UkQk6nHbEZXs +UKujybFt1vxF15s5Z9McE8FQZsxplLhtgfUTUKd8xHdUrxHyee/BKr7LLmtG7mfj +BBxOf91ZBZHmp6k0j0YCbMNLnrGfaRAuuUrHFczBzReNKxcr/HyB8wXNe7krsJFi +X7t0EUm7BRvdT03R6JqJAhwEEAECAAYFAk6pIygACgkQbLqKJDkZaP4WpBAAoz2P +l0+mEkDuaAAs0nfoOTsceAiIRkt5kGA3mITHUDbYKHpYmTpRXhZ4LhCdZmefWO+M +0l/BiMQ/q9lQhu3f8vGSNre/G5c81f09Il7iQri9BC/0N6ndiR6S0eVGsDpAjtly +m69CP38gvrBTjuHQ4LeFb2bI8iHoCeYIpaS5Rji9D134w9YuWSAbxT41wdt2Rp16 +l3JbB7q8TK0qF8qUa+xO+ESKH2erfWbWtdq+Zocy22iOpqTlAHaj0oQ0uqAv6mzA +8HTH6iGNBBfuGHI8WpJA8gp6CdFoolzbakTFMoCiynpMqIVZer6xCwsIEuHGycvs +gwK0rnVV8ToohIuXP7x68PwQyTgp1LGD8ps2bMpMS46cmxpqNietd/L9Qnn+swZP +BcGEEOCYyBCBr+vHBcTrLaQlYQSQM6/t4WzD7+RRp+pIEm1edNyryn00PJZmSK3B +5OtQomWdkwib7Sl3U+e91jGFof8t5Xs4hIUyV+0SEN4bK+dn+c+2uZVSFEA8wu1R +wujw6dHaBRtEkIFN9j5ZEHmGBo2tsgrkuNoFHM116Q1A5hbegGDC25qCh3fVxsgA +jzObPbwhn2S8YbiLYZAUi7Pyv1wpoeGzUCbPnh8CeMbrrVPyVko65arIfSON7nZr +XKcDLHepqaFQIgbh9rxvL4esCfA8mE1GrgbX1kOJAhwEEAECAAYFAk6phMoACgkQ +pVJrm7PNTmpMDQ//fxow0ZqJdJcSUz56FIozfBeOlkaodr9XITGc4lyHg4qwj/5e +5EKLY9etGRO5dqtDW/w9VYO61KYPCmf0R0asCSCWreh40bLNi3m+uxL0VzsFkIG7 +oOo7hdVzJWKH8nGwcq//q49a16VvB3Viu2OniF/BsBWYvMXumw3qY+RPKXnSfRd2 +0ChmWzzkBj/eVgRi8nHnEmXVSUFmqF7RoP2KqAc36ZndEl9JhNVami9f9zTlLgQg +6rrw2UGQ5DpUEfYEzsKDUTKO5U3eb2Sgsn1x2gi7haXkFukQ3N26Q0QW8U0I3nkt +SYAPq8BCK/vhtqVz1jfgzuHJBC6nvOP3ShbURSP6Px5Hc/6I7nfFliHgCLuj6LhF +SBethdWhcZWgmZ+gu+ajnbLJHheObLs2hnt1PCQySxD7Un2gf9b6IPspuNFFkzUf +nlo0iPCe6SXVyM/NbKQ3adKft5hlhYjS1Pt1Ei8V7X2S76bP/6WsBXigzMu1z0N8 +RWe2xxYfiVmS3KK0FU4i+ugHRamh98BVsd4vfaskG2cfkqwi9K223W/MO71H3NzY +mL52RxKrtpFPX5GRJi9GNFB3oRWZNYxtLVrmInsI3YhzXUYLwsG1KAIwBzoMvpnh +CdSiTf1gvC2unjBSTX45A0KrBbA48Sa8LCP4BQjd2V563FLj3MvtbfRMOQyJAhwE +EAECAAYFAk6qmyAACgkQu+l2vyauXdINMBAAtIZKzEWFmG77TigapDmnxIURXbhX +oKv6s+0QvWLME8gw5EwEvTcNINgyNJq1+hotNeGNQMMhfYgIfu/FUl9fTtSoDD6Y +ZtV2QAu4fOMYPKj0YUdK19sqwT3/xdOZ2TkHfOIfM0uvP8P4yVnHP53rOEPYQFA9 +DOKcBH2act+KRkBC61yTL7VUmAxwBhPjcubY6yIu/8cUhTS/i7uNzsD8D+98atuG +GcX0L+KdjMZkeQBjhxFQHASp5wtfloZC1D0DmMknWVeLFjxuiswQmWq4gI4oegJJ +HSI6JPu747GKLu0YUoQBLW4QVoWFVZIB2FvOmHPAM0uf0Ev/NuAabTXXuXzFPaBf +4p42dae9Hk9SaXCfd2jY7afwdo25u0hDtp9SOtIqQXwHisX6DQ3cPULbC68XS+bE +B2BcNZBkUdVRwZaNIhRalp8FXq3F+TsviNSFiY4Rl81ccDdK/sGlsW6rKLgHS999 +6aw2K5YpXb2B9sSdQI4co0yap+rvJE+FwjBT3MdZXThy9NTdRWzTdjXmuapZ3nfK +6UIcqSW8Mv6Pvt3ufCL4/MfZLoW2dlijm2THXrrNjXVDvKTCACx4LhUNXGN06+iE +ewO7plSDU5hXA0qnMdHGbvplXli6sXFCyZ6vQAfE9lIoKGGYhyVtwmEkXH/faH07 +qN/7isUNxUwN4fqJAhwEEAECAAYFAk6sVDIACgkQ+zc9RfizbSiTpQ/9EZpSIYOU +j3vXcv+MSTPphvS50AyKyUaI+ymgD30jWsIzMBMEIztnZwno0va31VC7klt045ep +vIRaGJjnrHZh8mzIlC7YY7PkJUrjElTL04wgxmUYqzfDchhjmAmaoPnL29DDZqo3 +9EP1N2AlnH7b9t2uLfT4BogjMGbakevuyLXnJBZuZxfKNf57KXA5bsgTRQ6fWEOF +X/SKS7B7blxg20v6KEoivG7dySahTIrh3x6JKjoCnKOVGG+pR4LB21N2pbultl0P +qWWcRVylREmJe9rkZeqlRFc/XTxTYNBF+wMID0LPG9cEoZ6GSsfNigL218QemdGS +O+dzNWDlV9im0nDiuf7Hlv8BBQ6Hlo7ao5G3HgRruobYZVZsScLzbNdw7sXZp+9h +GOrfGmJ7Z7PYi5uvMeEWotFucfCcZtGHk2TDtBG7DPDYzYfMW0Tml8KKa4vJ2bA4 +LEYu7mhAt4N+aQaJ+7YxKRoHHzshJVjlXjF7GmPFYFJNuFu3sWUIrHu9PCl23ReX +WAZAAhJETEMzEhHAPFC/6tcMf5ZRFAu3AVp9mAlP+ccrImDgofPndditAtgTDhRe +KQoHzWpxRc+vj/cUDWWytuFpLI6AYqfZU+pIvSg65/c7DiZBNXN6A/UGK8ilKLCv +sJ3WGfXSYEmeX/6sB8487ZfbHHWCCIC9NFmJAhwEEAECAAYFAk6t2FEACgkQ68Js +21pW3nOeaA//QjGblIZM9gALNRhAIEUzTsBniDleOBr+znO3/LNfgirrwdLtams/ +HkJ3RaJdSERM1NW5XMkHdZAC5GKScPAx7Th6STDzhnOHKdgnsHcfh0HHLLv/0Me7 +y4iEukSR5QFm1X/L/CYMK3SgW2Lj+ABxI6ahHeAx/i8O4Ni65eJpkVuVhbytvyWj +JfhVKwX8m1v9udmrTCculd9YpazxxuEIzmcsprIKhjIJB959+ZoMJ1gTX+YQGzK9 +O59eU19bFEjn4bSS22fRdkKb5R/B0meVdsQxJaJxjkYQKItKWlwWu0obA2QX3a8B +/9unWgYqNVX4yg70QJP7Pgyn1iiWQFMP19ubT7ifEj6G8peUS/TAg4vaU6a/Nl/S +ok2NtoHbEnuwv5RT3Z+E6j15b+/HrV9dMG2LdUqR0nxB/EnqUn4TZgmldJLoxewM +HuZy7jvYRBD/7i2f2lWoa0HDOw6e7AzJ6/pbUIh7VoxPq4H5wgUC33TXbXR4iLx8 +oh84wdwfTPdZVXkHnZIBr9WyqdWecDBxQl9FQCs6XBb1z/rHPzDGMjpqVV+v93mO +gKDf/JarQAHv25gDChOZkUOJav4GkpQC71FCutrnTYopfo+ePmFtBq8WSb5Inwfk +CEX5Nv930e/aisQg/S0WV9fScUP9L5D4tEJg0Jl5cH2mNWzZ5/e2fACJAhwEEAEC +AAYFAk6ubbEACgkQxycdCkmxi6f7zw//YWIaw1M0IOw4F8OaasYN/o8dtIQomeur +k9Zya9y8yswgRfFVexVg+nd5Vh7HtyfxQV4CSFG/FzJ1yoFOk2JDnU4q1CnaPFl4 +iK7EQ6gu8X4ljC2f4AgeNyPTah0WySyD+mwa3xX46JEnZyY8VZQSLFDty+o3dh4I +hLIxW/mkr4hBxg5rKz65dPWRFNzqYWc00/WH7VeQtd4DS3nc733sCwdz7RHuMUVf +jJeowY2feY3esZC9tODvQiCMVyk8aL+ef0p6C4mwQfTHmYlE4PE+iQAsQZdn+UgQ +r96FV795fxLsmTO7FOaTtcQSp0LQeL89F1l/5++MbOg773JT1kzTfdTws2JzWnoo +BWaXsjxMFkhX8VbdNXPs4tFyTl7mVujjRr135Z/uUS4t/YIrMinOgbz5mfddMLAS +pxA0qe92JBnNkAF1wyH2Yw0p+MBN4D5GS7e1ONZYx00TL4GsNmgWmjOTkPR2Ok9+ +qBjIsJHsnQUlJoUo6O7uWv9oG7BaE9XSletVuD/MsO8vRoC96oGSmU1DR8Xns4u6 +Ju/nS0hkOQoq5P7GImPAZQa8P2asQskntEiRB5SrZucRxtqijpuMD5b2xxO1/m4e +bnbuluZoHMEupFrEZ23qqjypedePHR+7E0nnRelRWbqToMOvZkXQvl2czVBKMkh3 +SftWEhuS+92JAhwEEAECAAYFAk6vJ0IACgkQjc41VjAi5XpPTg//QzHZRiyDL8c+ +gHhrpwUYtJPbtX4nEY3OyTguvAmD/1QjiVCtmeFmCNxRxAJAFpoX6x8iN7btqlcm +UaX1xomgspC75fYiddo2wyTCMY/9GL4YQm08KXs60QfCqJMq5hRZLqrjHaFQuxU+ +0RHIz/V0g910Rf/OCgmcTs8C1FD27rvUzh8KN5xtThX8aELiVuHcaQu8SsiZdVYx +dPWAeSwbSPqsmVmuURUYVd8OLNwDhJhU/hCRXoNThn9yu34oTl0pPmntJimmvwck +tPWYy75HSGFifA9q5dv8XvV3AjPjAIViRjUHZwPcBeJRznur0zuJKwHxH3EvexBr +9FKsV9Ps27DMOBK1aFSiKNpvzHYqt6eRXspPnXZ9mvfJHULH1bwf93q4VJnXpMS1 +rn/8DGcBxTP1MR4W4b4B4iJu8jUwAtm6MPb8KtC+mFp2vbJ0RzK9ArUuiyUumdnk +Met09WOBv86YO8DrIGfMVlpVskAwJrIt1FMmI+48EskO12qImH+9MLEEMsjiLhCX +EVzy/nzv9y52r2J9f4BXpOesnuEoU/48Nmh0oAG1Eluwd8WjtiiadblJEQ4TSpCc +sbIZ1LXjHePfk+kHKJmMBQpfHana4HBzBygjapKg09gJRROtk15vkRD1+C2UWJAA +j+25eVRsY0tq/jG8DxAlHHoD2zH2ZVeJAhwEEAECAAYFAk6xpZEACgkQly1b9Nxh +OAagNg/+Kaj2VWlgBuiq2g8+jN/vkjsKHqvlhT6YcAdCs1WzOD7CYV/s0bQfNBLl +u4Uz/wvr86tx0FSQ1zxYF3XcGKATDKWRS55cUC1bn1Zu3cr9e66R1bCFow/l3dQM +O0ezv2/kBGGHwVuci8lEXgzyIS3c3C7vpu7HpdsrPoqaCePsE4+m/k0szeDC+gBs +Wlq3hjP/u3Fye45NGxJliRwleR2ekeoA3UbyPl5BR3cFTWHWNCAJY9geQDoD3VGP +snVVcgeGvtl2PBIprPbXsT+XfewN/mSKWCOVyeiE+dsZdNg3E/QxhNzH50hXPlfS +OKstTfRwgpomvE9dgPRA5+/fuuokgbi4O4AxLZkC2/GP2XsGJA8tXYp8DCyxixaF +r0MkK1IX8kFoRSUNcRZMPFA23kgVFxBpxrSS/fratwuDKI16/HWf6muPbsPk85OX +GRBZHuYl0/+3h0A4/LGXG5fLwkCwCNsNNJAzShyslbieldNSkcyTLpK6mrSlxUoj +4xoZ5Uw96ql3V/bmpBr9N9e7DvQqj7gVInmVBcSxQ3FKFNGxtphYn6A6Wa7tPPgc +ecwzC++SmEG32/dEaH5IpmiSPwmrVatuJd34L16nNu2M4nyxN/NQhgoproEBrz7u +ZGiwfokNmqJvK3hYeV6CNLT7Ef0PXNE7Ht8dogwPiEn+fgUaLkWJAhwEEAECAAYF +Ak61dOgACgkQEJ8JhQb/CxQjUA/9HuwNjQIvr9aulYP7ON++qXQg6bSZAVydUMJh +NudMg6YEbDA/hlj9uOyEFTnWOjSS+kV7pRg+Riaw5O0SCQZpUeRBQZcgkS5AL/jU +L2fEjymcgQldyI2uD91jZyQRR1HiH7E2mPfSuqMuYtY518e8PxqXVCu3a2lwz+f9 +L5Utv+oY5dZCKSmK9ULFE7B0cM+Kdyx0uJQR5swwRk7+0JqS9QG8dlV0hdh7OVPJ +fiukFLB6zTkwVks1WDWqHpk6pu1Kh0QnogP/xed+TKdTtb0U52BYjmWDzMNIoaUQ +OTemmZztcgyecuxTYyQgrrz4RL7HzgLLK6RCM474n1KEmcd9YlSDuuob4tlTrYaP +uEG/JcyDYeOvyFDKjRFk6NxNyXXTGVGE4vfbcLonpxMyKWm4MAgI11xer83MNFcI +AcF8+2uw7hFdmBQeeeS6m//uBw1/IwREb78y/LaBI+KaqHPjtlUJUwdIiQAo+GVo +hfAmBZPtmRVic/+nD3wVv6z3zJeDC0In1/NooF6Mqg+Rw1REKeHPkR9VsqEq+AMm +ecTAefkGjMX2xdxvhvDXU69kOBKvOyGOr+KwX2NmvsdQC4PdMZAqr0Buz+ol+vw8 +iTaBK+7ZwgN6i31JPk6MbN8zac9oF08zcLhHiD8NgxERouOMiTxAGN6CSIbidPJ4 +09nWRvKJAhwEEAECAAYFAk7Te3YACgkQdkfhpEvA5Lpruw//WYZwfmzJZGTorfWw +Fk3k6z1yuQFvJiPiG6NO9dyENmJVdJPOFBRonHe8yVa3DBghgq45Y22iUzEEO1Ef +WZRtf022FUsW/mEtPpIG79Q0bL8fuD4m3sVfNOZ1/PUyA4mZiTR4eeDWrVMLZW+N +q0ysONhoMrltFD3woxmQDnzc5aGhGiiJ4W2G2MaJa/s0Nke42dzuIhg5SmhYcUpO +YTBEPnqW1LV9rOcgjdD+ytEHUt0gyyKAKXJv77zvgNCISB8uWkqNCwzO+kJnr1bC +4HavBEjVaODgIpWGQLWM3wr8YHApciju/7u2I+A2hcljY3WitQpsNVwTqP3aZdAU +ULB8Ze4+wvOpWbQ7aNjVUGZR+y75EmFJdNoLyFWr4hiD5SohQYEGUFGInm1XSwRK +mBgfBzSO7wcJaThjvVsYY+D9cYpEln/Gk76EEafcmDH7PcCOersK42ZAK6FKL1jg +23wv2VPFnYyYfNE3B/SatbcmJK9W72KYoCtkmdZe0Nd1nda7jh7+d2P8eouArM99 +qQ4sRNHWKNxULgQGG0+h7J2K1lyt0HSpDD2qYALWK2JQeJws+g3qwLYTfi2ujKoL +As3CMUf2JUmTw612ZfluyZK44yCleBiIYxpKbSWfwyF/sUynFewxg/Pd66f0WUcG +oea1nLi2jwM2+bOKbWc5QtABo1aJAhwEEAECAAYFAk7drSYACgkQ0292m8EYBPAj +phAAzpYnM2zc3+lggghaRVDGEYao8kZ/k1IQxxF66ngAVGnPMLQkLBEJfZzW2tMw +EYdljTOJq/ftVGbz1PL+iwM5ZquI+urinxF8iepprLPsOwQRn5MgeYEFbL9V1//f +VreuMAjyXTdMGVC+sel94Wg5o7oSrVAaFPWIkteKDsOJ+Iv52pujJUAgxne3bIqY +J8OHZJyKXxNYNnRhdRrCAQikmpJ/5VC8QSS2tagEnGw0G9pJTKdu+lKwf7rHhZMc +rEJvOkGyQH9WpshxP9iCcmqR++frh9AEOok31wJLALk4Yz3Fz47xAHZIxdIPse+G +246RNS/ZMEAJruLqYlDoZhEBaPthX3QWEIhEDiuEqSmxmA36L4ShYnujbVLmjyar +BGRBCqrhRbAT1orY88yOirrVADov9l1fFsXa9++aVuBZBCBaCW2PB4nj0PaZVEOF +UR/rUi1n/nNQ658Giw7uo/yYS4r7MKTr65vw4GnQtk1JmJYHH1K3T0QMAZCQpGEc +lSsE8QzqBhwM+MmaNZb6yPdIGw9JlH7iUJHPobQNagTuPydBgZlOKgaG5qPK2m6m +wbc2XL8Jwiq56yLhstg0SgIXyM9NYaUPS085pykQWKOgplkkfMr+dehSt9gnFSyQ +3LUVltzWHTxgG/KcojtpjOjf1Fe/FnQeblooMRim72sdaw+JAhwEEAEIAAYFAk6o +ZLkACgkQ4PNz83v5CZo54w/+MCK3zx4B3beGRoYqDXYZYDvfJB7hCkUHRMHST6Y1 +0L3oh5HxE5bzUInu0h8C/E6LQj4RMqKz+UGqRgCE8rSC/LtfVgaCRq/SqjC07mbx +60M1BWfS+ww33MPeAPtiG5HHDNq7fLZs/mdCVlT6YU9WXHDWr2EMAm3BKF5U9WAh +Qb1d01ueNd/an0JYIp7OZfcI4k5o8kh+x9H7vY6S6cLbSes7lpt6HBQoeziKnRRg +hkHH6AISLOFpyr3DkIULKTBoBID872pTHc7LCCpdyROVF+Mx2yd7bZV/BBvL2Mgk +LEkWBQesqo7xs6UV0yjEn6HOblC6oDXnSxgkR7cuW0ZwehU2+nRBI96YX52vBKwg +7/V5X+qQz2BeLT+mio7KhMKRxA94h8kUgD2i6SBVAVmZXLLiwKD5TbiaztcNXQPS +FBadCx1phZbpaDNu2WLQN62y+PsNSBoz6CNs/lD3nV5rLtinNOaAf5LXZkZHMIOx +PQx0TvNL/abGXJ+0XTudtVgkqgi0MyNYJbGTbBckRjmTjjnDI7WUxrZoyMWNBYR1 +FK4JuugHEg3mhTxmxzft+e6/6kbkx50Ni/ujB4Oz/KCmxCYFAw+OnivvXGQqcJ9U +1YJZA4WBzRpXGMezmbkOodNCggu1Z0ql2myz1LBZY7O/4crH5y/P7vIpRaWfgOBD +KnaJAhwEEwECAAYFAk6ml/0ACgkQwaRgcltRy8/Mog/6AkoDNOsu0NEMnPymTrd3 +u85D2SyUrOGYYBtwh/Uv7O7ZiNVw5VyYKFx+ffZhDG44wtkx9+gUG58O6VA39P8c +KWxMM43I7jhi4aAmDaXy/ic3WTOiR9c4oTzeVBtV3zgTVI4Hd5iEiNqSwYClODGz +AOfh7oVEwFZ5kmX5n0KW08E+vuQ+vBcwt5nNyb+mIn4ek4UavKP3Rs0KqNDLqssK +kDWW/I8T0cnr3ooHJxoRG7LrmfZEZxAD/2sSMH3v1lxVAq2Xq3mM3KfM1p95qRJ+ +PgHDoosBfDArDenhAg1WM6ewuJyMiXSDuXiaCPiPS4y44lvEy5zZmvtqXdoI4dAH +34qOvXrWHx8Pk/hhYKIzD5D712PyKQbpoifKH9TfQbd3QStbR2GO97QLJ1BhOQ1p +wqjTUOouf+jZPNpgDRMjVB5DSiQh7co6bNBrwqn3DgeUJp3QdGkxhQ4iBFWJELny +IWhv8ftq5zSAhEMeBqhdSDbOZuhFKM0UeJ8TZJqTmGc9lvz7tUjhbAEMzrrsimnr +hZ2NzKszvtxNlQHpC4xUwkIeD/d9HKoJgzRDTqPg8bg0n2hqPtWhNDL7Qgq6CToK +XgdoNQlD+tNOY0jdSoHi6SRbEtftXKDObz2/Jx2LVQMU3InKnwQiLqMd28F/F8X/ +H9P5+G39nTYHnmGyg9IZT3mJAjoEEwEIACQCGwMCHgECF4AFCwkIBwMFFQoJCAsF +FgIDAQAFAk6by5sCGQEACgkQ99NY+ylx4KaVYRAAwuCHOG7iwOSMfQ4LYiuxlzcd +f7Y/tkyJAX6R8t6a5eT9sDOZBmpPnoL40emJLsHqqRTUHqzS/GRdaqbQb6pvgVNX +rC5CZ/+w5pgqksY34twgbNSnUahwh8sI8Ee41qEJRc4oCFC8Q4GhlJOhLXyntHqU +m+ejz7073xBRNfRYZJVPROCaSfo6p3zT69JCzqJxVcvC6TmARF91Io23pCxLvQVb +W6dm4zblrLAorELZnzo5JgXcG35L7uI0lekeSo7KHH4fCCMX+m776ms6aBwG4S6Z +zI/jHd7rGzB382t2lHEXRFkcws5uSaTnpKToN970YD/WpfDqESouJaqIDLAfk3ou +OxwuSIBKybB50oY4WXOtGnItMYod9rsTIbm1Kc0S7IyvVRuTSfZBgKetAOlK59r6 +FKTMLiBS6rzmky2IVQknBfoRXX8HfeAxENsRPvatuuQpOfwmpES9n0gEOKfwe4I8 +FVU8CmeDqix4ZXcWWZSRayo//HneMYFBgrK06nMDM/xLe/JfV8nGIRF9hkW57Ka+ +2XlqWyOLGZg0nRjr1fP9exPzXnxlXts47gXINcBSVDusMWVbxSMY0MMkgXKwnEyo +W/SSWNAwfV3q0rX02dcJX25QH/0rv7anjX5L4nOr8D88jjlkZYYhORNuOn4RxqzR +x3Qh5FoMtKIxQN7N4j/R04fThQEQAAEBAAAAAAAAAAAAAAAA/9j/4AAQSkZJRgAB +AQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwg +JC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwh +MjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIy +MjL/wAARCACWAHADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQF +BgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKB +kaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW +V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKz +tLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QA +HwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQA +AQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcY +GRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE +hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX +2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDktbunu5mmkYlnOTXP +SHmte/OF5NYzmtJsqAzNQsMmpqibqaxNCBfkcr2bpU0IycUyRNw9+1SokkSxyujK +rnAJGM/SkzajKzsy9FHxVyGLkcUWyBkBFaVpYz3DhYIXkY9lXNc8mezThZXPd/hn +NDJ4KtY4iN0TMsgHrnP8iK7CvB/D2q3XhGdpJdStrcN/rLZj5rN6ZVen1yK19W+M +M8kLRabYqhIwZZj/ACUH+tVGdo2Z5VfBTnVbhqmZHxGk/tXxlcrZRtN5SrGxQZ5A +56VxFzAlnn7TPFG39wHc35DpUuo65qGoBlkuWEZOfLjGxfyFZX2R5Oi4B7moS6s9 +OCnCCguhuWOlxX09tALqKFp+fMnfaigDJya0Lfwyt74lg0axuo7suwVpo1O1e7Hn +rgVgLCSkasdxQbRXt/wy8Nixgn1edMSzgRw5HRBjJ/E/ypxV2LFVnSjzf1c8KvZA +yABt34Vksav3G3y8hwT6YrPY812yZ8/FCVG33qeOtNf71ZmglbE+l3a6VaNcElLi +IzWrZ44JBX68VkAE9BXsMtrpF38J9Kt7i9htdQihMsPmZB3hmxjjnPT8qluwXa2P +L7W/e0gR4443kV8MJBuGO3H1z+YrSfV9RvI9kl1J5f8Azzj+RfyXGfxrKkSNmLhg +CQGeMfwnPNWob+yQ7TJgj2rOWh7GHqQkk5MnSJgMABRUoh9TmrFq0FypMUqNjrz0 +qx5A7DNZOR6UYpq6ZQCAdFApyICctk1YaMA8kUBB1xSuHLY6Hwb4Tl8T6myBxFbQ +ANK+M9egHuea9/ghS3t44YxiONQqj0ArjPhjor6Z4fa7myJL0hwp7IM4P45J+mK7 +YnAzW9NWVz5vHVnUquK2R8ezDrVJ+DV6bnNUX61ucyEB5pr/AHjSr1ob71SWaOkW +/nXA+YAj1Gce9bermJ4EBuGuEjUKCrHCH0x2FVvCsRuL0w4GwKXcnv6CvUdD+H1v +4itTeyEQw/cjMagb8dT7ijoPTqeIzkGVJlGCT8wByDVK5OJD6jrXtl58J9Pt/PUX +cm5eVOOPpXBal4LlhY5lBXoCB2rNyUdzdUJyV4nHQ3Zjk3ZI9wa6GDxA90YopmGE +XYAoAz7n3qEeG1jb52JrNvrE2Mm5RlT3qOaEnZGsVWo+8dYs9uNhAeTcQCVHArq/ +Dvh6LW9btLWGUTQFRLOyKwCL3ByBz2rlNDSK4srdU+eWUhQP9onGK+gPBvhk+HtM +xOEN5L/rCvIAB4AP41EY3Z34nF+zop31Z0aIkMSogCogAAHYCopCSck8elPkkUdT +WRquoy2yAQICzfxuflX69ya2bPAim9T5XlJ5HaqcnWrcvU4HHrVR+tbCQ1RzSkfN +QnWl/jNSWjq/Bmm/2jcm33lRNIsTgdSvUgH+f0r6dtreLT7GK2gQLFCgRFHGAK+c +vhcgbxXDu6b0HX1avftV1y209/LlDHPVlXIFS3YfI5NJGFrMwdpVXGW61yF5EgQ5 +UHvzW7fapZ3m57Vw57gcVi3UyLBI8m1eMHNctRczPeoQtFHE6gV8xgoxXO6lHvt3 +BHPWug1C/tDIwV1J9qxJ2SZG2kHIrNRcXcVVxkmjP0u6aGA7CwdHyu3qDXv0/wAT +LG20qyjt2a9uWiRHlXhTJgbgSe+fauH+BxsP7R1iK6EDTMsXlCUAk8tnGfqK6G50 +lpdW1m5nIS5tbhUUxoFXmNTnGPfrW85qmnJ7Hkyk6jjTa2K8vxLvbq0nC6dJMykq +62xOQPYj2I/WsFvFEkxEkug6qQo4XYcL9Bir3h+a5sNT1LVUkb9xdfZ8IMBsrks3 +bAzXUeHbrU9Z0bU5xcW0saNKwd1b36EN7U4uMnoRJOJ4TIk0MCeZCCHGVY9cVRlX +HIORWlvhZN5ZXdOqPnDfiKzLqcSyEqioP7q9q6zmTGqeacD8xqAPilVic45PoKkt +M9h+CtsLq8vCUjIhlil3cbxhZB+WSK9P8WLeJp80tpGrOqFlDHAOO31ryn4N6xYW +OsvplxFJBdXpRopZAOSAfk+hzkV7jehZ42hZcr3NZyjc0hJqaseUeFru+1K+aG+t +E6ZLgYxz096xPHlw+nam1tHyp6ivX9LtbEXDLEihhzwP1NeOfEZll8Szf3QcZrGc +eVXPWo1HOTh2RzZvbgQRmK2TD8nHb61UJMyNIU2sDzWraoPIww4qreLHEpCHJPWs +5ST2GqUluzL026k0W7hvY2ZClwrkr1ADdq9nk1COZdfuoY5hBc3SOjMuAR5Ufr75 +rxGeFrrULO0eeOBJphmWU4RM8Ak9q9R8Q32r6LIdFn0+aa3kKpFcKMhVHAUY44/r +Sqwc6enU5JpKordCfQZo08IeJ7kxRSTC+l8oSnCFxHGMH/vqpfhhrtzqfhnU9Ki0 +pIbmNNi3IjIilLHBDHplQc4zXnzyatLKNHj3XCSXMkiRIj7kJHQ5AB6Z4zXuWn3u +h+GfDFppkl5DalYQcTMEZ3Iy3B75NddOnaCZx1HrbzPmGWY4OAB9KqM1dPP4QvXl +cxXFsyZO3L4OKrP4P1Ef8tLb/v7XRZmapy7GAoLtgfjVhYgBjLE/lXUWvgxrTTJL +7Vbk28W5QpijMnyk43HHb0q/4bso5zC62y7bhc2aMcfa8fLIgk6q+QGX0/GtI0r7 +mUpWMbQrXVbW+ttQtYJQ1nsuULnBKBwAVB5YZIHGa+pNSnUWHnKCA67uRg8188aj +4glk0/UbW3RzbKnlhSxjba8i/NtHyh1ddrbQA27n1r1Xwt4hGs/DiwuVcSzwRiBw +T1ZOOfqMGssQlFaGuGvKauWNPlvbSOe4EqxyTMD8y7vlB6Y968u8X3kdxqxnTEkE +m5QO4YHFehX0uqW9sZhFaHPO4ksR+leZ6zcSMqo2nqI1ZmG3g7j1rjeqPejF6zRN +beW+m5X7yjDCsHUXEMTux4AJrRsWzBIyKyEL8yOa5nxHe7YViU4Zz09BWcY3lYit +V5YXKz3X2y1H3VfIJG4Ak9gB171rp4v1tba5hedzvcMjb94j2cYHX8T3rlohvQy7 +yrbS4wP4h1/Ic/hV6yDqkaoWUNIYscliw7AfdH4iuxRSVkeV7Zt3kNvNVvby5Es0 +7s4OQRxz9BWrK9zYaTbvfvBfGabzBFM7OVBUDBOfYfSsto0uHWNljR3XKqhyVH+0 +c9Tx+XSmPbXM8IVF3qjEAnA/A5NNaETfM9D6CuLTQgNz6VZkn1iFUrnTtEgiWUaR +biZ2AiRItzE9gFH3j7fiSBTrKNjDHczKXLNtgizzI3+A557YPpWHqepRyQy3Ek03 +2RnMBliGJr588wwD+CMd26nPOScV6EWpRvYyry5HyxZm+I3l1S2vLe3SS4uYsSlo +mCw25XkmSXpIwAxgYUdBWdodxZTWiWkbOLdtVSeOFjnyI0Quz+xbgcehqPVJ1N5a +QXsKStGA39lwSeXBZRdw7d3I656Z59KyEiurHVRamFbW5v2a3MY/5Zbu34BwKiT1 +MEtDU8NRWuuy+IZbyUxRfY5LkNnB4kWV/pgBRVz4TXtyw1DT4ZMl4fOSFjgMV4P4 +4IrKvzFo3hHVXswSL+/bT0kPaGMK7/8AfR2D6Kaw/COttoHiCwvskRrIUlx3RuD/ +AI/hWFRXi0b0pcs0z6Bd7G+0stJ5gbB3xlsFWHUGvONSIs2by2ZoyejHNd1q2mpq +EQvLOYxyMvLIeGHbI7159rdndw/u5X4X0HWuBJM9hVXFGPLqixlgo5PGBXIazK0t +78x5CjPtXQNCsTM79FGSa5S4lM1w8h/iJNaUoq+hx4mbcdS3ZxCfSr9f+WkAWdf9 +3Oxv/Ql/KtKKWP8AtIAdGnWYe2YiT+pqp4cHm6uLU9LuKS2/FlIX/wAe20gDRpHc +xIWIiLsPQBAuf1rfqcVyZGjXT4yCj4iImhK5bBdiHHuMj86nWGJWC3AMiBdxMTbd +4PR1OOmeo7H0zViQXU2pvCgjS9skL2yooImj67Pf5c4/EUmyN0gNuQLa5Ja1LdIZ +v4oj/st0/Ee9PlGpW1PWdZv1lN0k84t4bdNt7MhybeI8CFD3lfHzegwOgrlby/u1 +1OG5jQJql5B/oUTN8umW/I3H0baMj0Bz1NO1C/tYJXdnW40uybMahTjULzA3Mc9R +nn6Y9a5++MzebaXMkZv7rFze3LPgxR44iz26jI9cCuuUrIwjErX01qtpPZW1wG0+ +OTcrFSJL+Toef7o/zzVG7V4ZWv1uPNEUgAkz1mYb2xnkgHjPsPWluNQeUQyeeIQq +GGKFYd5hhPcH1Ofr71E8SNFFMymG1MuyKInLYUDe59zx+J9qxbuaWJfEbzQpaaYJ +G2RxJJJHu486QFmOPX5sfhWR9nljwjRsHViNuOc+lWtSumvdSlu34aWcOR6df6V0 +sYtr4XGn3ZkhjNz9oS6hjDvDiHeSASMggdMjpRu2Lax0ngvxW0ujizmc+ZbjaCe6 +9gfpS6tfJckk9a49PtGmanDcysksdwvyXUX3LlezezeoPPqM9eiSAXQDqcg1wVIN +SPWoT5oHLa1MFjMKbmZ+oXk1zAQlsY5zXoht4GkuooCI9q7bzUXXKWsZ6qg7yN0/ +T1I5S9FvOJJbO1EFvaFEXPLv82NznuxIb2HQV0whyxOCvPmmyrpSzQatZTqmWjuA +yg8ZZCGx7VprG0drHcbhHFPEY3J5Ch1Yj9VxVnSYR5en3EmPl1VA59nY5/8AQTVe +9LWunWUMsbSwODDIinB3xSMTg9jh60t1Mbli3t7oW72yv/xMdN/0u0cc+bF1ZQe+ +Oo+hFSvHaTOhBEWmaz8ysORbXI/pk4+hp8Ra0tI5YZQLnSitzbO/HnWsmCVPrgsO +P9phU0mn/aJNV0e2ykcijUtOUdHwMsATz90nH+7VpEtk97eRiLfGDDa6dlLKJ05m +mP3mYevGfbAFYczqI3hkbcoYSXUpGWkk7IPb/wCua0p9RkvHVb4uupWqlIt5wGPq +3+1796xpQyvsyWZGPJ/ikPVj9KhyuaqJXkFxcSFFDNK/3lQ4+gwPTirv9kziaK1k +VlmKn5D1RAxA/Fmya0LGySzTzG5lI/IVq3CtbWF9rUj75rhMqfcbUUf99En/AIDU +wkm7GlSjKEFJnGSxrJeukfKByq/RUrYs59upAf8APaOOMfV4WjH8xVTTbbLqx6eX +duM/7MJ/qKakhW5glB5jNsfyY1cdNTBmloKMYJdMkjDxXccc6g8YKkoSp7Hr9cYr +T069TS7O7lu/MmhhMaoIzjzfMzt57DAJ/CqkKi31PSnQEhZ7m14/2X3D9Hq3c2Lz +6j/YNtMskFizXdw4AwGZsIue4TzB+betOcEyqdVxukY+sahcaldLahFhsoZEaO3i +4RerFj6tjqTzWfqURtJZ7IfxQwTP9Soc/q5rZit0bRr2/ZdpaKWeMdwuVjT9N35V +mBhf6lNcSfdNq+SPSNcfyUUctiL3NR4Gi0jUYk4ZES7T6xzFT+klZ3iG6P8Aa0sU +aqYpLoX0IPQeYoYj6c4P0rptd+z2sds0a7UkFxZyjfnJaMOO3GCynmuANy73EEr5 +LRKij3A6CiTQonaWsQja3WUbrOKT7BdQy4JEMzM6Mr91wAQfX2NIwubLS4biMMNR +8N3nlPu4JhZjtJ9s5H/AqsWlvFqFqlqoDRXlq1qrjhllQmWA/iu1fwPpVyxK6hqe +myyf6vXbBtPuDnhZ1+UMR6ghD+NapEtmlrvgVLlS63OHUYVmGSPb3rlBo7acSJ5F +mkU4Bx0+lFFcEG+U9dQj7TYjkkNdBotlHrnh26sZmZfs84mVvUY5H5qKKK1pL3h4 +v+Gcwh+zWkKgDP8AZtySfd2dT+lZwTCOf7ogP86KK6H0PKR0FsD9rhyeY9Xmx+Kj +P/oIresxHF4m8WCNAAbUMOOh2E/zoorW2xmzndXm+zwpaKPkk021T6AsWP6k1V0W +1X+zftB5PkXCH6FkX/2Y0UVNveK+yHim8cahfWP8Ed80qn38sD/2UVzGMKT6UUVh +U3NIbHd+AbOXWbee3ikWN7MLcFnyRhZFYYA748wdvve9SX/iiys99vpFiZGS6kni +ur5VZ4nY5OxRwOnUlj9KKK2jsjOS1P/ZiQEcBBABAgAGBQJOpxJ5AAoJEHm+PkMA +QRiG+ecH/0eU/780943YHYtyAtuNpjd0A2pW/PqFbnjyIJZ2NW5Dje52oyzJMZwL +r/XbqzsQ5afpR5wXn2SDguZ82oflieTShGqXxt0fFd8FJGEoP6BlTimApIKmBqJH +2z78K3b8NL01d+dGtjEOqJqPA3lkjfliWGuhpsjqDhMenzZVWm50ogJxNZ39a0By +I69MTxLP3BHP1mUk3kagd9wKmw/S/QJrQn4VPZFCaYP0aJPqTYB9Tbnu+BTxflr/ +TPJ8TMAtHfYm5+GwIRa7bVSFA5+etFAe5zO1/Ks02birrYbruC83oqtBFyld+zA/ +Ln6xfKltSAaNf+mo/wBLmkr8D+Ika3WJARwEEAECAAYFAk6nFtoACgkQyDsHRd8Y +jf6xIwf/ZVEl0q8pdkaKzBiIBEdAa4y1ERFeRQwF1Mp0PoxDTY9FVGpXu+RCgdwH +Jz30A9gckc6QWZJhNv2zs7ToS8Var//c39STutiRUl9I2Weo5PxdY2OFgAL60S2y +o409pQMqCVGF72jbfb4LrUuviq2eQog0p49ydvTx1ZkNCuS9u1R4isywRubsTFAm +pidh0/5wyz0EQR2wTl3jz1v7wDFtPD7/5SyuPiQnoqwHO+CmzUaRT9cNrED5MBjw +jD6PvGnpgqwVQNevwZ8Ri+AQLvRUMdYYqTKOZDHyezzql9103q3edYo1slL1uP42 +SF7aBbSmtip58pdiZ9U+3zSGB1Phf4kBHAQQAQIABgUCTqjMcQAKCRDArf/6sfsc +GNObB/oCmH1n0A3I/UHHGCVznhdCjYwZFyjzO9jYsLDKPQ9RYG6gYmSeX3ctHLfg +oz/CPTUDU0/qYlVK1HW25JMStVHL1ly/caKSPDEjCjRnkV/+EtzRUEEBntqybhaa +Pqe2VuqhkCbNU8SwBAcltK/gZBq+Un/4aiUdmndzOJ4Q5Ca/QDB3rQt1wnpLR5nv +lgHXKCktAGGki7d38ATHIpVTFe0NFjwenwlhb5xBzxpug5IuQW7cDPLr0/yesV8N +0AYw6/YO4szUIGT9tn3bl4iiwRaVQ0w20wLo3ltzv385X9FBHQLmLHkJQj3yftHk +7OLHh6Z7Cp74DgtWMcS46NJ/u/X3iQEcBBABAgAGBQJOqYlSAAoJEEHdSxh4DVnE +hRIIAJcvCsG/sRejWFAWA+gwEk33Vy8yAmQgQjIHgLQGwRUoW8Q2qQigOKTi1UKv +1E0+FXJA6gfid3LKvh76X5EGZiQgaxOYl4kCeP1olfiMY6iE4ChyCrZgbOEGmC5f +WxgLkDjSbCEMhvn9nLO8iAXlsGjWBTGq07JnZiQ6kZO39JgWkn3X4+YPx2C/wZZz +ZKoAgbCsNhPbnGw6aRX8/jG+S/a6dc/4GLoXLdurHL55t5W9lyzwW8p8Xjmkok9a +DjV2DqPZeCTJlhqbGwlGSEwB+aGdAHLJ1cfYbXgPx8qigkqL4Yobt2Jyg6nrqYcO +9UKOzkFz7ibjhgx2GAD07rPjYpyJASAEEAECAAoFAk6pDNMDBQF4AAoJEIFK5Hwh +SFTWrSwIAKYb9uAMLMM1NDEfMZK98xXF5cLdYpZHzah+98FOQeDBH9CWE4WqAyYJ +YyNqL6I9IhQzT3BMmfZy1LFt4AlcEp0GlPBkMc5ojuBaWzZ9kIsD0IvTSgMOA8Vd +oGzUt6sBYlXKlK9XpnMy0YKuGI8sXsH7bexzdXaI0sdeAFQI1SG964WcZVZTSR/M +Jd63zZcRn/uhCf43No4Bxxo3ASfupkcGRg+pwZj+naTtwTNWTXdw8EvtaJcNi9Sm +OxGGrsxEYKU7BixFI0LreaaTrUD7xj/tQ37QUZ8q0v2BFEanyFJDBenAp7kvqGzT +9YfPfQujc4zQ1DGF69UHtupLpdEvJMGJAhwEEAECAAYFAk6laHQACgkQbDGAVD0p +KaQ9Hw//RmXD6T2Dy5hKgp2WF/9Exw8MAXldKL+kKIiDBC8l/yoOdg0Ak0R4jEnL +V3eVkeDiEg2l6Hgee5fJzBpiUMuih3f7kYM3kedg8jNdK0trcUeKojh/LHt740zg +bkTdMMMA3AzRtgyfpw5v1dxXaHb1DgKwzDtxMg3g+uHzYtZjw5a8zJawPVHTeTrz +HIaMhmqAqoA/1zXiyLdGBQ59Uo96W/CaOyQocGtc8+thg+ByEEOmMYy1e9weO3AW +BipiuL640lHahisWhYVfnmbo+ivQM0lGEjs93rm482J0q6l+pXqcoHkvzn7dP6eY +jbsoh/py0m8rBp6dC3WRBAX83rhAFWMhbXXxEHEVOe2NUNy92y4XsotrWzDMXtwP +LgSokeBwaFCzHjbjIcxuZ4/JIuzt2VnQySCXqVA55ychAHtz2D0k3WdSLuWNiBwj +X1GcbqwVaR1KukxMhSlyjdPY5bPnaFpXP+r0gDXEcz/DaidkXUTZ1DIac1q1vZlt +52eeOQpoLsihpbCjnaK6e/4KwP785jdaMxcPGkq3cP/bNezvK2c1XnzkEbvd49ib +CILeSkP5+9ODQeun8Y8vJxoLwfjDKt4YNGKDtXpObULQU85dTlZ6vykcZaca91c8 +mKodTeJ52bmFhQW9H2IO/DVfV5fk+wi2NBmRkk7K0WRU8v9xkFeJAhwEEAECAAYF +Ak6lcSwACgkQONu9yGCSaT631A/7BLuby9xt5m5okR5YfGLnnGmCwwr1Ypxkm0ol +vJVu2hlqaR1e1Hsg8QuoqHMkLwv8T1S6BSgynyBxZRxGYk81pWiUO5u2C2ch+hGB +75VjUId1/ghI/Rq4CBWq312JEMoSuxyqqwcbjcegvnDxbnUqifu6O1UC0PjgDZi4 +kSqqeUiNkC/u4YpkRX4dZcT+w/i/NNB99hiFUFFFGlpG6NxokVVX3UQrwDbHGe1E +C6VLkQmlAvCUCVVph5aDaXn8gP1rgU+xMgGOylsq0G4m/6coaIRH0sxPunVGBFR0 +GrS+Z8R5qT2eTa1fClM24QZ77OrxunNRZAfE/17g6MIl80GSMKo7KVF/4E7adXkm +Lr9APX/GaDbzlnDIQLouQve+MSSCN9X/0ptMTGjjuJCdLOfUEfC2fC9CzPUmEcTa +2+zq/CGyP5odlJd/GdD1o7euwjS9avQw3T4HD9J8L6FEjBLrbItIF/YbpSQuKLdt +vu5JDO3bp0kKEEzjw29gRm3rgXxz89k1Ba0dMehxnvTYSi0ItWXfouzRlS2+Dr2W +iMC09c4j8s05yqhbKoHizrUZy1HxR3loxEoUfHJRBtiUlXBFZ7N0Q2juCvx/HveP +8fMenHpUg9Pg4Cdo3OyhugN6KoUo2iHPDYaGckN9XmEv7KuxzDV4LKncA/4G8dga +NlsUb4qJAhwEEAECAAYFAk6lf4IACgkQqE5/uaXy42xH8BAAiZw2sFfIvXekIrBR +N7IFIL5eoD5VxGCYTG/TYd+xYtbxNUw+FdJJ5kM2HfQasXyLwQcXmCsEzyxZ6Rke +Dcmy2bzhB4HlyIoEelS6ayzGGDa9imsekgsAN8EBvGIN/McV52xNBYLqMcyN9N5F +i9QGZPRtMDuqCQfGRlLgV3QbxUQFtks4QTJEEBSKvL4Ov7/Xgt128qS1n/pIVTe1 +ZNb9tPwMtmxQ3MqJRJxCaLmAXnlBD+AeArf6YGljxnR++PUB6j5gh7yHPB0gLPOm +hQ5QK4iR8rtxUqEmzg2GG5XydpKCLiFIHXHfPthqdSdmsramU9M01bp1RqU84UFR +x6WX8yFIi0U6r718ABMSSiSHqxpu+09UtHdo1eWB4SljVpfQImvwriC87HLGgLey +wx0Xc6ciLKm7Is4cDYM03PQwdullqa9dwGKK07XkaCDcJeEKN5EvvGg3zfV2p5h7 +pgVrj24kZAG0D+caBFFeGHIU8h0QFk1//hK/NvDmKrZwXbuEjpeMA+ZjFAI2oRC5 +KItcDUOMpYHjr7iEVpKf51pwtnzDjkgGCbN6Jnjwa4OHCMPwqnHTSka+TgU1XYK/ +WVxkUyZCy6NmsiFjai4CGwZ7wjvb3DsESO0iYMBl5q2YvitvW8updrTX+eCHXfr8 +RtgdibmR5l8jQq0HQLyS+Vxa57eJAhwEEAECAAYFAk6nGCgACgkQmOXcyBZHtyq8 +hBAAph53pvzDMAwiqL4vsZXHv/fNUSHoSyeyH+gRhJk99e3dkandU5DJ/DHWEFYN +0dYgoyUTT+v36bS+wKR3Sd0dLnWAKJP4IZiP4fUjTOZT23ib4UnrmF5VUecj/Wpo +zMO3TXiEZm3N0gOJ3CbGDggKmi2TSY1CiErcrgzDCKiMpBQqweCPe7xM4FMmMdbl +4cyvhmxUEeyJErX/q1r0E4Fu7ZMlNwLoVxNwl2FNUwUyzVdtGJgMbtDr0uM25N/u +emlr5sg3VEBqtq+FCHlADOLqeLb5TLZDz9RIO8NNqGJoQ08OBxkquoSmQLDWTSI0 +RLpYzoMu85D/N3Ed/UTWRW3XmG2GWDL8XZ0AMWDtq4mza2+FvM0cK2qg0w1m24pC +TguHkJHxRcr5cpf37e9R0L0lc1IQbBBxFHwlrxPxrq7Fa1nD3p5uWRrckDpcinUQ +WeZw3XVHdhqWja6wFy+1kIV7nxztnJ0GkEUL1LPBKPevTNURwlkxQWrHTeNCCdrx +RO21ErwizydOyroTtmCc04xDmzW0JP+sIdf3mS+BO6L6cI0nRyuaS4rutHcAoLQV +/YMKrZ9wD03UAhDv/SLatzf/h4X0QOHDprjeZ/5392fZYkGHXe3BFhv7/Dnb349K +YJfCGExIxj/WLMR43t/cwFgeGt36ZRI4uZv9xg+pytBLNuiJAhwEEAECAAYFAk6n +HDMACgkQvaBghUk7rOSHpxAAtEG8YFJ1xYZGZvrmeNfEe1bF1SNnpRNUKno9NRtX +rEmuyEWiF5emyPZImbYsqDRBaV6dvWWke0Zs2TBCjKnSzbVgdvJ8Y3D7m2qevU95 +n/RLeZQ6ik/54SNQrT8X+1eYtoKYkjIA29WbbRib3/rTa8IMl/zzWyg+AtEJ5W9h +1xzGwgeElFG5ooWWSy3TN7HRbM3L0eiYSw2jEBXjLiDOcN25YXS9HATdSuwQ9snP +W2nMDCebLKb4Fxqb9JQGl5vIppHZ0rfO9y4fwGoqmtOeNQdHwerricSq3pXSGuez +QxnhQiBcURmftZEnwzYrIUkcO7RfuCZ7RrME+mTtT5yWTqeNpVFOC8nG+M0txCiU +5tYkd9Xc9rrdTRHD551R6I0QeoEhADPHNzMWKxYrNF6ZEOuuwtFfYp5WIvoRf5pa +O08hNE+F1tsCrieJDdStKXjWD3NMuyszpECKGz291WJ+feZ/IUWHdPsy7OuUtZSG +p5u2W3qL2STb5RhAgEutqYrALYLvTL6O+MVjstarOWjFpIuDxm+s8HRhWgkTM5+8 +YPPcReuS8UpusJIMLD4B21ihkEvnhxO7BspOCekC5sKKupIAmBrFw7cyiYhaQv27 +/8orRfKarqinuclaVUQgfuPB3T5rtawuz8KrQqS7vNA1r0tZPg42xHngM6ivB52N +0q+JAhwEEAECAAYFAk6nHXIACgkQ+7dXa6fLC2vdURAAlPspmo4EU1zddH3kDLri +pnyNLUT/ca36mVMHqorDfNV+Bg1i6XT2sZS2q6xtaZrCqlDJv8rJ5zeO0F8F+ofF +mO3PfDuK8SfMBdgJRgK5zF8mM2fTcYwaF87B3laOTQazooiWzsR45CD2mgRncD8f +LgWBNouOfADINNEOfEpkWTj1KXIDGDZnNIiyi5JhPzvTBnkcBvnKELcqkn2U74cg +zBhKZRMpYq9yYZIz1Bj4VPQyeNxVbbMEVwvzSoNUXsPI3u1HNJtIOwdWvqJ5NSb6 +iPLRCM3Pn5Uj3AN3guQVSuolRoigLOZG3+PbkraIajdmxpaiLCWq4vGvxzFoYAx0 +A3mASgOJnypiOvqd77oQZfQjYVmjJGnMcoAXtp/mfOo0YaXgKSDkJeiAiLQ0qDGa +mN5cuV21Lv0zF6Mx9TQi5ykZgywmORys7kG0lTv8/4fO8i2750VZuOzSDgMUE56k +79fcYIybdX0OVb7Gw9F6qeEiUcmZfeOld+3rUABHItLCRLbGYZWX7qsOivKf9nRS +KXAFH5iGdtxQR2jX7wI42F7/FGA0C9XuUF5K6Ma6DNUBJo0YOCD//ZBIasqGt2Q7 +MUeoiTTMXPYc1Nf/+/7U98gdkXW9EIj0NNBI1M0WHt7Vr7oNUwyCrSEUS2SqM5E0 +uCPnPX1PUCMYS16PvKpWLj6JAhwEEAECAAYFAk6nL1gACgkQLqdrnCtGbZ2AXRAA +qD3VxCpBJwmG8YqnD0hqNDBkyk9qg6HcxgLFIj8m1ig+49RhtXiF3LxJ3A3U078k +kM37ckgbHEa+HCxM0lVlzdPYRDWh5pZ+oLKEWckmpa229E+SK309J2P9Tfdi8NA0 +2pppVFIEFmR1+3AWaoO4PBj+2VOjDXREStzXo6zynsVhYwvxPFkxd0zBMLMVGpCl +4NMkK7/UOStZBBR3y2nXdIgSiQz6L00+Bufk0GQWv0Sb7yezwEFhTULJ+RHq9sAX +hnfU4ymPhASqYA2wyOAssgNWVDWeJz8LplqV5R+m+9FJfpiq5NvpzQnQvSlGu746 +BfiSs2D4CUG+tyIGwd6Nd8eNYwcCrq4UpEvt61mjcmA5NsuSbKHhE5x/zz1XLmLU +nZi0pgprLMyoiKXeNoem182ObgF69KyLjXp970eEiqWud6YwKlbq4Yga+JO8oldZ +JIrwrcSZbpXOSV3iutnbFJ9ynp0xa9bHqKxpJCuKokys0yghfuB48LO6xg2gods7 ++3AOjUZJwfw2ZLUBzJmSTZp0iNAEU1+7bHcyhjby8JTpfS747uZzU1/yAgzIY31C +W5qb/TNZkMAhsZ1hbn2d2ga9TYqsDESIXGUZF/SDKyMlpwyw/ldRxLMNO1LS6HoY +enTRC0fcOZpfCKXfi7ceqlFzVbcnoBpEF38wyd/2BLuJAhwEEAECAAYFAk6nNU4A +CgkQ7ulgGnXF3j33zBAAgKNtGaqaQ3Hjnb0+TiSjkn22SQOQrWcr2s4w1aT9awRC +x2RvscxzifDxAaTPDP8DOMxVDULxeysv896MtFpi2ioHtdF48F8TYPIjzprq4vep +i4KNpITfe6Kq19h+vFqBssGC24vwOU8VsEH22/UDu9QOVhztCQWyoQH/G7U4l/PW +/v//ltcScGUfn+qnSg7sEadRbNKG7ORK3w/SfSesrily46Dci2HtzZviRrRm/Un9 +LG2Ow/YkFgFwDgW3IWqbvw5SrkMBW77wpY6ys6g5c2zo+nfQ71GEtvJAMSnU0hWC +TW4NzGK9mJTMcnjsr78uAHiLgl2lvXtk5qhmsqWfxnl7rb59JYB1udKqWbWQpVRj +8R6uMfTwLguIY5PwQr5bWF2vhP6wRxPCCMj9VdAqpsBnOQLRLhxj+/SumyDo1ux9 +BqpWiOt3+jCLoIxe8mQvnkbZv0B8DcmdFkps3FIdtkVqle1ORdmVxe8aXB3ofbyY +8oA8A/5q4KleqB6JbCcLjEX4mtegbw6ecvFWvK04eanVKdDirfjoDj/IE4GS0di7 +tH64ny+h//XiRHqZZX4Mrwx+Qjz5u03D9sTxdxdf0moTkNihZAA9WZjLRsmcMfDR +DlBCpCunYSZu0GVzYzmi/4RemwwzA4HTFLJnUSsqd40Yd61+9F/3rofGnulXLrCJ +AhwEEAECAAYFAk6nQOEACgkQY7TwGX88QucyZg//Qc3A2uPAhGwgWSTrlYIyGBEr +M4+l/bw6zETwwQ//XKFLeDnqK+lEoZ4YkeBeQapjOt5Ae5xZq0tnApdn3nmyrEPZ +w/C9ZePxsb4MilUm33o3zLUmOYHTjlhnREfog/mtbXqgXW6N3AMj3+BBgHYzxKxC +mLcxNFuOwIlin1h0Ctx21RMmgTbCTIfD72p2jLe67k3xkvJGtRI/UlBfGtsvI9Xy +Ytcr6LpGE5pNpx9i/ls3o52ZJsVs7a5hbMgBQE07ZjLVyacEgiqOXy7AJAWvYWPV +F7HERBw3bbskTdJlI9s1ffms2o7v1mIpCSiA1TJkTE9q8q3+38hbhXKRRkRqfTt2 +kLJNkf3tWW/ypc5y5hygdqa496NHwRxOLjrAfakeNy8i6vZnvzFRDgpUvCVvFA+f +9Tf79jchm4vEtXMJ13XaOyBzBCyHHZMA7Pv4Eka56ZsHd9pcGdsDhJUh4nwEmanW +1gNBQTwg7IXD70CW9ZO1HdXiuYtO6tZSBkxDq8Yr/I3iUhpA67CIQwzVDz2ZM7cE +KgamieHFm2QE/jshYqyjttHl/gXVvQkQ9SHghxpOHjRMS0U0PBHRbOG70MN+ZkOi +0WL/uaJYUvIFIXSzNAnl4/eYcuWwL+B6Y++PCYuEzyPZ9kiRkOs7+GCQ9rfM0UJe +fL/Jll3DiAdmCG9sVU6JAhwEEAECAAYFAk6nXfIACgkQHOUKkwgYupzIog//dR3/ +wrjnBfaf9FvzCbB39Kok2+j9OseBDq6a8prx/apN/0BjkNoZ7tJ4AJQCOzry3b7H +Fp8mv3mt8dUWYnWHd2z5FL4ifGjl8l0KaWo9NM6pnwxi2vJ/Qz35mluebfvHlH38 +elGQhuJq+MZ304hhegOXyK29OgYcrg96M0wYBmN4S2qV7O+qcvZmq/tuROutZ21l +wVxLPn1JKdVRowy3Jw6RrjT8Atni+FbwtyZ1cXXUHh+AKbENyXZB3x2T8dfo5JI1 +1AeuYy5axb7T4TmL4tWB4i/5zfyZwFzsK7Tj3POjNOGMgplhUaTVPDFj4rqHCav4 +Q56neWVqP9jHePQEMNyNZCHFm0w6EvWfbNV5Wn9Icy9MkLnhh6HcAX47Bd+ITumi +clwpmaWsk6LNNcX2Y6omNsaS7XTEKMPZubBAH+J54mnLalFBs7DzxK/kipGdtv4H +3G7/w4L84Wk8osp6D9/lc7seFcaaCzQ+qTwqfwIYqDo38SOHg/XlH60XSWtSKUlx +CcRSEUc0tWx4qwIq/tEKi2b3KuhM47mWBbqssVjNbsWwioai87ho0M2ygo50wxl7 +XSWdNzw4z5R6lkcGkNT4/XE6/xRmhQMh5aOE7VKiz4DpUjumziqUuniRbhmSEVro +5EQOhLD2uOgScZ2i4DbYucSCKdsKagT6JvzuLD+JAhwEEAECAAYFAk6nrAAACgkQ +FbyDNEMDjYxB5Q/+LtWGVSwqLTK27ABIgFRuozwUQlIif/XsuVYarQtJPzSX4bkY +fG9nq1e62In+mowdwLtE0PzGB210B/XrUxtSKjAHccr80BjFNMimDL/iQWr0lTqc +9MuLOnI83LTof04Um60FiapJOgWguzTo26N8465WyXkThF1pSH4NcSPpU1Idlcpb +kb7fw+Tck9oFwMoMPsJSxusRg0bjI3caS1wzJr22BSgqh65Cktm7u+APQyGHUmSf +J1aAkbb3ACYTj9qjII4841FL6iBcf2CjFTcw3w79f3DX6JbOf9aF4eQE8Kg0DPII +DdJlLoSc7vF5Es6lOTRrMVzWI+FBm00IhBOUJKpOMi0OT7FK7bUK00irjiA18mxS +qAUZcFtHT4LuCp0nfC6rb+LUae12kfr6WCihhKDemJXVmkMAyF/ZOJ67Jrq6C85J +qz83mLhJE77HEQsdX/5v+bJZqma9+NPw4KbgZ61NfZpfRW5eRNUGbyaCVx8P5iv0 +4lCFi8oP0Q7HMjTxV6Y6tLDiwg0EJ0hnbJfdproLwwa650JYMuT2L5HfbO1X5P6D +b/yFxKBrSZK4T0EGB4C9fZhx6D2mSMKaHODD2OzSInsyrHivmLsjONg7AmMi2+Lu +m6iA5BwSu978WRB0+WZosFGjhvrmNk+zudgGs9bHT4iwq90aY8L+4lcGtVOJAhwE +EAECAAYFAk6n3o4ACgkQvSWxBAa0cEnqnQ//R/Z12iH+GWLweX3S0GV409YuL01r +Kki+CMLbpQQ2X1mW8UIFuUBZYHIDHasrROMHXhfnAHisGLNhQ0Sk9aH4qcXqpGZr +/ThZW9+6HkGb+2j6M7k5ro32GpINg9TvCiPmS7yihFNRG9vyWLoSxM2k7T7naPcA +mBIxc+tEIohyRSfzvUnY+98fCLbU440Ir7Kb1DqM/HiZRTvTUf9Q3b0v7EuSWceQ +d/Gbj0N3Itcu0lsTkD17M7/1zY2bRRW0ezhPjMbmC/z/Dub5whZKsrNrDCgnIqpm +3bCHJ1XqBvndD1QSYK0jTPpcrn+ES1xwWSdzRNT9pe+h9LMl9+YUqh1X7vqfXHRL +dGI7Qy9uFOB4CPqDhgOJB/ms94fVQu0Odn4xGW9kF4nRSGwrysXydtCyEMTl+ssX +XR95J3iJZ2PFmFDLHly30za6f73FGgEXYzXXHh7TL/mPHvHMDnxv1h7rI4C8n/1I +v1IrShw+lANpfE1bD6BCTYaIHCYvvDuUbHjjfdR+cllILPs4+ET5hX/0T9xLBVRz +2eyzScmydxRoCuDzGA6VBFZCzCg/2zuaX19EPgWuKc7lUxrJrME5ZgMVZRypUiOR +c4L/MCyi57BLrqNKY8012kcaRGH6uMVUXN0+q0bKitc3jIuJIqqGFQySNXM7C3Ct +a+/VsR+XAUHCr4SJAhwEEAECAAYFAk6n4xwACgkQnr8S83LZ+4zX4hAAkjx8cPdf +7AMakYUJgYP4mR0z02oNzXZoz4e1677ReUfHi3INXgf3ZrIENr1R1ygWvj1KAytI +5JjaRreca8I12RVivnoQ/+XQ6Hz1R/rB2/Y3dn1cC+LxMV4/BIrTOBrW4xQYSD15 +Urx7ZOINanhS5IlVAmLGJz6YoEqK/hIR3AtXChkJ/Nx6fFArawaVi4j+/67GOYvo +Wb+bttRrpJqUVMJZmwrUyI1ippcofQzC5o/vWLnwaDcYRD9BrtLonsgGLzGzpju0 ++DQarjdeXYnYtn7jINweXi4uSi93QjP4W2SYYPwdOTocZ5gkgsg5YxM/ifpeCHOO +zTHlz/3z1q9U9JZ7bHtaF40fgao+fDZO4NmgTtRqq0DjWc061LV3FHGKhNGFXzSg +gf6uLsAk8/yJkKRIkxEs2mI8ntsTfe5IC6DmJ8h1gK0jhAJJebZZVQSuX+q3/vJY +Ucn5oeKmIxL7NqsPkU8FIeRveoYjjKZHfCA7mzXtOJu5ZDrdvb2phnXqGGxFIiZK +soUj5Y1YLhG61iG6SIGFxVZ8A9Wb1BspImEEytVh3b99NPomb6QwvWQkZ9v5EHtf +Ta8kkoFVqfe5/3dgy6G9ah9uELweZan59mtxit8RMukducsZxn3j/34ynLUHgDOo +KCykpuTF8LvySSPdqmm62ebzrEyJx7zD5C+JAhwEEAECAAYFAk6oU5AACgkQ63UU +WPoRgyAryA/+Nes6YX0xbYZOFhOLkTyGl90sQpBQ2kWEpEQ+ic/z33EhbV37oakD +PkboILU1YLau0E7vTFtMAbcv01xxFY/Pdf+mlDkICeDXZ1xldbvMAuopuMuvK+/Y +PJJJ0SExKk8SDLZw/pSZ4G97KorzUzrarbNtrpITTymddDQt/KZ4UMgaWB4RZFUA +nUrIyAXJLQuEmvqQViyuMrLVRTcijEynI0bLi0s1fgjI24SNZWkJa/IgDzr+nfii +u7tizFrkmxt3tbVgfpnyQ8Z/pBtXazWlRam9LreT1xqSTd4yZVS+rhS32PDS2JbV +GySqaCtOETacLhhXImCel9yIBNqcEZAfQfM+h6jweTp0xhH5iKdaUob6Ps3+Fr9t +gL2nI7cnZGec0yc61lO2vgXeKDSC3cBroZORV44eqPINmGkvcZD/hnuUzYA/Y9Of +n+Cj/iiK75uvhKclWk3aVx5fA+g7GJ3XM2kf2DaQABa9PjRA8NllFgbNsmnuRDcO +coMp4IoR+pHBSLBPmFp14+vUZlFcXx3WyM+Le+vtShGZmITXjiq6QWW6cMlqgVx6 +hYB1RX+lLUzdCBGJm2LfURvCcoCAyGPLyKpuAtgqcTeI98OtbDGEaw75FdVNIgOz +70fQ6gNacI82lGyG7oi1uQzdedFWX0P7LA7gKhWAIi1WbQ9wsDbs0UKJAhwEEAEC +AAYFAk6oaBcACgkQfMb8M0SyR+IKYRAAwIzxTYyc/PQY7PuM2Nk4mmpvi8R3Ww+n +Gc7CifrF+keKlZeCGM2lP2qdLBNGBSCVLCtD8B4zBvUPq0lKDSzscnmkhkpIxOp1 +BkrQ2nEkk6VHdKtsNYJMeRWvGOiYaXOymuCDbG1VsQAIUXii/0LZmoRFMgIU+wwe +gxKeMebk6sx92qDA5g5H0uOjPnFDhzjXohecHQbfdFJ4vzXWpxYLgeWUdan/YoEK +rr6hFMc5r4Ueg6Nq1Em8tN/TvTTu1jVrvweGR5umsHZW/MH7GIR5vXENEIJINjHO +AQoHpHGmp3GjIIq5VNIxCvrl5KujIhiVLsqmHlyi9ohAsZ3X9mcAVCbhAqAkzdZN +YrXZM5DkSEZDUjU7lMft22OLjS+HlnhYzpdS+YQc1/TSH2wAPLMwh+2Dnwnz7yue +rbHtrqP3SP1qdFMDTlMkuVfkPFXHMvwUecMFICBm0uejhvEswsB3/PVZpW0bTiMf +Iz4/lwbTV9OPXa/t9WeyeuyNdlgQzWpKEAJK5Gfn6BeawaT6R+rIJRuu8X8EGSj7 +f36G8DK2hifu+WkTuu7XA9B4D4UfcFdJlRgHPtSTZYUbSYq06MamFiBh8SP6zCkQ +WIA6QO1ioD2srvlJecAOav+qL3fha5BjTAJSloBG6N7Q7CC+EqnVamfZNdoI0hUM +nR9fLsLGcsmJAhwEEAECAAYFAk6phMsACgkQpVJrm7PNTmo3lxAAjNlJDQkvIkYf +V95KqR0brcLjV3DY/zzpU50URubmxnHoQT8aPTAaN626iGh2JzrSimGq4CB7AEMR +iILwOsM53aUu4v1QmEMmfnynIe/y0dJxopektqKB4mayyNksy8kmu8u2ZpLwVO81 +L8ILegeLeTS8pxWcTKEXYMFH+W9omxEUN+0p1sf+EfsvVG63M5bRxWb2At5epU1d +TWK3D4qjv5leS7PblbqusASYw31TCbH0aDHnsR85O2ZFffudW8hivrTbULfatZfb +2pZVmg40ESIEh5XlNLp8l6i0ZxWT0Yz6JAwfSGvih+i2gKrXmk7VTtwJjQjmP5Hk +4N74BvpnyKRDQqrTzlK0PhCaszWU6OXKJDTdqHOkjVR4FzZhL66tSsRKc6eHrGkC +R8Ov5DXGk7N9KAKKfoWGUyAEEMg5JWg0FRS9hneCpajXGSGeq0PH9IUmrTYZNqEe +9H97ECBZi+OS4g2VJfkJwZdl8ybDnmAWno12CVOWK2qe/EXPuxOwnYvZBtHgHl+S +HdSpNRCZapPoj3Dgxqm0v43i/HuQkTWKP8JHGJi6ou47AZvAGJ/8poD3uBzNFPVq +hpCBL7S7M9DkJRC/WPOfobQJV0OmNuYVD2MM+ELj2ee6XyV0X1QPep+X6ckMhcan +8IvthswOpnD3h3d7rUTqnYAszc/NXtOJAhwEEAECAAYFAk6qmyAACgkQu+l2vyau +XdJ83RAAuIu52P1GI+l7okab7OCyfRPuQ3kKn0wylJUQCz/qHNIRi9wqF03sVZAt +CDgqtpwRIjE8RB3I2agjj5WiaBvWvtInbGbjULh6PfTDUOTNxQt30JHYmJt3Qjxg +TkYscKBy/5hA9plJZuSMZy0vZl5pPgAdyCXHHcQqzBFrwSbqTP9PXpz357VPlT6e +NB+p97qexkMt6Bk3eAj3x5S9d39BIWuIN5x9QGmy+BmHct0mmJ7r61LX1/3Bpn4D +j1Ix1jZqfI23xTcYn1bbqCV7viXjNmm0L0K1EW/lgk/SFBHfi4103PN5Mxe9FXPu +iaXqKjFeNVU0Kwv/GXKONRfg+DrMVRw+A8qJdkIlKfuMFP+ximZgQ0/7PfnsdCW0 +x8cwmxtk7HWouCELzDZFHhScYK5gf6aDXzYvbIINCKXxehEcjO4uQ1c/f/XmMXub +m9rrB7XdApDZEa5X26qn6uDM/tScTLsiM2hXWsZG9OlufBKrizSbZ2bJlb91LgVv +G+CAnERLkd7L5OTiWoxmqkzSTsk5hFircaaDOWF2p40YodiBZ8V6xrXp7Krcg6bK +S/d3djJANT8ETQEVxaAtmtx4UEBoHskoPUuDQsY0Ki65aIaw40Gm75QK/tXas8LP +hVulubGx2VezZeJ5mdvFFKRNwtHT7cMSjexbofTBYFjYZ6TRhYyJAhwEEAECAAYF +Ak6sVDIACgkQ+zc9RfizbSiO2A/8DGcakE46EM5U7Ci5wjxJ/9x/dUH1+9gRiwn5 +cgUkyG6M8TRDOa43H4NgVHrb+z59K9dMrk755PjuS+0GLImC5KiuI2QQr00w9rkR +mJJs5yNZL5Dhk3Nq3zNj6VMZkNqPKvvwkFRuaxKh3WQ3wdpMdnc0SGSqqowWBCtG ++7lPmJNjhGev5EJiSve9jbsv5VD5zWiUxqAthoFJkjmUSt8Gv+9fh8VQGT6Iy6Rh +5nUSbjYrqSChfJvXq8rTypEDCdrZVm6PmSqL2K7cCF43VAVk8qY8DCRFXvJKGUs6 +x3rKJCi15Vmm+9P+QSRc1c9eDZHK3qjbYIfLuxVrF7zEZPhz2F0zCJw4D/kWIQBp +c8xk67vKUP4eQF4NOFZZKFttpvVOSDmVbZ0iuNIU54SAOc/WJ0FhtmBsS3gnPVY4 +bUBapyWCRCnqi0qufIAPAH76MqbbA84FCNomsAwXkU1z1KWpep9GK09pim5pW9WQ +qVUN1596WLWVQTkYpOEQ07KmPy0F8Vv96FBty1raRixx8BaLb5xC1gFMR/vXsMRd +c/HutCcNQ2DhL0r7JxZA5qau76wiBlcJZJHS3VsdL6YOqhLPNkM6GHSWUjVM2Yix +Yf+ezvG4+vmT1+1+wzX8WVxI0cNxvFgM1kDPmABr+CpukAIb2BvCP0Ir4nt5Yy9f +sRqkVDGJAhwEEAECAAYFAk6t2FEACgkQ68Js21pW3nPQDQ/7BoG16+qGJ8JQ2zln +PH4PsCns+5C4mF+aL+hdoGSbbY/4+S7me3fnh+S5QLwWeqWAUxmQurvTB+Wv4m5u +o7bY7lnnG1ZzD5+P0qWdDR7uHf91yrnVMlC0CGFq/gIDXr/6/ucRyukU2ydSJ/8w +Akqyraw8UsLQ7wjg8qBXWlqPFUNkvDsKA++wMoiRuploO5cX6DHsbRfvw2sgaSrj +O5ect2OLaKdVTNJ3UIfpSMBKieVkMUngf7tQVS4hRrscqM7gKMLARkhEP9MNjozO +CFsuJ03ieo4aKSO7/qEod14sHy5DK8PraXBu32yNzXvqI5Xx/p8rnvsic+iZlPc7 +5pyOVtNUVs4LXTfvgTnG4QB1d/OK5GLEJWZCcxU4UlVTdXiMoN2qfjiDu9tzji/c +oOmLtW49VdMlFrc+07jMFIgebLcrVRBFLIyfx/AgSagAhakUF95IDV+s3Q00wDTo +FVkVUgp3spq/hMrhbb4YzP3mJc2lFS1hBq3hSSMYbM193d+CtS67Lm8XhlTXxQjO +g/l/mgrgWt8rEBLinMNrNSlU5gZ8i0kaeWn+R4F0JIAem7e5kd0SYzc1DAa1W28l +jvZiIU99mzwoV5rG7yV8VuMySnCJcXwED3WQgrYkbUzUhyYqHAsHxpgKTqar0t8q +1yJyLWguk0I/Ia8ZNMX8mRYN/HCJAhwEEAECAAYFAk6vJ0IACgkQjc41VjAi5XoN +GBAAhtBk5au9+sawl/G2lAh1FHcNKN0eKKkv5cIgKl5sEnwHUqbsK+eCdVG62+qh +wSa0VE9w0907X66StfyZgc1Y07aC8Uo2SvR9/8sOUI4urgPBb0C7wPIiZ7ui0k1A +XF0AD/49G2r3HYFdTar2evmM708O1PeUFazHcnajQvWksxZZkM2PxWGIIMVTpYA9 +HNzQzt619961V+5iQFU98NsM2xie7GlpYGUWhWeJQckFkuuj4E+DhWQtRR/MtOl/ +4IuQj58jCId6HzMk76brEIqqEZYmzlEYT0mrmZFJkT2uYv2WDpwmtg6TGBhOCAic +6/sZ96JTMkMPDdDdVAj9dSqaoBAdyPYAdNPorMJKMV2VbG1VpZjswMxX4UIthDyO +y2bBPXP6ey7EzTBEIiESXtHgFVfylA1FjYqyYCCpjZN+e2rlF+RzyWz4LYeejDLZ +dbhGCnufNfaK1qmu3OxeytJqrzfbNDm4VsPyiv4afCDZzbAeg0Ph1sTQNvMZmsCT +7IXJJbqJqu/Wx3wt69D1Y/0D9ocTA/8Dl4nWjnnIAgwrER6GkjEE/9FrW8qbC3MR +K/FsEI/svh05JZJ7vnlYngShHkPk2TXKNaMeLTmAUh45TkhyhrzBL3bQKaIktlWs +YZnSwDQjMOpOSpV/JoveAr/TPdKJ7WCsH+IjhuV7bjeojr+JAhwEEAECAAYFAk6x +pZEACgkQly1b9NxhOAaFNA//ZqCzr1Er31kV5jcVSKGKJGwt/An94PuhT3MMLqeb +XdkWCnWzm7l/jLEsrM4N+ba0txPgjXQeSssPc4x7SJDSG+HhltxQrkPbdP8HJ/G+ +kW4YBQbnqVviu4wTDLmW4IuLThqqv22ISpBE2f/VnHxk+IlKKN48QSyYqC9hHSmY +tvbi4emfmbqtGg6QfQf6hhzVX27YWMRH0acUGj7fgfwDVS6xTXvRrzOJBLW+7S1S +uK6y/S2JFh//bIVbQ/3T/JJ/mxyOoAbmhi7xtPYitfarnOxxvMhp46bWg05Tpm1c +fDbqD4XhNmTH5pUzBlwUKeeSJi49zpY+V2oXOCoecV7u6v89XJqT25GWVIHYnoXN +D3nxOvcebqEysN6CZJWChDPDkO1+r4RpcBj2iXrk/n9NGabk998R1AMKs9JVJkab +Jr1KJol6R0tcnvoXyrN0HQeJNGWMyo5FSz0/VQ4vOIZC1JTtJj9pdCO9Pfq+yx6m +yD1fGb3TyINw26DSGnHk5yfrrYS1HxHZ0PW7vWJswbJtLlfQEXXiVhlfdf2qy8kL +2R/wpxPM9/jmiM5iScEOLQ8alTJkIFL7bZbKLRLEvMzt75Nh4b7pzPFhnbeLaVBa +tey/VWL9Wq/O23yj2M6grheZa44qOE7GemdmPWx/fFnzrhd8jvuicGoQ1KC4Gt22 +Wv2JAhwEEAECAAYFAk61dOoACgkQEJ8JhQb/CxR8OA//QS/3SN1AUX+1zlCAz22I +IspOmQHahpaC1Ve0xUArXQS86X1DU3J0oqSNSjizn8zJbLxuZPumJCV1AbN71UT0 +hA9b0dwwTgwc+Hve/lb+iClX23vASMM+mAHJLrNFh8b74iJFyxC3o0clNbjf0W1E +s4S84FD+/jun/Uldu1DUrQv2TASwUcFJsjYeYw4pvGf2bq6UhWXcWYipyXzscgDj +87KwGiD1VNuNXylCm/54Hu7c9RSaBMEIGtc3XNa0PGF8xF5zddgDl1hOWYweu/IV +ShNezS6AHKVPZL/oiMgyI8ljfZhfZA9JYnRIbDpCI0kmQUgK+PEyECGfviqrjt2w +UAkrCXLpdBnOGR7bdS2EIO5M3hZxvscC2PVsCctDbx0bIymooTgakx04S2LNDFCn +rwRzb2Pes86zVDEzPcauPft7kOnaZNWzPwedp46jHBjPqRfElu7ghB2a0cZ8BhR2 +Lr46zcAjFvtZ2n5m8YQuwZ4ZJcPJs8fv5bANEdbk6P/qCyBH83EG8f5k1TELhPao +wsk0k5cLD+5WoosXySjJJnUhSuW+k8OkuSQMu6SyEa64CjqMDC651bfbc+rJYRSF +CbH52CBimxFZED3Y/+1StnswKhewswBBynC2Tc6o0/t+hkTFZbTJ11LyZ8zVYBNy +f3qm2juTTUCXPAzgcI78+z+JAhwEEAECAAYFAk7Te3YACgkQdkfhpEvA5LrE7BAA +th3ocDcqArRyXp3RyCylBqXUK3vvk9s/hRKNlXB96YsvbF1KqVr9um1kmWIPFQAt +Hi05SmFIZ2pxoDRjsySjbBllHdX5+OF5I6o8DSztaFjMFXQcEP+seJmp4fnHOTN5 +KjbRGL4ZjzVl1wbyhnt3zRUEQhDPxJmznIBC0HpVQaCaDm6ciGUZHbjXrJNc0fo2 +Lp22VldOsY2cLZgG1yTsAEiDSTmF/grbss7z20hSPxFioR/VXLvzKqPOYUogRAZt +EjKalGSYo8FS8TemA0pwTpBKgECN6C8FAaOotYNn2TUKmnk64JAVvQfhb4LgWRwg +TZ3JVz+xtD7SQiZmnT4khFX9eqSpkHOcK4GOmap6yRUzt74ofS72rPLkw7eSGkWU +F/5XJZCpbxTfVqPyij+uaMbqUyuem3NiKxI/I3nXPRWFsesm/rEAP7but7XXgJsC +bsTPZMuo29RZdSivyvobDgaUuO7L5Fcx/HFFAvzdLWIJ9oNn2RBtUP527/GDmRHR +DR6wceuZEM/H5MjdK7F73g3l2O2KC94KvMexoxMipoxU5YnO9iGrCjgR1GXAnhdj +5xa68QUTWai3FpQ5yDMI7IptfQKiH+fhOUX/aXnFPTKxHuJ1nnaUZhCWtz/6QqXH +De31N61TlWfqa1H8MgRkudSEoxOVImVkbkQvefyZt+CJAhwEEAECAAYFAk7drSYA +CgkQ0292m8EYBPCUfRAA4pkIdYx6rlYbDlyZ6aVZ8FRs2CYNEzAqgRufrxReltfl +9dzic6cOWRTTj2AepvXmZ7Pfr9ON73yZNrAbl7xn21k0wxMvfyo4fEcBTund/bsy +BY7Q1nL17i/PEFysyy9naZaRVK9II0MHjyBCIuRIoZh9whCu8+yYsLSwpXvk7d5r +yTU1EkEj9PejoevrXfsKh/nWkSGG9o84IUsQcdOFHqFjxQQBk+LaL1NUi5SMYLpU +WsxWIt2WdIqu7zplgsWcsBSaO2q5NPKl21Hg1ZPTcx9bjdJPO9Aeg7bJ/RJ+mVvm +2Y2vmqmwO9Nq6+WewKB63A21oOO5duHpKXDTZIR9j2UnMmxCgbMA2girV1H3rK6m +PhlRW6/vEfDwyp7v8DU+8/uWJSli1XKAGw47/1Jeai3spPvx9HTY8cLU8owTfywK +CIOauH5p+G3cdJwuMBJRsB8Aoq2hHjGZTJGnPZ8ewvshrVZriYsXtEXZVWy428Cv +cmXIXnaS/rt8kUxLYFd+Pn/KQkPa02QL09vjOyZjyP2br8+IoaqkVFtJzJILZ5jV +5cO/p1PcDOiyBu4GI7jnlajMVsQBP0mi+JY7KAwPZr5UqRl70+CiZVNriD5tI9AJ +ZGKmX3ysteCaiPcbE4viPlRgTqnpuypzfcyr39gbJHjlkfxSdSOUZbMMhg1uVICJ +AhwEEAEIAAYFAk6oZLkACgkQ4PNz83v5CZr9Zg//Yn9BqXeiRJ8bGdbfrR3PIRTz +xW4pDt2Yy6KPhIcykoQINOtynmEE91U4dTUkXktuTmlaxNHa/rRpWkuuJ193l+89 +avKIwTCD94UOo9HnVxPbGOZaZ0xw4+Rgh9tTATn7KSC0AyIdzm5LQfg7lMzsHyBz +Mh+lsd9JwJ6Ielqt0HGKkhhDdWDc4W6VzWykUebWpU75X/RxSdhZTjzL0a31nQ3p +Ilao2RHNhuJWI4b4FAaJU/4MVW+A7iHtJ0taIXpMZJ5iy4EM3W3/UoIz9jf3dYwg +j5JDJjx3BNIlf1ubM8NkoDHBpVAKtn6O2hcvdpbx4JMw3RAaaaWJFKyhzCsVOHeV +o3F4CNtThB0zJkFSdzwpYL6DT/ijH4vS5AQHgrfH/zmS9mRq+y4WBXRBcyTTqX80 +ccGoExug/4b201/WB/QpVkf2ko0/bUhOVZm9ozYTsqGa6BvqAaqUpsQ3xDzIzimB +mNh1KGxirw1uPXuC/YxlVy0dWMBW98HnajVNABUeDhK9l0niMit6FtgvEnjpnVP4 +xRvw3dCOJGfjXt9noo62MCfplZqZe0U5VR42A80vDtoTzwFMC6AXNDwfqaRT4Ko9 +uyEqMWE3TQAYY/LQQVeBkPG/RUeaSYfxv2cwDashHNfmq2PdRVxkSZkvpE6HiW4L +ab7REOfF8usJW9/SkmuJAjcEEwEIACEFAk6b/qQCGwMFCwkIBwMFFQoJCAsFFgID +AQACHgECF4AACgkQ99NY+ylx4KbzvA/+IxAuTK43uMNHzAGizSvjPt11AzMgoa5z +cO2XQKZoY2bVO0fO/khK28x/g94vS/LqLSZXU43MWq3gX8ZF+UmwHstyBawnHuaW +pvJA1f/ZU/a5uOLsv2kzqCgu0Sg0cdpffeM+cy+DshzRs/n9xj/diIMeSH8zr5F8 +I8VoZbZHPXiJ/mxTDSzfwD2Rk2tmy23bBvLUs5icOnZvYP9LQKU7AOfb/3oiBlHL +3YjCzQKLZtdABDihelha3sHTugz1/d3r6TYRf2x2bkoK/4LxrsLlrYL7eR24E++u +2tx4Zfl8UMJRw5YfP1Viwv5ccYhJegKu4hoXnElx+WC01HRUOGpJNQtzd3zeakNN +Bf34hiIS1GTNV22OISsBn1On5z05sEepKZzpUolhDIbmA+sZsCgUUcYoXGIJadaL +C2d0pmeC1o29nOaX2Sp1lUwxykgblivLZCFwZm29StSvK+TpEowTb18JmbtYjOFV +JgxUoiCv31a6P1Wm0xpGj1xoNAxhcrfJGsCiM+R5+PLAiOQBdrbsdIR1ZvV5hBr5 +xCMiPM14yqzixpEezJeaMd3MWspwVsAVIBF+oh08+TWdcXvp0aWDj+MJfivg+b+7 +UkMoLw9pt5/6Kn8EZ6G+wQd9L3Y9Vck/I0ieP7V4vj1ny/wMScOaRN7aPfy7V85k +WGyQ6QYSR5G5Ag0ETpvLpAEQANqpwEG/QWMQx1SIIYfXUtNRXP2KKusz1rE2C4KM +V80DGKRJmt1TdGPv8ZmDqE3aYP8Br9WXymCWWDiT1MkNzzCzbPibEoFzo6jX1ilg +cpGH2HOVxM6PJykTbwpH5TL8fIBbdAenzmoVOFkkzprixs/RwO8UHmrxtF1Cg8XH +kchm1Gj6zQ5JnMiSEMMQwmNBUAWX1+h3fCiPT9JyWAqG+EPsD0vVmcj4FWEpW7Ei +J+g9BH+8GgkpGPVEV/oHIlAfZ6EVoFwfDBf0oZ9DmEmuIBi2EXZD5ue2WQQSYcxf +UI4qTARGfjP7aOINa2L+pDCRRpXNFD3oUr1Z9jPh/KAeOdPDqh+1e5leJSCZEIjG +pbMwKKuK8F6MSAFt1FcNJ8lrIHaJkNwyFcry+nJfqgFRwqGi3MjB134O2rxr55+9 +dRzqCYT96WynJI7m2PmcCQmHPyzWNQcS9BlFCdZzziWW1vbwM8sfh9e+BE2E5jmd +lw5fjm8vfNMcCh+AKVK4pax3c0X3W3832YDhj8tXD66DPeMmqAthBJwqeZJYAIcg +Wb38ZksV8jgRsmNditgYboSPGsQ7GiY5ZpI7rKcPxRQFHFin+cABcm80LNss4jm0 +ugCA5fjT4NksY4Jj/tGG2qg0cDwOgDor7pX29W8m+1LG1MR3iwTJEI35RnABOhMl +WjtzABEBAAGJAh8EGAEIAAkFAk6by6QCGwwACgkQ99NY+ylx4Kbg/BAAnhaYJCj+ +4VD29T7c61VDKDUWq7ClX2j35dC5/9pZEnQYaGzYrSMtdzCY2M5HNzVXJuBd/h1v +JVdDWafNDzBVCmNEzrSmp/nj5jJ00oIImum2RkmLYBdjw2YFCoQi4lQeQ9d9Wok7 +S+yh7hhzumMQp8R3vZBFApkPL8QeFlMvj1GE6r8rUYql7jkzIht0DbH5aMTvrz2X +4N+iwNDpVryECNMxMFcEryveZZH8SMRyXc37nsp3eL0Foe8zRWGa4fROxPA0r1nl +PQMwb6CwUvJcORj/pjdYe5HVs10aSB+fsazinIW17NhqcpDSqTcxWKw3XCz7UPSO +iDJJue9bmU90BXiFWR/BarFGgjbnx4svRHL/veY7KnqZq5L44eS1UOzTnPlDqeq7 +bYe8iiHGhfHFbGRSChqfV+HBIpUBhvGkxQEgFjPqVXyXHC0dZwjyuWxz1f9s1h9i +LJTEh3uVfB/T/k6mqkoX9b4G2BOcEVoYOwGTUomgAmblY176jYbOqP+z9KQ6h3Hb +cDQ+mvyfcAvOxroPqELQylfrU+rJlFtOPBo1DHPuYmDsIhjQnGkFXhVdOsKtRkY8 +GOelHqtMXm0SN4QxWoAnWv3R2XTeglEge1+wWlkNSWWyaraUHP9ckUPx7fyxnXke +ttsW4Qm8dOTwfQtoXCD/o5kUSg5mvNyIumY= +=o7ud +-----END PGP PUBLIC KEY BLOCK----- diff --git a/liburing.spec b/liburing.spec new file mode 100644 index 0000000..20ebc1e --- /dev/null +++ b/liburing.spec @@ -0,0 +1,147 @@ +# +# spec file for package liburing +# +# Copyright (c) 2025 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 lname liburing2 +Name: liburing +Version: 2.8 +Release: 0 +Summary: Linux-native io_uring I/O access library +License: (GPL-2.0-only AND LGPL-2.1-or-later) OR MIT +Group: Development/Libraries/C and C++ +URL: https://github.com/axboe/liburing +Source0: https://brick.kernel.dk/snaps/%{name}-%{version}.tar.gz +Source1: https://brick.kernel.dk/snaps/%{name}-%{version}.tar.gz.asc +Source2: https://git.kernel.org/pub/scm/docs/kernel/pgpkeys.git/plain/keys/F7D358FB2971E0A6.asc#/%{name}.keyring +Patch0: 0001-test-init-mem-zero-the-ringbuf-memory.patch +Patch1: 0001-test-rsrc_tags-use-correct-buffer-index-for-test.patch +BuildRequires: fdupes +BuildRequires: gcc-c++ +BuildRequires: pkgconfig +BuildRequires: procps +# Kernel part has landed in 5.1 +Conflicts: kernel < 5.1 + +%description +Provides native async IO for the Linux kernel, in a fast and efficient +manner, for both buffered and O_DIRECT. + +%package -n %{lname} +Summary: Linux-native io_uring I/O access library +Group: Development/Libraries/C and C++ + +%description -n %{lname} +Provides native async IO for the Linux kernel, in a fast and efficient +manner, for both buffered and O_DIRECT. + +%package -n liburing-ffi2 +Summary: io_uring I/O access library for non-C/C++ languages +Group: Development/Libraries/C and C++ + +%description -n liburing-ffi2 +Foreign function interface for liburing, offering non-C/C++ language +integration. + +%package devel +Summary: Development files for Linux-native io_uring I/O access library +Group: Development/Libraries/C and C++ +# SLE/Leap 15.4+ retain liburing-devel for the inherited 0.6 API. The v2 API is: +Provides: %{lname}-devel = %{version} +Requires: %{lname} = %{version} +Requires: pkgconfig + +%description devel +This package provides header files to include and libraries to link with +for the Linux-native io_uring. + +%prep +%autosetup -p1 + +%build +# not autotools, so configure macro doesn't work +%set_build_flags +%ifarch %{ix86} +# Otherwise 32-bit x86 fails with: undefined reference to `__stack_chk_fail_local' +export CFLAGS="%{optflags} -fno-stack-protector" +export CPPFLAGS="%{optflags} -fno-stack-protector" +%endif +./configure --prefix=%{_prefix} \ + --includedir=%{_includedir} \ + --libdir=%{_libdir} \ + --libdevdir=%{_libdir} \ + --mandir=%{_mandir} \ + --datadir=%{_datadir} +%make_build -C src + +%check +declare -a TEST_EXCLUDE=() + +%if 0%{?sle_version} == 150500 +TEST_EXCLUDE+=( fallocate.t fd-pass.t fixed-buf-merge.t msg-ring-overflow.t nop.t poll-race-mshot.t reg-hint.t sqwait.t wq-aff.t ) +%endif +%if 0%{?sle_version} == 150600 || 0%{?sle_version} == 150700 +TEST_EXCLUDE+=( fallocate.t sqwait.t nop.t ) +%endif +%if 0%{?suse_version} == 1600 +TEST_EXCLUDE+=( sqwait.t ) +%endif + +%ifarch ppc64le +TEST_EXCLUDE+=( no-mmap-inval.t recv-multishot.t reg-fd-only.t recvsend_bundle.t recvsend_bundle-inc.t ) +%elifarch s390x +TEST_EXCLUDE+=( 7ad0e4b2f83c.t futex.t multicqes_drain.t poll-mshot-update.t read-mshot.t timeout-new.t waitid.t ) +TEST_EXCLUDE+=( link-timeout.t min-timeout-wait.t submit-and-wait.t sync-cancel.t ) +%endif + +# io_uring syscalls not supported as of qemu 7.0.0 and would test the host +# kernel anyway not the target kernel.. +%if !0%{?qemu_user_space_build} +echo "TEST_EXCLUDE=\"${TEST_EXCLUDE[@]}\"" > test/config.local +%make_build runtests +%endif + +%install +%make_install +rm -v %{buildroot}%{_libdir}/%{name}*.a + +%fdupes %{buildroot}/%{_mandir}/ + +%post -n %{lname} -p /sbin/ldconfig +%postun -n %{lname} -p /sbin/ldconfig + +%post -n liburing-ffi2 -p /sbin/ldconfig +%postun -n liburing-ffi2 -p /sbin/ldconfig + +%files -n %{lname} +%{_libdir}/liburing.so.* +%license COPYING COPYING.GPL LICENSE + +%files -n liburing-ffi2 +%{_libdir}/liburing-ffi.so.* + +%files devel +%doc README +%{_includedir}/liburing/ +%{_includedir}/liburing.h +%{_libdir}/liburing.so +%{_libdir}/liburing-ffi.so +%{_libdir}/pkgconfig/* +%{_mandir}/man2/* +%{_mandir}/man3/* +%{_mandir}/man7/* + +%changelog diff --git a/test-buf-ring-nommap-skip-the-test-on-queue-init-ENO.patch b/test-buf-ring-nommap-skip-the-test-on-queue-init-ENO.patch new file mode 100644 index 0000000..f048ee0 --- /dev/null +++ b/test-buf-ring-nommap-skip-the-test-on-queue-init-ENO.patch @@ -0,0 +1,28 @@ +From f11c1ab393185aecedc3f1445b0dff5b187f58c1 Mon Sep 17 00:00:00 2001 +From: Jens Axboe +Date: Thu, 8 Aug 2024 07:34:46 -0600 +Subject: [PATCH] test/buf-ring-nommap: skip the test on queue init ENOMEM + failure + +Fixes: https://github.com/axboe/liburing/issues/1200 +Signed-off-by: Jens Axboe +--- + test/buf-ring-nommap.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/test/buf-ring-nommap.c b/test/buf-ring-nommap.c +index 17c1495..32a372c 100644 +--- a/test/buf-ring-nommap.c ++++ b/test/buf-ring-nommap.c +@@ -46,7 +46,7 @@ int main(int argc, char *argv[]) + p.flags = IORING_SETUP_NO_MMAP; + ret = io_uring_queue_init_mem(1, &ring, &p, ring_mem, 16384); + if (ret < 0) { +- if (ret == -EINVAL) ++ if (ret == -EINVAL || ret == -ENOMEM) + return T_EXIT_SKIP; + fprintf(stderr, "queue init failed %d\n", ret); + return T_EXIT_FAIL; +-- +2.45.2 + diff --git a/test-buf-ring-nommap-zero-the-ringbuf-memory.patch b/test-buf-ring-nommap-zero-the-ringbuf-memory.patch new file mode 100644 index 0000000..3afc924 --- /dev/null +++ b/test-buf-ring-nommap-zero-the-ringbuf-memory.patch @@ -0,0 +1,49 @@ +From 8100d7b5f862fa514d821e8bd8f99d0de79af571 Mon Sep 17 00:00:00 2001 +From: "Jiri Slaby (SUSE)" +Date: Fri, 12 Jul 2024 13:17:03 +0200 +Subject: [PATCH] test/buf-ring-nommap: zero the ringbuf memory + +The test crashes when run under the openSUSE build system. It sets +MALLOC_PERTURB_=69 in the environment, so the allocated memory is +initialized to 0xba. + +Later in io_uring_get_sqe() -> _io_uring_get_sqe(): +1424 if (next - head <= sq->ring_entries) { +(gdb) p *sq +$2 = {khead = 0x55555555d000, ktail = 0x55555555d004, + kring_mask = 0x55555555d010, kring_entries = 0x55555555d018, + kflags = 0x55555555d024, kdropped = 0x55555555d020, array = 0x0, + sqes = 0x55555555c000, sqe_head = 0, sqe_tail = 0, ring_sz = 0, + ring_ptr = 0x55555555d000, ring_mask = 0, ring_entries = 1, pad = {0, 0}} +(gdb) p sq->ring_entries +$3 = 1 +(gdb) p next +$4 = 1 +(gdb) p/x head +$6 = 0xbabababa + +And that causes a crash, of course. + +Fix that by zeroing the memory after posix_memalign(). + +Signed-off-by: Jiri Slaby (SUSE) +--- + test/buf-ring-nommap.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/test/buf-ring-nommap.c b/test/buf-ring-nommap.c +index 1e47f28..17c1495 100644 +--- a/test/buf-ring-nommap.c ++++ b/test/buf-ring-nommap.c +@@ -41,6 +41,8 @@ int main(int argc, char *argv[]) + if (posix_memalign(&ring_mem, 16384, 16384)) + return T_EXIT_FAIL; + ++ memset(ring_mem, 0, 16384); ++ + p.flags = IORING_SETUP_NO_MMAP; + ret = io_uring_queue_init_mem(1, &ring, &p, ring_mem, 16384); + if (ret < 0) { +-- +2.35.3 + diff --git a/test-no-mmap-inval-0-return-is-fine-too.patch b/test-no-mmap-inval-0-return-is-fine-too.patch new file mode 100644 index 0000000..cff6037 --- /dev/null +++ b/test-no-mmap-inval-0-return-is-fine-too.patch @@ -0,0 +1,30 @@ +From: Jens Axboe +Date: Tue, 7 Nov 2023 08:05:52 -0700 +Subject: test/no-mmap-inval: 0 return is fine too +Git-repo: git://git.kernel.dk/liburing.git +Git-commit: 9dc95a03e4a764e42b9e62990bb00feb9307ba63 +Patch-mainline: 2.6 +References: test_fix + +Signed-off-by: Jens Axboe +Signed-off-by: Jiri Slaby +--- + test/no-mmap-inval.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/test/no-mmap-inval.c b/test/no-mmap-inval.c +index e851078d..9571fee0 100644 +--- a/test/no-mmap-inval.c ++++ b/test/no-mmap-inval.c +@@ -31,7 +31,7 @@ int main(int argc, char *argv[]) + if (ret == -EINVAL) { + /* kernel doesn't support SETUP_NO_MMAP */ + return T_EXIT_SKIP; +- } else if (ret != -EFAULT) { ++ } else if (ret && ret != -EFAULT) { + fprintf(stderr, "Got %d, wanted -EFAULT\n", ret); + return T_EXIT_FAIL; + } +-- +2.44.0 + diff --git a/test-recv-multishot-wait-for-the-right-amount-of-CQE.patch b/test-recv-multishot-wait-for-the-right-amount-of-CQE.patch new file mode 100644 index 0000000..148ac3e --- /dev/null +++ b/test-recv-multishot-wait-for-the-right-amount-of-CQE.patch @@ -0,0 +1,50 @@ +From: Jens Axboe +Date: Tue, 6 Feb 2024 13:17:14 -0700 +Subject: test/recv-multishot: wait for the right amount of CQEs +Git-repo: git://git.kernel.dk/liburing.git +Git-commit: a1d5e4b863a60af93d0cab9d4bbf578733337a90 +Patch-mainline: 2.6 +References: kernel 6.9 + +This test assumes that all task_work is a) has already arrived, and +b) will always be fully run even though the app asked for less, which +can lead to premature checking of CQEs and hitting end-of-CQEs before +it should. + +Fix it up to wait for what it needs. + +Signed-off-by: Jens Axboe +Signed-off-by: Jiri Slaby +--- + test/recv-multishot.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/test/recv-multishot.c b/test/recv-multishot.c +index f66f1319..39983e8d 100644 +--- a/test/recv-multishot.c ++++ b/test/recv-multishot.c +@@ -57,7 +57,7 @@ static int test(struct args *args) + int const N = 8; + int const N_BUFFS = N * 64; + int const N_CQE_OVERFLOW = 4; +- int const min_cqes = 2; ++ int const min_cqes = args->early_error ? 2 : 8; + int const NAME_LEN = sizeof(struct sockaddr_storage); + int const CONTROL_LEN = CMSG_ALIGN(sizeof(struct sockaddr_storage)) + + sizeof(struct cmsghdr); +@@ -237,7 +237,11 @@ static int test(struct args *args) + usleep(1000); + + if ((args->stream && !early_error) || recv_cqes < min_cqes) { +- ret = io_uring_wait_cqes(&ring, &cqe, 1, &timeout, NULL); ++ unsigned int to_wait = 1; ++ ++ if (recv_cqes < min_cqes) ++ to_wait = min_cqes - recv_cqes; ++ ret = io_uring_wait_cqes(&ring, &cqe, to_wait, &timeout, NULL); + if (ret && ret != -ETIME) { + fprintf(stderr, "wait final failed: %d\n", ret); + ret = -1; +-- +2.44.0 +