commit cb3d6a20648a6d60ac7eec58682b86282757d5f73f15dcf6fbbd6c53f34c0c69 Author: Adrian Schröter Date: Thu Mar 13 22:06:14 2025 +0100 Sync from SUSE:SLFO:Main xapian-core revision 7924ff59e93159c9f240bf862655bddc 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/baselibs.conf b/baselibs.conf new file mode 100644 index 0000000..a33993c --- /dev/null +++ b/baselibs.conf @@ -0,0 +1 @@ +libxapian30 diff --git a/xapian-core-1.4.22.tar.xz b/xapian-core-1.4.22.tar.xz new file mode 100644 index 0000000..b70e138 --- /dev/null +++ b/xapian-core-1.4.22.tar.xz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:05884af00b06702ce486057d62a3bfbe6606cf965ada0f5ea570b328a2fa1ea8 +size 3019608 diff --git a/xapian-core-1.4.22.tar.xz.asc b/xapian-core-1.4.22.tar.xz.asc new file mode 100644 index 0000000..d30ef52 --- /dev/null +++ b/xapian-core-1.4.22.tar.xz.asc @@ -0,0 +1,16 @@ +-----BEGIN PGP SIGNATURE----- + +iQIzBAABCgAdFiEECOJAD/f+j+3jrLUoGBR7BzutKwcFAmPbFYcACgkQGBR7Bzut +Kwda8Q//eTbGRq9iAS47Bl18+RFtKX/mOQg5Aen6E/RkqZsG2GZJOKHnAPamNTnB +O6zC/bb7LNIAkpenPuWwOJAD7Zrke3wiSQ/Qcbcam8iZXA9sPxjuggjNwb+AuI95 +kF12C0FoG1iQumL/WarDtid5MGjVgPOO123JSMR9FGe3Fwe6rtzt0K97MKLCjekh +KUXHkfc/HPl/KIgjsXZRIe0PTHl5WcdgkrmERzmBNoxNk+7xVXnPqbuuseQYx8ZR +BsLGRHknIZEJK+AqSSWQbe2uPxNJpw+FYN2X1T5kb4flUJi4c8+sK04D6KbZTmSD +wJZAkZZbOnRRPQ075twGCAzBA1Lokn9bA61meGUghtTeaP8/rL2LixNupZzqzBKU +rSu1FkhyADf6QlpXFSpBTvrBBb83UbGQF4mEvGdXq1/3vv6F1kZB8nm3KtsHLwhp +HU4Qkt2oCCrNFo8OAPAZ2oSWljbSYptZJ3VpBXM/Q7tDRaHuATXk2S+j0hSTg3UI +0R5TbVVhJL2S5f2wjHjQ9UiAJhTueOSwk4mUYWTWpxEPv3oKyZM31+FknTAoUZBS +PX+XdMgt8HoRZ+yGrYm6jRGwQuZRR9nB6dn48Pgj/AVT80Z1ouVNUMkyJKgdNeJb +hZJq7hQD5hJ6FnlKIWdw6MpAO5m7eu2e/p3bFv8+Vc4XWs8kr3Q= +=9gqZ +-----END PGP SIGNATURE----- diff --git a/xapian-core.changes b/xapian-core.changes new file mode 100644 index 0000000..0bdfa84 --- /dev/null +++ b/xapian-core.changes @@ -0,0 +1,1599 @@ +------------------------------------------------------------------- +Thu Aug 22 08:07:11 UTC 2024 - ming li + +- update to 1.4.22: + * Expand canceltransaction1 to test value changes are rolled back. + * Minor optimisations to DPHWeight and TfIdfWeight weighting formulae + calculations. + * Optimise LatLongDistancePostingSource to avoid pow() call on each document + with default k2 setting. + * Fix bug in recovery from WritableDatabase::commit() failing. + * configure: Enable -fno-math-errno if supported. We don't make use of maths + function setting errno and if we tell the compiler that it can optimise them + better in some cases. + * INSTALL: Document assumptions about platform features + * INSTALL: Add section on clang version requirements. + +------------------------------------------------------------------- +Thu Sep 29 19:24:49 UTC 2022 - Dirk Müller + +- update to 1.4.21: + * Stop trying to check for incompatible C++ ABI between the compiler used to + build xapian-core and the compiler used to build code using xapian-core. + * Fix new warnings from GCC 12. + * Avoid undefined value use when unpacking a key in a corrupted glass docdata + table. We now skip further checks on the entry in this case. + * Merge allocations in MSVC directory reading compatibility code so we can + allocate in a single malloc() call. + * Add accept() wrapper which checks an assumption that Microsoft's SOCKET type + only actually holds 32 bit values even in 64 bit platforms and throws an + exception if violated. + * Eliminate a use of sprintf. + * Squash some unhelpful MSVC deprecation warnings. + * Declare dummy invalid parameter handler noexcept to fix a warning from MSVC. + * Include in configure check for sys_errlist as that's where it is + with mingw and MSVC. + +------------------------------------------------------------------- +Sun Jul 17 15:40:00 UTC 2022 - Dirk Müller + +- update to 1.4.20: + * Throw DatabaseNotFoundError when the database directory doesn't exist or + when it doesn't contain a Xapian database. Patch from Germán Méndez Bravo + in https://github.com/xapian/xapian/pull/258 + * Improve exception message for attempting to remove an empty term (the + exception type is still InvalidArgumentError). Reported by David Bremner. + * Optimise when a value range is a superset of the slot bounds but the value + slot frequency is not equal to the document count by replacing the lower + bound with an empty string to make the bounds check very cheap. + * Avoid creating a PostList tree for an empty shard. This avoids pointless + work in an uncommon case, but also by handling this up front the code in + PostList subclasses for query operators can assume the shard isn't empty + which simplifies the code in several places. + * Remove lingering handling for database backends without slot bounds since + all backends have been required to support these since 1.4.11. + * Fix collection frequency estimates for positional operators. This affects + the weighting of positional operators in subqueries of OP_SYNONYM with + weighting schemes which use the collection frequency. + * xapian-check: Test decompress data in the spelling and synonym tables. + We don't have structure checking for these tables, but we can at least fetch + each entry and check for decompression problems. + * Improve error if a block is detected as overwritten in WritableDatabase. + Drop "are there multiple writers?" as it's rarely a useful question to ask + since we started using fcntl() locking as it's now very hard to get multiple + concurrent writers on a database. Instead suggest running xapian-check, + which is probably the best next step for a user who hits this problem. + +------------------------------------------------------------------- +Wed Jan 19 21:10:03 UTC 2022 - Dirk Müller + +- update to 1.4.19: + * New QueryParser::FLAG_NO_POSITIONS flag. With this flag enabled, any query + operations which would use positional information are replaced by the nearest + equivalent which doesn't (so phrase searches, NEAR and ADJ will result in + OP_AND). This is intended to replace the automatic conversion of OP_PHRASE, + etc to OP_AND when a database has no positional information, which will no + longer happen in the release series after 1.4. + * Give a compile error for code which adds a Database to WritableDatabase. + Prior to 1.4.19, this compiled and effectively created a "black-hole" shard + which quietly discarded any changes made to it. + In 1.4.19 it's still possible to perform this operation by assigning the + WritableDatabase to a Database first, which is harder to fix. This case + throws an exception on git master where it's easier to address. + * Fix TermIterator::skip_to() with sharded databases which sometimes was + failing to advance all the way to the requested term. Uncovered while + addressing warning from GCC's -Wduplicated-cond, reported by dcb in #816. + * Clamp edit distance to one less than the length of the word we've been asked + to correct, which makes the algorithm we use more efficient. We already + require suggestion to have at least one character in common, so the only + change to suggestions is we'll no longer suggest corrections which are + twice as long or longer even if the edit distance would allow it, which + seems like an improvement in itself. + * Minor optimisation expanding wildcards. + * PostingIterator::get_description(): For an all-docs iterator on a glass + database, get_description() would call get_docid() which isn't valid to + do once the iterator has reached the end. + * Expand allterms test coverage. + * Fetch wdf upper bound from postlist which avoids an extra postlist table + cursor seek per weighted query term, and also means we now use a per-shard + wdf upper bound for local shards which will in typically give a tighter + weight upper bound which will tend to make various other matcher + optimisations more effective. Eric Wong reported this speeds up a + particularly slow case from ~2 minutes to ~3 seconds. + * Avoid triggering a pointless maximum weight recalculation if an unweighted + child of a MultiAndPostList prunes. + * Only check if the database has positional information when the query + uses positional information. This should help improve notmuch delete + performance. Thanks to andreas on #notmuch for analysis of the problem. + * Optimise Glass::Inverter::has_positions(). Use const auto& instead of just + auto for the loop variables. Reported to be faster by andreas on #notmuch. + * Cache result of Glass::Inverter::has_positions() since calculating it is + potentially very expensive, while maintaining a cached answer is very cheap. + * Add missing closing parenthesis to reported remote prog context, which has + been missing since this code was first added over 20 years ago! + +------------------------------------------------------------------- +Tue Jan 19 22:04:41 UTC 2021 - Dirk Müller + +- update to 1.4.18: + * QueryParser::FLAG_ACCUMULATE: New flag. Previously the unstem and stoplist + data was always reset by a call to QueryParser::parse_query(), which makes + sense if you use the same QueryParser object to parse a series of independent + queries. If you're using the same QueryParser object to parse several fields + on the same query form, you may want to have the unstem and stoplist data + combined for all of them, in which case you can use this flag to prevent this + data from being reset. + + * QueryParser::unstem_begin(): Eliminate unnecessary copying of the data. + + * Fix typo in Swedish stopword list, syncing change made to Snowball by Daniel + Gómez Villanueva. + + * Remove some French stop words with other meanings, syncing change made to + Snowball by PhilippeOuellet. + + testsuite: + + * Run testcase testlock4 using backend chert, not just using glass + + * Skip testcase testlock4 on platforms that don't allow us to implement + Database::locked() (which notably include GNU Hurd and Microsoft Windows). + + documentation: + + * List DB_NO_TERMLIST in the WritableDatabase constructor API documentation + where we already list the other DB_* constants. + + portability: + + * Eliminate single use of std::mem_fun() which was deprecated in C++11 and + removed in C++17. Reported by Mateusz Pusz in #806. + + * Add missing includes for std::numeric_limits<>. Reported by stac47 in #805. + + * Work around mingw.org header issue. MSVC seems to implicitly include + but mingw.org's headers don't, leading to ERROR_PIPE_CONNECTED + not being defined. Fixes https://github.com/xapian/xapian/pull/318, reported + by Alex Sandro. + + * Suppress MSVC warnings about possible loss of data. The values involved are + the number of set bits in a value of integer type, so these warnings are + bogus. + + * Include for size_t and off_t, which is the appropriate header, + and needed with Android's bionic libc. Patch from Matthieu Gautier. + + * Use a temporary file for the Doxygen configuration to work around Doxygen + 1.8.19 bug which truncates a config file read from stdin to 4096 bytes + +------------------------------------------------------------------- +Thu Aug 27 06:17:24 UTC 2020 - Antonio Larrosa + +- Update to 1.4.17: + + API: + * Database::get_average_length(): Add this as an alias for Database::get_avlen(). + In git master we've added this as a preferred new name - adding it to 1.4.x too + will make it easier for users to update to using this. + * Database::get_spelling_suggestion(): Optimise edit distance initialisation + loop to significantly reduce the cost of a typical edit distance calculation. + * Fix query expansion on sharded databases. The mechanism for passing in which + shard a TermList is from wasn't hooked up and as a result we'd always think + it's from the first shard, meaning the statistics would be wrong and that our + suggested terms may not have been as good as they should be in this + situation. + * Enquire::get_eset(): Use string::compare() to avoid 1/3 of the string compares + on average. + + documentation: + * Update doxygen HTML headers and footers to resolve issues with some + interactive features of the API docs not working. Reported by Enrico Zini. + * Stop specifying obsolete doxygen settings PERL_PATH and MSCGEN_PATH. + * Clarify API docs for MSet::get_termfreq() to make it clear that this + considers all documents in the database, not only those that matched the + searched (it would sometimes be useful to be able to report the number of + occurrences of a term in the matched documents, but it's not something we + currently keep track of). Reported by Tadeusz Sośnierz and Peter Salomonsen. + +------------------------------------------------------------------- +Sat Aug 15 18:44:45 UTC 2020 - Dirk Mueller + +- update to 1.4.16: + * MSet::snippet(): The snippet now includes trailing punctuation which carries + meaning or gives useful context. See + https://github.com/xapian/xapian/pull/180, reported by Robert Stepanek. + + * MSet::snippet(): Fix segfault generating snippet from default-constructed + MSet. This probably isn't something you'd typically do, but it shouldn't + crash. Found during extended testing of #803 (which only affected git + master) which was reported by Robert Stepanek. + + * Remove trailing full stop from exception messages. We conventionally don't + include one, but a few cases didn't follow that convention. + + testsuite: + + * Replace direct use of ftime() which gives deprecation warnings with recent + mingw. Reported by srinivasyadav22. + + matcher: + + * Fix segfault in rare cases in the query optimiser. We keep a pointer to the + most recent posting list to use as a hint for opening the next posting list, + but the existing mechanism to take ownership of this hint had a flaw. We now + invalidate the hint in situations where it might be indirectly deleted which + is safe, but somewhat conservative. + + * Improve the optimisation of an always-matching OP_VALUE_GE to also take + effect when the value slot's lower bound is equal to the limit of the + OP_VALUE_GE. Patch from boda sadalla. + + glass backend: + + * Report the correct errno value if commit() fails. We were potentially + reporting ENOENT from an unlink() call cleaning up a temporary file prior to + throwing the exception instead. + + documentation: + + * Fix missing menus in API documentation. Newer doxygen generates .js files + which we also need to distribute and install. Reported by sec^nd on #xapian. + + * Note OP_FILTER ignored subquery bug fixed in 1.4.15 as present in 1.4.14 and + older. + + portability: + + * Use our own autoconf cache variable namespace (xo_cv_ prefix instead of + ac_cv_) to avoid colliding with standard autoconf macro use if config.site or + a shared config.cache is used. The former case caused a build failure for + the OpenBSD port with 1.4.15, reported by Lucas R. + + * Use clock_gettime() and nanosleep() under modern mingw as these allow higher + precision than what we previously used. + +------------------------------------------------------------------- +Wed Apr 29 17:00:49 UTC 2020 - Dominique Leuenberger + +- Update to version 1.4.15: + + API: + * Database::check(): Fix checking of replication changesets. + This reverts a change incorrectly made in 1.3.7. + * Database::locked(): Return false instead of true for a closed inmemory DB. + * Database::commit(): If commit() failed with an exception while trying to add + pending changes (e.g. InvalidArgumentError due to a long term containing zero + bytes) then a subsequent commit() on the same object would throw the same + exception. Now we clear the pending changes in this situation (like we + already did for failure at other stages in the commit). This bug remains + unfixed for the chert backend as it's harder to fix there and the effort to + fix it and extra risk of breakage don't seem justified for a backend we + recommend people migrate away from. + * QueryParser::parse_query(): Optimise parsing of multi-word synonyms. + + Testsuite fixes. + + matcher: + * Hoist positional check above OP_FILTER. + * Handle OP_FILTER with more than two subqueries correctly. Previously we'd + only check the first two subqueries in some situations. + + remote backend: + * For a remote WritableDatabase, the client now keeps track of whether there + are pending changes, and if there aren't then we now do nothing for commit() + or cancel() calls. In particular this saves a message exchange when the + WritableDatabase destructor is called when changes have already been + committed with an explicit call to commit() (which is what we recommend + doing, since with an explicit call to commit() you get to see any exception + which gets thrown). + * When closing a remote prog WritableDatabase, previously an exception could + leave the remote connection open with the remote server running, and we'd + then wait for the specified timeout before closing the connection. Now we + close the connection before letting the exception propagate. + * Don't swallow exceptions from Database::close() on a remote database. If + we aren't in a transaction and so try to commit() and that fails then + previously the caller would have no indication of the failure. + * Fix handling the reported term weight when remote shards are searched. + Fixes 5 XFAILs in the testsuite. + * Add missing space to mismatching protocol versions error message. + + build system: + * Fix to build when configured with --disable-backend-remote, broken by changes + in 1.4.14. Fixes #797, reported by Дилян Палаузов. + * The clang and icc compilers both define __GNUC__, which led our ABI mismatch + message to report them as "g++" with a bogus version (the version of GCC that + these compilers advertise themselves as, which for clang is always 4.2.0) - + now we report clang++ or icc along with the actual version of that compiler. + + updated documentation. + +------------------------------------------------------------------- +Wed Jan 15 09:12:32 UTC 2020 - Antonio Larrosa + +- Update to 1.4.14: + * API: + + Xapian::QueryParser: Handle "" inside a quoted phrase better. In a quoted + boolean term, "" is treated as an escaped ", so handle it in a compatible way + for quoted phrases. Previously we'd drop out of the phrase and start a new + phrase. Fixes #630, reported by Austin Clements. + + Xapian::Stem: The constructor which takes a stemmer name now takes an + optional second bool parameter - if this is true, then an unknown stemmer + name falls back to using the "none" stemmer instead of throwing an exception. + This allows simply constructing a stemmer from an ISO language code without + having to worry about whether there's a stemmer for that language, and + without having to handle an exception if there isn't. + + Xapian::Stem: Fix a bug with handling 4-byte UTF-8 sequences which + potentially affects most of the stemmers. None of the stemmers work in + languages where 4-byte UTF-8 sequences are part of the alphabet, but this + bug could result in invalid UTF-8 sequences in terms generated from text + containing high Unicode codepoints such as emoji, which can cause issues (for + example, in some language bindings). Fix synced from Snowball git post + 2.0.0. + + Xapian::Stem: Add a new is_none() method which tests if this is a "none" + stemmer. + + Xapian::Weight: The total length of all documents is now made available to + Xapian::Weight subclasses, and this is now used by DLHWeight, DPHWeight and + LMWeight. To maintain ABI compatibility, internally this still fetches the + average length and the number of documents, multiplies them, then rounds the + result, but in the next release series this will be handled directly. + + Xapian::Database::locked() on an inmemory database used to always return + false, but an inmemory Database is always actually a WritableDatabase + underneath, so now we always report true in this case because it's really + always report being locked for writing. + + testsuite: + * Fix failing multi_glass_remoteprog_glass tests on x86. When the tests are + run under valgrind, remote servers should be run using the runsrv wrapper + script, but this wasn't happening for remote servers in multi-databases - now + it is. Also, previously runsrv only used valgrind for the remote for an x86 + build that didn't use SSE, but it seems there are x87 instructions in libc + that are affected by valgrind not providing excess precision, so do this for + x86 builds which use SSE too. Together these changes fix failures of + topercent2, xor2, tradweight1 under backend multi_glass_remoteprog_glass on + x86. + * Fix C++ One-Definition Rule (ODR) violation in testsuite code. Two different + source files linked into apitest were each defining a different `struct + test`. Wrap each in an anonymous namespace to localise it to the file it is + defined and used in. This was probably harmless in practice, unless trying + to build with Link-Time Optimisation or similar (which is how it was + detected). + * Test all language codes in stemlangs1. The testsuite hardcodes a list of + supported language codes which hadn't been updated since 2008. + * Improve DateRangeProcessor test coverage. + + matcher: + * Handle pruning under a positional check. This used to be impossible, but + since 1.4.13 it can happen as we now hoist AND_NOT to just below where we + hoist the positional checks. The code on master already handles pruning here + so this bug is specific to the RELEASE/1.4 branch. + * When searching with collapsing over multiple shards, at least some of which + are remote, uncollapsed_upper_bound could be too low and + uncollapsed_lower_bound too high. This was causing assertion failures in + testcases msize1 and msize2 under test harness backends + multi_glass_remoteprog_glass and multi_remoteprog_glass. + * Internally we no longer calculate a bogus total_term_count as the sum of + total_length * doc_count for all shards. Instead we just use the sum of + total_length, which gives the total number of term occurrences. This change + should improve the estimated collection_freq values for synonyms. + * Several places where we might divide zero by zero in a database where wdf was + always zero have been fixed. + + build system: + * configure: Stop using AC_FUNC_MEMCMP. The autoconf manual marks it as + "obsolescent", and it seems clear that nobody's relying on it as we're + missing the "'AC_LIBOBJ' replacement for 'memcmp'" which it would try to + use if needed. + + documentation: + * HACKING: Replace release docs with pointer to the developer guide where they + are now maintained. + + portability: + * Eliminate 2 uses of atoi(). These are potentially problematic in a + multithreaded application if setlocale() is called by another thread at the + same time. + * Don't check __GNUC__ in visibility.h as the configure probe before defining + XAPIAN_ENABLE_VISIBILITY checks that the visibility attributes work. This + probably makes no difference in practice, as all compilers we're aware of + which support symbol visibility also define __GNUC__. + * Document Sun C++ requires --disable-shared. + +- Update to 1.4.13: + + API: + * Fix write one past end of std::vector on certain QueryParser parser errors. + This is undefined behaviour, but the write was always into reserved space, so + in practice we'd actually get away with it (it was noticed because it + triggers an error when running under ubsan and using libc++). + * MSet::get_matches_estimated(): Improve rounding of result - a bug meant we + would almost always round down. + * Optimise test for UTF-8 continuation character. Performing a signed char + comparison shaves an instruction or two on most architectures. + * Database::get_revision(): Return revision 0 for a Database with no shards + rather that throwing InvalidOperationError. + * DPHWeight: Avoid dividing by 0 when searching a sharded database when one + shard is empty. The result wasn't used in this case, but it's still + undefined behaviour. Detected by UBSan. + + testsuite: + * The "singlefile" test harness backend manager now creates databases by + compacting the corresponding underlying backend database (creating it first + if need be) rather than always creating a temporary database to compact. + * Enable compaction testcases for multi and singlefile test harness backends. + * Add generated database support for remoteprog and remotetcp test harness + backends. + * Add test harness support for running testcases using a multi database + comprised of one local and one remote shard, or two remote shards. + * Check if removing existing multi stub failed. Previously if removing an + existing stub failed, the test harness would create a temporary new stub and + then try to rename it over the old one, which will always fail on Microsoft + Windows. + * Wait for xapian-tcpsrv processes to finish before moving on to the next + testcase under __WIN32__ like we already do on POSIX platforms. + + matcher: + * Optimise OP_AND_NOT better. We now combine its left argument with other + connected and-like subqueries, and gather up and hoist the negated subqueries + and apply them together above the combined and-like subqueries, just below + any positional filters. + * Optimise OP_AND_MAYBE better. We now combine its left argument with other + connected and-like subqueries, and gather up and hoist the optional + subqueries and apply them together above the combined and-like subqueries and + any hoisted positional filters. + * Treat all BoolWeight queries as scaled by 0 - we can optimise better if we + know the query is unweighted. + + glass backend: + * Allow zlib compression to reduce size by one byte. We were specifying an + output buffer size one byte smaller than the input, but it appears zlib won't + use the final byte in the buffer, so we actually need to pass the input size + as the output buffer size. + * Only try to compress Btree item values > 18 bytes, which saves CPU time + without sacrificing any significant size savings. + + remote backend: + * Fix match stats when searching with collapsing over multiple shards and at + least some shards are remote. + * Ignore orphaned remote protocol replies which can happen when searching with + a remote shard if an exception is thrown by another shard. + * Wait for xapian-progsrv child to exit when a remote Database or + WritableDatabase object is closed under __WIN32__ like we already do for + POSIX platforms. + + documentation: + * Correct documentation of initial messages in replication protocol. + + tools: + * quest: Report bounds and estimate of number of matches. + * xapian-delve: Improve output when database revision information is not + available. We now specially handle the cases of a DB with multiple shards + and a backend which doesn't support get_revision(). + + portability: + * Fix warning from GCC 9 with -Wdeprecated-copy (which is enabled by -Wextra) + if a reference to an Error object is thrown. + * Suppress GCC warning in our API headers when compiling code using Xapian with + GCC and -Wduplicated-branches. + * Mark some internal classes as final (following GCC -Wsuggest-final-types + suggestions to allow some method calls to be devirtualised). + * Fix to build with --enable-maintainer-mode and Perl < 5.10, which doesn't + have the `//=` operator. It's unlikely developers will have such an old + Perl, but the mingw environment on appveyor CI does. The use of `//=` was + introduced by changes in 1.4.10. + +- Update to 1.4.12: + + API: + * Xapian::PostingSource: When a PostingSource without a clone() method is used + with a Database containing multiple shards, the documented behaviour has + always been that Xapian::InvalidOperationError is thrown. However, since at + least 1.4.0, this exception hasn't been thrown, but instead a single + PostingSource object would get used for all the shards, typically leading to + incorrect results. The actual behaviour now matches what was documented. + * Xapian::Database: Add size() method which reports the number of shards. + * Xapian::Database::check(): You can now pass a stub database which will check + all the databases listed in it (or throw Xapian::UnimplementError for + backends which don't support checking). + * Xapian::Document: When updating a document use a emplace_hint() to make the + bulk insertion O(n) instead of O(n·log(n)), and use std::move() to avoid + copying OmDocumentTerm objects. + * Xapian::Query: Add missing get_unique_terms_end() method. + * Xapian::iterator_valid(): Implement for Utf8Iterator + + testsuite: + * Fix keepalive1 failures on some platforms. On some platforms a timeout + gives NetworkTimeoutError and on others NetworkError - since 1.4.10 changed + to checking the exact exception type, keepalive1 has been failing on the + former set of platforms. We now just check for NetworkError or a subclass + here (since NetworkTimeoutError is a subclass of NetworkError). + * Run cursordelbug1 testcase with multi databases too. + + matcher: + * Ownership of PostingSource objects during the match now makes use of the + optional reference-counting mechanism rather than a separate flag. + + remote backend: + * Fix remote protocol design bug. Previously some messages didn't send a reply + but could result in an exception being sent over the link. That exception + would then get read as a response to the next message instead of its actual + response so we'd be out of step. + This fix necessitated a minor version bump in the remote protocol (to 39.1). + If you are upgrading a live system which uses the remote backend, upgrade the + servers before the clients. + * Fix socket leaks on errors during opening a database. + * Don't close remote DB socket on receiving EOF as the levels above won't + know it's been closed and may try to perform operations on it, which would be + problematic if that fd gets reused in the meantime. Leaving it open means + any further operations will also get EOF. + * We add a wrapper around the libc socket() function which deals with the + corner case where SOCK_CLOEXEC is defined but socket() fails if it is + specified (which can happen with a newer libc and older kernel). + Unfortunately, this wrapper wasn't checking the returned value from socket() + correctly, so when SOCK_CLOEXEC was specified and non-zero it would create + the socket() with SOCK_CLOEXEC, then leak that one and create it again + without SOCK_CLOEXEC. We now check the return value properly. + * Fix potential infinite loop in ValueCountMatchSpy::merge_results() if passed + serialised results with extra data appended (which shouldn't happen in normal + use). + + build system: + * Current versions of valgrind result in false positives on current versions of + macOS, so on this platform configure now only enables use of valgrind if it's + specified explicitly. + * Refactor macros to probe for compiler flags so they automatically cache + their results and consistently report success/failure. + * Rename our custom TYPE_SOCKLEN_T macro to XAPIAN_TYPE_SOCKLEN_T. The + AX_TYPE_SOCKLEN_T macro defines an alias of TYPE_SOCKLEN_T for itself which + means it can get used instead in some situations, but it isn't compatible + with our macro. We can't just switch to AX_TYPE_SOCKLEN_T as it doesn't + handle cases we need, so just rename our macro to avoid potential problems. + + documentation: + * Improve API documentation for Xapian::Query class. Add missing doc + comments and improve some of the existing ones. + * Add Unicode consortium names and codes for categories from Chapter 4, Version + 11 of the Unicode standard. Patch from David Bremner. + * Improve configure --help output - drop "[default=no]" for --enable-* + options which default off. + Палаузов. + * Fix API documentation typo - Query::op (the type) not op_ (a parameter name). + * Note which version Document::remove_postings() was added in. + * In the remote protocol documentation, MSG_REPLACEDOCUMENTTERM was documented + as not having a reply, but actually REPLY_ADDDOCUMENT is sent. + * Update list of users. + + tools: + * copydatabase: A change in 1.4.6 which added support for \ as directory + separator on platforms where that's the norm broke the code in copydatabase + which removes a trailing slash from input databases. + + portability: + * Add missing '#include '. + * Fix str() helper function when converting the most negative value + of a signed integer type. + * Avoid calling close() on fd we know must actually be a WIN32 SOCKET. + * Include not for std::boolalpha. + * Rework setenv() compatibility handling. Now that Solaris 9 is dead we can + assume setenv() is provided by Unix-like platforms (POSIX requires it). For + other platforms, provide a compatibility implementation of setenv() which + so the compatibility code is encapsulated in one place rather than replicated + at every use. + * Fix maintainer-mode builds on Solaris where /bin/tr is not POSIX compliant. + We now use the simple workaround suggested by the autoconf manual. + * Improve support for Sun C++: + + Suppress unhelpful warning for lambda with multiple return statements. + + Enable reporting the tags corresponding to warnings, which we need + to know in order to suppress any new unhelpful warnings. + + Adjust our workaround for bug with this compiler's header to avoid + a compiler warning. + + Use -xldscope=symbolic for Sun C++. This flag is roughly equivalent to + -Bsymbolic-functions which we've probed for with GNU ld since Xapian 1.0.0. + +- Update to 1.4.11: + + API: + * MSet::SNIPPET_CJK_NGRAM - new flag for use with MSet::snippet() to enable + support for selecting and highlighting snippets which works with the + QueryParser and TermGenerator FLAG_CJK_NGRAM flags. This mode can also be + enabled by setting environment variable XAPIAN_CJK_NGRAM to a non-empty + value. (There was nominally already support for XAPIAN_CJK_NGRAM in + MSet::snippet(), but it didn't work usefully - the highlighting added was all + empty start/end pairs at the end of the span of CJK characters containing the + CJK ngram terms, which to the user would typically look like it was selecting + the end of the text and not highlighting anything). + * Deprecate XAPIAN_CJK_NGRAM environment variable. There are now flags which + can be used instead in all cases, and there's sadly no portable thread-safe + way to read an environment variable so checking environment variables is + problematic in library code that may be used in multithreaded programs. + * Query::OP_ELITE_SET currently incorrectly recursively flattens any OP_OR (or + OP_OR-like) subqueries into the list of subqueries it selects from - until + that's fixed, we now select from the full exploded list rather than the last + n (where n is the number of direct subqueries of the OP_ELITE_SET). + + testsuite: + * Testcases which need a generated database now get run with a sharded + database. + * Avoid using strerror() in the testsuite which removes an obstacle to running + tests in parallel in separate threads. + + matcher: + * Extend detection of cases of OP_SYNONYM with disjoint subqueries (which means + we don't need document length) which was added in 1.4.8 - we now detect when + all subqueries are different terms, or when all subqueries are + non-overlapping wildcards. The second case is what QueryParser produces for + a wildcard or partial query with a query prefix which maps to more than one + term prefix. + + glass backend: + * Handle an empty value slot lower bound gracefully. This shouldn't happen for + a non-empty slot, but has been reported by a notmuch user so it seems there + is (or perhaps was as the database was several years old) a way it can come + about. We now check for this situation and set the smallest possible valid + lower bound instead, so other code assuming a valid lower bound will work + correctly. + + chert backend: + * Handle an empty value slot lower bound gracefully, equivalent to the change + made for glass. + + documentation: + * HACKING: We no longer use auto_ptr<>. + * NEWS: Correct factual error in old entry - the 0.4.1 release was Open Muscat + not OmSee (the OmSee name was only applied after that final release was made, + and only used internally to BrightStation). + + portability: + * Suppress more clang -Wself-assign-overloaded warnings in testcases which are + deliberately testing handling of self-assignment. + * Add missing includes of . + + debug code: + * When configured with --enable-log, the O_SYNC flag was always specified when + opening the logfile, with the intention that the most recent log entries + wouldn't get lost if there was a crash, but O_SYNC can incur a significant + performance overhead and most debugging is not of such crashes. So we no + longer specify O_SYNC by default, but you can now request synchronous logging + by including %! anywhere in the filename specified with XAPIAN_DEBUG_LOG + (the %! is replaced with the empty string). We also now use O_DSYNC if + available in preference to O_SYNC, since the mtime of the log file isn't + important. + +- Update to 1.4.10: + + API: + * DatabaseClosedError: New exception class thrown instead of DatabaseError when + an operation is attempted which can't be completed because it involves a + database which close() was previously called on. DatabaseClosedError is a + subclass of DatabaseError so existing code catching DatabaseError will still + work as before. + * DatabaseNotFoundError: New exception class thrown instead of + DatabaseOpeningError when the problem is the problem is "file not found" or + similar. DatabaseNotFoundError is a subclass of DatabaseOpeningError so + existing code catching DatabaseOpeningError will still work as before. + * Query: Make &=, |= and ^= on Query objects opportunistically append to + an existing query with a matching query operator which has a reference + count of 1. This provides an easy way to incrementally build flatter query + trees. + * Query: Support `query &= ~query2` better - this now is handled exactly + equivalent to `query = query & ~query2` and gives `query AND_NOT query2` + instead of `query AND ( AND_NOT query2)`. + * QueryParser: Now uses &=, |= and ^= to produce flatter query trees. This + fixes problems with running out of stack space when handling Query object + trees built by abusing QueryParser to parse very large machine-generated + queries. + * Stopper: Fix incorrect accents in Hungarian stopword list. Patch from David + Corbett. + + testsuite: + * Test MSet::snippet() with small and zero lengths. + * Fix testcase stubdb4 annotations - this testcase doesn't need a backend. + * Add PATH annotation for testcases needing get_database_path() to avoid having + to repeatedly list the backends where this is supported in testcase + annotations. + * TEST_EXCEPTION helper macro now checks that the exact specified exception + type is thrown. Previously it would allow a subclass of the specified + exception type, but in testcases we really want to be able to test for an + exact type. + + matcher: + * Map OP_VALUE_GE/OP_VALUE_LE on an empty slot to EmptyPostList. We already do + this for OP_VALUE_RANGE, and it's a little more efficient than creating a + postlist object which checks the empty value slot. + + glass backend: + * We no longer flush all pending positional changes when a postlist, termlist + or all-terms is opened on a modified WritableDatabase. Doing so was + incurring a significant performance cost, and the first of these happens + internally when `replace_document(term, doc)` is used, which is the usual way + to support non-numeric unique ids. We now only flush pending positional + changes when committing. + + remote backend: + * Use poll() where available instead of select(). poll() is specified by + POSIX.1-2001 so should be widely available by now, and it allows watching any + fd (select() is limited to watching fds < FD_SETSIZE). For any platforms + which still lack poll() we now workaround this select() limitation when a + high numbered fd needs to be watched (for example, by trying a non-blocking + read or write and on EAGAIN sleeping for a bit before retrying). + * Stop watching fds for "exceptional conditions" - none of these are relevant + to our usage. + * Remove 0.1s timeout in ready_to_read(). The comment says this is to avoid a + busy loop, but that's out of date - the matcher first checks which remotes + are ready to read and then does a second pass to handle those which weren't + with a blocking read. + + build system: + * Stop probing for header sys/errno.h which is no longer used - it was only + needed for Compaq C++, support for which was dropped in 1.4.8. + + documentation: + * docs/valueranges.html: Update to document RangeProcessor instead of + ValueRangeProcessor - the latter is deprecated and will be gone in the next + release series. + * Document RangeProcessor::operator()() returns OP_INVALID to signal it doesn't + recognise a range. + * Update some URLs for pages which have moved. + * Use https for URLs where available. + * HACKING: Update "empty()" section for changes in C++11. + + portability: + * Suppress clang warnings for self-assignment tests. Some testcases trigger + this new-ish clang warning while testing that self-assignment works, which + seems a useful thing to be testing - at least one of these is a regression + test. + * Add std::move to fix clang -Wreturn-std-move warning (which is enabled by + -Wall). + * Add casts to fix ubsan warnings. These cases aren't undefined behaviour, but + are reported by ubsan extra checks implicit-integer-truncation and/or + implicit-conversion which it is useful to be able to enable to catch + potential bugs. + * Fix check for when to use _byteswap_ulong() - in practice this would only + have caused a problem if a platform provided _byteswap_ushort() but not + _byteswap_ulong(), but we're not aware of any which do. + * Fix return values of do_bswap() helpers to match parameter types (previously + we always returned int and only supported swapping types up to 32 bits, so + this probably doesn't result in any behavioural changes). + * Only include if we'll use it instead of always including it when + it exists. Including can result in warnings about duplicate + declarations of builtin functions under mingw. + * Remove call to close()/closesocket() when the argument is always -1 (since + the change to use getaddrinfo() in 1.3.3). + +------------------------------------------------------------------- +Tue Nov 20 08:59:06 UTC 2018 - alarrosa@suse.com + +- Update to 1.4.9: + * API: + + Document::add_posting(): Fix bugs with the change in 1.4.8 to more + efficiently handle insertion of a batch of extra positions in ascending + order. These could lead to missing positions and corrupted encoded + positional data. + * remote backend: + + Avoid hang if remote connection shutdown fails by not waiting for the + connection to close in this situation. Seems to fix occasional hangs seen on + macOS. Patch from Germán M. Bravo. + +- Update to 1.4.8: + * API: + + QueryParser,TermGenerator: Add new stemming mode STEM_SOME_FULL_POS. + This stores positional information for both stemmed and unstemmed terms, + allowing NEAR and ADJ to work with stemmed terms. The extra positional + information is likely to take up a significant amount of extra disk space so + the default STEM_SOME is likely to be a better choice for most users. + + Database::check(): Fetch and decompress the document data to catch problems + with the splitting of large data into multiple entries, corruption of the + compressed data, etc. Also check that empty document data isn't explicitly + stored for glass. + + Fix an incorrect type being used for term positions in the TermGenerator API. + These were Xapian::termcount but should be Xapian::termpos. Both are + typedefs for the same 32-bit unsigned integer type by default (almost always + "unsigned int") so this change is entirely compatible, except that if you + were configuring 1.4.7 or earlier with --enable-64bit-termcount you need to + also use the new --enable-64bit-termpos configure option with 1.4.8 and up or + rebuild your applications. This change was necessary to make + --enable-64bit-termpos actually useful. + + Add Document::remove_postings() method which removes all postings in a + specified term position range much more efficiently than by calling + remove_posting() repeatedly. It returns the number of postings removed. + + Fix bugs with handling term positions >= 0x80000000. Reported by Gaurav + Arora. + + Document::add_posting(): More efficiently handle insertion of a batch of + extra positions in ascending order. + + Query: Simplify OP_SYNONYM with single OP_WILDCARD subquery by converting to + OP_WILDCARD with combiner OP_SYNONYM, which means such cases can take + advantage of the new matcher optimisation in this release to avoid needing + document length for OP_WILDCARD with combiner OP_SYNONYM. + * testsuite: + + Catch and report std::exception from the test harness itself. + + apitest: Drop special case for not storing doc length in testcase postlist5 - + all backends have stored document lengths for a long time. + + test_harness: Create directories in a race-free way. + * matcher: + + Avoid needing document length for an OP_WILDCARD with combiner OP_SYNONYM. + We know that we can't get any duplicate terms in the expansion of a wildcard + so the sum of the wdf from them can't possibly exceed the document length. + + OP_SYNONYM: No longer tries to initialise weights for its subquery, which + should reduce the time taken to set up a large wildcard query. + + OP_SYNONYM: Fix frequency estimates when OP_SYNONYM is used with a + subquery containing OP_XOR or OP_MAX - in such cases the frequency + estimates for the first subquery of the OP_XOR/OP_MAX were used for + all its subqueries. Also the estimated collection frequency is + now rounded to the nearest integer rather than always being rounded + down. + * glass backend: + + Revert change made in 1.4.6: + Enable glass's "open_nearby_postlist" optimisation (which especially helps + large wildcard queries) for writable databases without any uncommitted + changes as well. + The amended check isn't conservative enough as there may be postlist changes + in the inverter while the table is unmodified. This breaks testcase + T150-tagging.sh in notmuch's testsuite, reported by David Bremner. + + When indexing a document without any terms we now avoid some unnecessary work + when storing its termlist. + * build system: + + New --enable-64bit-termpos configure option which makes Xapian::termpos a + 64-bit type and enables support for storing 64-bit termpos values in the + glass backend in an upwardly compatible way. Few people will actually want + to index documents more than 4 billion words long, but the extra numbering + space can be helpful if you want to use term positions in "interesting" ways. + + Hook up configure --disable-sse/--enable-sse=sse options for MSVC. + + Fix configure probes for builtin functions for clang. We need to specify the + argument types for each builtin since otherwise AC_CHECK_DECLS tries to + compile code which just tries to take a pointer to the builtin function + causing clang to give an error saying that's not allowed. If the argument + types are specified then AC_CHECK_DECLS tries to compile a call to the + builtin function instead. + * documentation: + + Fix documentation comment typo. + * tools: + + xapian-delve: Test for all docs empty using get_total_length() which is + slightly simpler internally than get_avlength(), and avoids an exact floating + point equality check. + * examples: + + quest: Support --weight=coord. + + xapian-pos: New tool to show term position info to help debugging when using + positional information in more complex ways. + * portability: + + Fix undefined behaviour from C++ ODR violation due to using the same name + two different non-static inline functions. It seems that with current GCC + versions the desired function always ends up being used, but with current + clang the other function is sometimes used, resulting in database corruption + when using value slots in docid 16384 or higher with the default glass + backend. Patch from Germán M. Bravo. + + Suppress alignment cast warning on sparc Linux. The pointer being cast is to + a record returned by getdirentries(), so it should be suitable aligned. + + Drop special handling for Compaq C++. We never actually achieved a working + build using it, and I can find no evidence that this compiler still exists, + let alone that it was updated for C++11 which we now require. + + Create new database directories in race-free way. + + Avoid throwing and handling an exception in replace_document() when + adding a document with a specified docid which is <= last_docid but currently + unused. + + Use our portable code for handling UUIDs on all platforms, and only use + platform-specific code for generating a new UUID. This fixes a bug with + converting UUIDs to and from string representation on FreeBSD, NetBSD and + OpenBSD on little-endian platforms which resulted in reversed byte order in + the first three components, so the same database would report a different + UUID on these platforms compared to other platforms. With this fix, the + UUIDs of existing databases will appear to change on these platforms + (except in rare "palindronic" cases). Reported by Germán M. Bravo. + + Fix to build with a C++17 compiler. Previously we used a "byte" type + internally which clashed with "std::byte" in source files which use + "using namespace std;". Fixes #768, reported by Laurent Stacul. + + Adjust apitest testcase stubdb2 to allow for NetBSD oddity: NetBSD's + getaddrinfo() in IPv4 mode seems to resolve ::1 to an IPv4 address on the + local network. + + Avoid timer_create() on OpenBSD and NetBSD. On OpenBSD it always fails with + ENOSYS (and there's no prototype in the libc headers), while on NetBSD it + seems to work, but the timer never seems to fire, so it's useless to us (see + #770). + + Use SOCK_NONBLOCK if available to avoid a call to fcntl(). It's supported by + at least Linux, FreeBSD, NetBSD and OpenBSD. + + Use O_NOINHERIT for O_CLOEXEC on Windows. This flag has essentially the same + effect, and it's common in other codebases to do this. + + On AIX O_CLOEXEC may be a 64-bit constant which won't fit in an int. To + workaround this stupidity we now call the non-standard open64x() instead + of open() when the flags don't fit in an int. + + Add functions to add/multiply with overflow check. These are implemented + with compiler builtins or equivalent where possible, so the overflow check + will typically just require a check of the processor's overflow or carry + flag. + + +------------------------------------------------------------------- +Wed Oct 24 05:42:05 UTC 2018 - sean@suspend.net + +- Update to 1.4.7: + * API: + + Database::check(): Fix bogus error reports for documents with length + zero due to a new check added in 1.4.6 that the doclength was between the + stored upper and lower bounds, which failed to allow for the lower bound + ignoring documents with length zero (since documents indexed only by + boolean terms aren't involved in weighted searches). + + + Query: Use of Query::MatchAll in multithreaded code causes problems + because the reference counting gets messed up by concurrent updates. + Document that Query(string()) should be used instead of MatchAll in + multithreaded code, and avoid using it in library code. + + * Stem: + + Stemming algorithms added for Irish, Lithuanian, Nepali and Tamil. + + Merge Snowball compiler changes which improve code generation. + + Merge optimisations to the Arabic and Turkish stemmers. + + * testsuite: + + Fix duplicate test in apitest closedb10 testcase. + + * See also https://xapian.org/docs/xapian-core-1.4.7/NEWS + +------------------------------------------------------------------- +Tue Jul 24 09:11:32 UTC 2018 - jengelh@inai.de + +- Fix RPM groups. +- Trim bias and redundancies from description. + +------------------------------------------------------------------- +Tue Jul 3 09:21:00 UTC 2018 - alarrosa@suse.com + +- Update to 1.4.6: + * API classes now support C++11 move semantics when using a compiler which + we are confident supports them (currently compilers which define + __cplusplus >= 201103 plus a special check for MSVC 2015 or later). + C++11 move semantics provide a clean and efficient way for threaded code to + hand-off Xapian objects to worker threads, but in this case it's very + unhelpful for availability of these semantics to vary by compiler as it + quietly leads to a build with non-threadsafe behaviour. To address this, + user code can #define XAPIAN_MOVE_SEMANTICS before #include to + force this on, and will then get a compilation failure if the compiler + lacks suitable support. + + * MSet::snippet(): + + We were only escaping output for HTML/XML in some cases, which would + potentially allow HTML to be injected into output (this fixes + bnc#1099925, CVE-2018-0499). + + Include certain leading non-word characters in snippets. Previously we + started the snippet at the start of the first actual word, but there are + various cases where including non-word characters in front of the actual + word adds useful context or otherwise aids comprehension. + + * Add MSetIterator::get_sort_key() method. The sort key has always been + available internally, but wasn't exposed via the public API before, which + seems like an oversight as the collapse key has long been available. + + * Database::compact(): + + Allow Compactor::resolve_duplicate_metadata() implementations to delete + entries. Previously if an implementation returned an empty string this + would result in a user meta-data entry with an empty value, which isn't + normally achievable (empty meta-data values aren't stored), and so will + cause odd behaviour. We now handle an empty returned value by + interpreting it in the natural way - it means that the merged result is + to not set a value for that key in the output database. + + Since 1.3.5 compacting a WritableDatabase with uncommitted changes throws + Xapian::InvalidOperationError when compacting to a single-file glass + database. This release adds similar checks for chert and when compacting + to a multiple-file glass database. + + In the unlikely event that the total number of documents or the total + length of all documents overflow when trying to compact a multi-database, + we throw an exception. This is now a DatabaseError exception instead of a + const char* exception (a hang-over from before this code was turned into a + public API in the library). + + * See also https://xapian.org/docs/xapian-core-1.4.6/NEWS + +------------------------------------------------------------------- +Thu Dec 14 10:43:38 UTC 2017 - alarrosa@suse.com + +- Update to 1.4.5: + * Add Database::get_total_length() method. Previously you had to calculate + this from get_avlength() and get_doccount(), taking into account rounding + issues. But even then you couldn't reliably get the exact value when total + length is large since a double's mantissa has more limited precision than an + unsigned long long. + * Add Xapian::iterator_rewound() for bidirectional iterators, to test if the + iterator is at the start (useful for testing whether we're done when + iterating backwards). + * DatabaseOpeningError exceptions now provide errno via get_error_string() + rather than turning it into a string and including it in the exception + message. + * WritableDatabase::replace_document(): when passed a Document object which + came from a database and has unmodified values, we used to always read + those values into a memory structure. Now we only do this if the document + is being replaced to the same document ID which it came from, which should + make other cases a bit more efficient. + * Enquire::get_eset(): When approximating term frequencies we now round to the + nearest integer - previously we always rounded down. + * See also https://xapian.org/docs/xapian-core-1.4.5/NEWS + +------------------------------------------------------------------- +Fri Jun 30 15:46:49 UTC 2017 - alarrosa@suse.com + +- Update to 1.4.4: + * Database::check(): + + Fix checking a single table - changes in 1.4.2 broke such checks unless + you specified the table without any extension. + + Errors from failing to find the file specified are now thrown as + DatabaseOpeningError (was DatabaseError, of which DatabaseOpeningError is + a subclass so existing code should continue to work). Also improved the + error message when the file doesn't exist is better. + * Drop OP_SCALE_WEIGHT over OP_VALUE_RANGE, OP_VALUE_GE and OP_VALUE_LE in + the Query constructor. These operators always return weight 0 so + OP_SCALE_WEIGHT over them has no effect. Eliminating it at query + construction time is cheap (we only need to check the type of the + subquery), eliminates the confusing "0 * " from the query description, + and means the OP_SCALE_WEIGHT Query object can be released sooner. + Inspired by Shivanshu Chauhan asking about the query description on IRC. + * Drop OP_SCALE_WEIGHT on the right side of OP_AND_NOT in the Query + constructor. OP_AND_NOT takes no weight from the right so OP_SCALE_WEIGHT + has no effect there. Eliminating it at query construction time is cheap + (just need to check the subquery's type), eliminates the confusing "0 * " + from the query description, and means the OP_SCALE_WEIGHT object can be + released sooner. + * See also https://xapian.org/docs/xapian-core-1.4.4/NEWS + +------------------------------------------------------------------- +Wed Feb 1 09:40:00 UTC 2017 - alarrosa@suse.com + +- Update to 1.4.3: + * MSet::snippet(): Favour candidate snippets which contain more of a diversity + of matching terms by discounting the relevance of repeated terms using an + exponential decay. A snippet which contains more terms from the query is + likely to be better than one which contains the same term or terms multiple + times, but a repeated term is still interesting, just less with each + additional appearance. Diversity issue highlighted by Robert Stepanek's + patch in https://github.com/xapian/xapian/pull/117 - testcases taken from his + patch. + + * MSet::snippet(): New flag SNIPPET_EMPTY_WITHOUT_MATCH to get an empty snippet + if there are no matches in the text passed in. Implemented by Robert + Stepanek. + + * Round MSet::get_matches_estimated() to an appropriate number of significant + figures. The algorithm used looks at the lower and upper bound and where the + estimate sits between them, and then picks an appropriate number of + significant figures. Thanks to Sébastien Le Callonnec for help sorting out a + portability issue on OS X. + + * Add Database::locked() method - where possible this non-invasively checks if + the database is currently open for writing, which can be useful for + dashboards and other status reporting tools. + + * See also https://xapian.org/docs/xapian-core-1.4.3/NEWS + +- Update to 1.4.2: + * Add XAPIAN_AT_LEAST(A,B,C) macro. + + * MSet::snippet(): Optimise snippet generation - it's now ~46% faster in a + simple test. + + * Add Xapian::DOC_ASSUME_VALID flag which tells Database::get_document() that + it doesn't need to check that the passed docid is valid. Fixes #739, + reported by Germán M. Bravo. + + * TfIdfWeight: Add support for the L wdf normalisation. Patch from Vivek Pal. + + * BB2Weight: Fix weights when database has just one document. Our existing + attempt to clamp N to be at least 2 was ineffective due to computing + N - 2 < 0 in an unsigned type. + + * DPHWeight: Fix reversed sign in quadratic formula, making the upper bound a + tiny amount higher. + + * DLHWeight: Correct upper bound which was a bit too low, due to flawed logic + in its derivation. The new bound is slightly less tight (by a few percent). + + * DLHWeight,DPHWeight: Avoid calculating log(0) when wdf is equal to the + document length. + + * TermGenerator: Handle stemmer returning empty string - the Arabic stemmer + can currently do this (e.g. for a single tatweel) and user stemmers can too. + Fixes #741, reported by Emmanuel Engelhart. + + * Database::check(): Fix check that the first docid in each doclength chunk is + more than the last docid in the previous chunk - this code was in the wrong + place so didn't actually work. + + * Database::get_unique_terms(): Clamp returned value to be <= document length. + Ideally get_unique_terms() ought to only count terms with wdf > 0, but that's + expensive to calculate on demand. + + * See also https://xapian.org/docs/xapian-core-1.4.2/NEWS + +------------------------------------------------------------------- +Fri Nov 11 10:02:34 UTC 2016 - alarrosa@suse.com + +- Update to 1.4.1 + * Constructing a Query for a non-reference counted PostingSource object will + now try to clone the PostingSource object (as happened in 1.3.4 and + earlier). This clone code was removed as part of the changes in 1.3.5 to + support optional reference counting of PostingSource objects, but that breaks + the case when the PostingSource object is on the stack and goes out of scope + before the Query object is used. Issue reported by Till Schäfer and analysed + by Daniel Vrátil in a bug report against Akonadi: + https://bugs.kde.org/show_bug.cgi?id=363741 + + * Add BM25PlusWeight class implementing the BM25+ weighting scheme, implemented + by Vivek Pal (https://github.com/xapian/xapian/pull/104). + + * Add PL2PlusWeight class implementing the PL2+ weighting scheme, implemented + by Vivek Pal (https://github.com/xapian/xapian/pull/108). + + * LMWeight: Implement Dir+ weighting scheme as DIRICHLET_PLUS_SMOOTHING. + Patch from Vivek Pal. + + * Add CoordWeight class implementing coordinate matching. This can be useful + for specialised uses - e.g. to implement sorting by the number of matching + filters. + + * DLHWeight,DPHWeight,PL2Weight: With these weighting schemes, the formulae + can give a negative weight contribution for a term in extreme cases. We + used to try to handle this by calculating a per-term lower bound on the + contribution and subtracting this from the contribution, but this idea + is fundamentally flawed as the total offset it adds to a document depends on + what combination of terms that document matches, meaning in general the + offset isn't the same for every matching document. So instead we now clamp + each term's weight contribution to be >= 0. + + * TfIdfWeight: Always scale term weight by wqf - this seems the logical + approach as it matches the weighting we'd get if we weighted every non-unique + term in the query, as well as being explicit in the Piv+ formula. + + * Fix OP_SCALE_WEIGHT to work with all weighting schemes - previously it was + ignored when using PL2Weight and LMWeight. + + * PL2Weight: Greatly improve upper bound on weight: + + Split the weight equation into two parts and maximise each separately as + that gives an easily solvable problem, and in common cases the maximum is + at the same value of wdfn for both parts. In a simple test, the upper + bounds are now just over double the highest weight actually achieved - + previously they were several hundred times. This approach was suggested by + Aarsh Shah in: https://github.com/xapian/xapian/pull/48 + + Improve upper bound on normalised wdf (wdfn) - when wdf_upper_bound > + doclength_lower_bound, we get a tighter bound by evaluating at + wdf=wdf_upper_bound. In a simple test, this reduces the upper bound on + wdfn by 36-64%, and the upper bound on the weight by 9-33%. + + * PL2Weight: Fix calculation of upper_bound when P2>0. P2 is typically + negative, but for a very common term it can be positive and then we should + use wdfn_lower not wdfn_upper to adjust P_max. + + * Weight::unserialise(): Check serialised form is empty when unserialising + parameter-free schemes BoolWeight, DLHWeight and DPHWeight. + + * TermGenerator::set_stopper_strategy(): New method to control how the Stopper + object is used. Patch from Arnav Jain. + + * QueryParser: Fix handling of CJK query over multiple prefixes. Previously + all the n-gram terms were AND-ed together - now we AND together for each + prefix, then OR the results. Fixes #719, reported by Aaron Li. + + * Add Database::get_revision() method which provides access to the database + revision number for chert and glass, intended for use by xapiand. Marked + as experimental, so we don't have to go through the usual deprecation cycle + if this proves not to be the approach we want to take. Fixes #709, + reported by German M. Bravo. + + * Mark RangeProcessor constructor as `explicit`. + + * See also https://xapian.org/docs/xapian-core-1.4.1/NEWS + +- A compiler with support for C++11 is required, so + specify BuildRequires gcc-c++ >= 4.6 + +------------------------------------------------------------------- +Sat Jul 9 06:25:35 UTC 2016 - tittiatcoke@gmail.com + +- Update to 1.4.0 + * API + + Update to Unicode 9.0.0 + + Reimplement ESet and ESetIterator + + MSetIterator and ESetIterator are now STL-compatible + random_access_iterators + * See also http://xapian.org/docs/xapian-core-1.4.0/NEWS + +------------------------------------------------------------------- +Wed Apr 13 07:07:04 UTC 2016 - tittiatcoke@gmail.com + +- Update to 1.2.23 + * API + + PostingSource: Public member variables are now wrapped by methods + * chert backend + + xapian-check now performs additional consistency checks for chert. + * omega + + Fix HTML/XML entity decoding to be O(n) not O(n²) - indexing + HTML/XML with a lot of entities is now much faster. + +------------------------------------------------------------------- +Thu May 21 08:54:55 UTC 2015 - tittiatcoke@gmail.com + +- Update to 1.2.21 + * API: + + QueryParser: Extend the set of characters allowed in the + start of a range to be anything except for '(' and characters <= ' '. + + * matcher: + + Reimplement OP_PHRASE for non-exact phrases. + + Reimplement OP_NEAR - the new implementation consistently + requires the terms to occur at different positions, and fixes + some previously missed matches. + + Fix a reversed check for picking the shorter position list + for an exact phrase of two terms. + + When matching an exact phrase, if a term doesn't occur where + we want, use its actual position to advance the anchor term, + rather than just checking the next position of the anchor term. + + * brass backend: + + Fix cursor versioning to consider cancel() and reopen() as + events where the cursor version may need incrementing, + and flag the current cursor version as used when a cursor is rebuilt. + + Avoid using file descriptions < 3 for writable database tables, + as it risks corruption if some code in the same process tries + to write to stdout or stderr without realising it is closed. + + * chert backend: + + Fix cursor versioning to consider cancel() and reopen() as + events where the cursor version may need incrementing, + and flag the current cursor version as used when a cursor is rebuilt. + + Avoid using file descriptions < 3 for writable database tables, + as it risks corruption if some code in the same process tries + to write to stdout or stderr without realising it is closed. + + * flint backend: + + Fix cursor versioning to consider cancel() and reopen() as + events where the cursor version may need incrementing, + and flag the current cursor version as used when a cursor is rebuilt. + + + * remote backend: + + + Fix sort by value when multiple databases are in use and one or + more are remote. + + * build system: + + + The compiler ABI check in the public API headers now issues a + warning (instead of an error) for an ABI mismatch for ABI versions + 2 and later (which means GCC >= 3.4). + + xapian-config,xapian-core.pc: When compiling with xlC on AIX, the + reported --cxxflags/--cflags now include -D_LARGE_FILES=1 as this + is defined for the library, and defining it changes the ABI of + std::string with this compiler, so it must also be defined when + building code using the Xapian API. + + xapian-core.pc: Include --enable-runtime-pseudo-reloc in --libs + output for mingw and cygwin, like xapian-config does. + + xapian-core.pc: Fix include directory reported by `pkg-config --cflags`. + + xapian-config: Fix typo so cached result of test in is_uninstalled() + is actually used on subsequent calls. + + configure: Changes in 1.2.19 broke the custom macro we use to probe + for supported compiler flags such that the flags never got used. + + configure: Set default value for AUTOM4TE before AC_OUTPUT so the + default will actually get used. + + soaktest: Link with libtool's '-no-install' or '-no-fast-install', + like we already do for other test programs, which means that libtool + doesn't need to generate shell script wrappers for them on most platforms. + + * documentation: + + API documentation: Minor wording tweaks and formatting improvements. + + docs/deprecation.rst: Add deprecation of omindex --preserve-nonduplicates + which happened in 1.2.4. + + HACKING: libtool 2.4.6 is now used for bootstrapping snapshots and releases. + + * tools: + + xapian-compact: Make sure we open all the tables of input databases at the + same revision. + + xapian-metadata: Add 'list' subcommand to list all the metadata keys. + + xapian-replicate: Fix connection timeout to be 10 seconds rather than 10000 + seconds (the incorrect timeout has been the case since 1.2.3). + + xapian-replicate: Set SO_KEEPALIVE for xapian-replicate's connection to the + master, and add command line option to allow setting socket-level timeouts + (SO_RCVTIMEO and SO_SNDTIMEO) on platforms that support them. + + xapian-replicate-server: Avoid potentially reading uninitialised data if a + changeset file is truncated. + + * portability: + + Add spaces between literal strings and macros which expand to literal strings + for C++11 compatibility. + + ValueCountMatchSpy::top_values_begin(): Fix the comparison function not to + return true for two equal elements, which manifests as incorrect sorting in + some cases when using clang's libc++ (which recent OS X versions do). + + apitest: The adddoc5 testcase fails under clang due to an exception handling + bug, so just #ifdef out the problematic part of the testcase when building + with clang for now. + + configure: Improve the probe for whether the test harness can use RTTI to + work for IBM's xlC compiler (which defaults to not generating RTTI). + + Use F_DUPFD where available to dup to a file descriptor which is >= 2, rather + than calling dup() until we get one. + + When unserialising a double, avoid reading one byte past the end of the + serialised value. + + When unserialising a double, add missing cast to unsigned char when we check + if the value will fit in the double type. + + Fix incorrect use of "delete" which should be "delete []". This is + undefined behaviour in C++, though the type is POD, so in practice this + probably worked OK on many platforms. + +- Drop patch 0001-backends-chert-chert_cursor.cc-backends-chert-chert_.patch + due to upstream inclusion + +------------------------------------------------------------------- +Sat May 2 01:27:33 UTC 2015 - hrvoje.senjan@gmail.com + +- Add 0001-backends-chert-chert_cursor.cc-backends-chert-chert_.patch + from upstream (kde#341990, http://trac.xapian.org/ticket/675) + +------------------------------------------------------------------- +Thu Mar 12 07:34:11 UTC 2015 - mpluskal@suse.com + +- Update to 1.2.20 + * chert backend + + After splitting a block, we always insert the new block in + the parent right after the block it was split from - there's + no need to binary chop. + * build system + + Generate and install a file for pkg-config. + + configure: Update link to cygwin FAQ in error message. + * tools + + xapian-check: For chert and brass, cross-check the position + and postlist tables to detect positional data for non-existent + documents. + * portability + + When locking a database for writing, use F_OFD_SETLK where + available, which avoids having to fork() a child process to + hold the lock. This currently requires Linux kernel >= 3.15, + but it has been submitted to POSIX so hopefully will be widely + supported eventually. Thanks to Austin Clements for pointing + out this now exists. + + Fix detection of fdatasync(), which appears to have been + broken practically forever - this means we've probably been + using fsync() instead, which probably isn't a big additional + overhead. Thanks to Vlad Shablinsky for helping with Mac + OS X portability of this fix. + + configure: Define MINGW_HAS_SECURE_API under mingw to get + _putenv_s() declared in stdlib.h. + + Use POSIX O_NONBLOCK in preference to O_NDELAY - the + semantics of the latter differ between BSD and System V. + + According to POSIX, strerror() may not be thread safe, so + use alternative thread-safe ways to translate errno values + where possible. + + On Microsoft Windows, avoid defining EADDRINUSE, etc if + they're already defined, and use WSAE* constants un-negated - + they start from a high value so won't collide with E* + constants. + +------------------------------------------------------------------- +Fri Feb 20 09:57:10 UTC 2015 - mpluskal@suse.com + +- Tiny spec file cleanups +- Add gpg signature + +------------------------------------------------------------------- +Tue Oct 21 12:18:41 UTC 2014 - tittiatcoke@gmail.com + +- Update to 1.2.19 + - API: + * Xapian::BM5Weight: + + Improve BM25 upper bound in the case when our wdf upper + bound > our document length lower bound. + + Pre-multiply termweight by (param_k1 + 1) rather than + doing it for every weighted term in every document considered. + - testsuite: + * Don't report apparent leaks of fds opened on /dev/urandom + - matcher: + * Fix false matches reported for non-exact phrases in some cases. + - build system: + * For Sun's C++ compiler, pass -library=Crun separately since + libtool looks for " -library=stlport4 " (with the spaces). + * Remove .replicatmp (created by the test suite) upon "make clean". + - documentation: + * include/xapian/compactor.h: Fix formatting of doxygen comment. + * HACKING: freecode no longer accepts updates, so drop that item + from the release checklist. + * docs/overview.rst: Add missing database path to example of using + xapian-progsrv in a stub database file. + - portability: + * Suppress unused typedef warnings from debugging logging macros, + which occur in functions which always exit via throwing an + exception when compiling with recent versions of GCC or clang. + * Fix debug logging code to compile with clang. + +------------------------------------------------------------------- +Thu Sep 11 16:20:33 UTC 2014 - hrvoje.senjan@gmail.com + +- Add baselibs.conf, needed by baloo 32bit libraries + +------------------------------------------------------------------- +Mon Apr 28 08:10:37 UTC 2014 - tittiatcoke@gmail.com + +- Switch the SSE instruction set of for x86 builds. + +------------------------------------------------------------------- +Wed Jan 29 22:10:21 UTC 2014 - hrvoje.senjan@gmail.com + +- Update to 1.2.17 + - API: + * Enquire::set_sort_by_relevance_then_value() and + Enquire::set_sort_by_relevance_then_key(): Fix sense of reverse + parameter. + * BM25Weight: Fix case where (k1 == 0 || b == 0) but k2 != 0. + * Unicode::tolower(): Fix to give correct results for U+01C5, + U+01C8, U+01CB, and U+01F2 + - testsuite: + * Automatically probe for and hook in eatmydata to the testsuite + using the wrapper script it now includes. + * Fix apitest to build when brass, chert or flint are disabled. + - brass backend: + * Fix handling of invalid block sizes passed to Xapian::Brass::open() + - the size gets fixed as documented, but the uncorrected size + was passed to the base file (and abort() was called if 0 + was passed). + * Validate "dir_end" when reading a block. (fixes #592) + - chert backend: + * Fix handling of invalid block sizes passed to Xapian::Chert::open() + - the size gets fixed as documented, but the uncorrected size was + passed to the base file (and abort() was called if 0 was passed). + * Validate "dir_end" when reading a block. (fixes #592) + - flint backend: + * Fix handling of invalid block sizes passed to Xapian::Flint::open() + - the size gets fixed as documented, but the uncorrected size was + passed to the base file (and abort() was called if 0 was passed). + * Validate "dir_end" when reading a block. (fixes #592) + - build system: + * configure: Improve reporting of GCC version. + * Use -no-fast-install on platforms where -no-install causes + libtool to emit a warning. + * docs/Makefile.am: Fix handling of MAINTAINER_NO_DOCS. + * Include UnicodeData.txt and the script to generate the unicode + tables from it. + - documentation: + * postingsource.rst: Clarify a couple of points + - portability: + * Protect the ValueIterator::check() method against Mac OS X SDK + headers which define a check() macro. + * Fix warning from xlC compiler. + * Avoid use of grep -e in configure, as /usr/bin/grep on Solaris + doesn't support -e. + * Fix check for flags which might be needed for ANSI mode for + compilers called 'cxx'. + * configure: Improve handling of Sun's C++ compiler - trick libtool + into not adding -library=Cstd, and prefer -library=stdcxx4 if + supported. Explicitly add -library=Crun which seems to be required, + even though the documentation suggests otherwise. + +------------------------------------------------------------------- +Sun Dec 15 20:24:21 UTC 2013 - hrvoje.senjan@gmail.com + +- Update to 1.2.16 + - API: + * PositionIterator,PostingIterator,TermIterator,ValueIterator: + Don't segfault if skip_to() or check() is called on an iterator + which is already at_end(). + * ValueCountMatchSpy: get_description() on a default-constructed + ValueCountMatchSpy object no longer fails when xapian-core is + built with --enable-log. + * ValueCountMatchSpy: get_total() on a default-constructed + ValueCountMatchSpy object now returns 0 rather than segfaulting. + - brass backend: + * When moving a cursor on a read-only table, check if the block we + want is in the internal cursor. We already do this for a + writable table, as it is necessary for correctness, but it's a + cheap check and may avoid asking the OS for a block we actually + already have. + * Correctly report the database as closed rather than + 'Bad file descriptor' in certain cases. + * Reuse a cursor for reading values from valuestreams rather than + creating a new one each time. This can dramatically reduce the + number of blocks redundantly reread when sorting by value. + The rereads will generally get served from VM cache, but there's + still an overhead to that. + - chert backend: + * When moving a cursor on a read-only table, check if the block + we want is in the internal cursor. We already do this for a + writable table, as it is necessary for correctness, but it's + a cheap check and may avoid asking the OS for a block we actually + already have. + * Correctly report the database as closed rather than + 'Bad file descriptor' in certain cases. + * Reuse a cursor for reading values from valuestreams rather than + creating a new one each time. This can dramatically reduce the + number of blocks redundantly reread when sorting by value. + The rereads will generally get served from VM cache, but there's + still an overhead to that. + - flint backend: + * When moving a cursor on a read-only table, check if the block we + want is in the internal cursor. We already do this for a writable + table, as it is necessary for correctness, but it's a cheap check + and may avoid asking the OS for a block we actually already have. + * Correctly report the database as closed rather than + 'Bad file descriptor' in certain cases. + - tools: + * xapian-chert-update: Fix -b to work rather than always + segfaulting (reported in http://bugs.debian.org/716484). + * xapian-chert-update: The documented alias --blocksize for -b has + never actually been supported, so just drop mentions of it + from --help and the man page. + - xapian-check: + * Fix chert database check that first docid in each doclength + chunk is more than the last docid in the previous chunk + - previously this didn't actually work. + * Fix database check not to falsely report "position table: Junk + after position data" whenever there are 7 unused bits (7 is OK, + *more* than 7 isn't). + * Fix to report block numbers correctly for links within the B-tree. + * If the METAINFO key is missing, only report it once per table. + * Fix database consistency checking to always open all the tables + at the same revision - not doing this could lead to false errors + being reported after a commit interrupted by the process being + killed or the machine crashing. +- Change tarball to xz. Added xz BuildRequires: xz for that purpose + +------------------------------------------------------------------- +Thu May 30 17:36:39 UTC 2013 - tittiatcoke@gmail.com + +- Update to version 1.2.15 + * See http://svn.xapian.org/*checkout*/tags/1.2.15/xapian-core/NEWS + +------------------------------------------------------------------- +Fri Dec 21 10:22:07 UTC 2012 - mlin@suse.com + +- Update to version 1.2.12 + * 1.2.11 had its library version information incorrectly set. + This resulted in the shared library having an incorrect SONAME. + This release has been made to fix this problem. + * Fix issue with running AND, OR and XOR queries against a + database with no documents in it - this was leading to a divide + by zero, which led to MSet::get_matches_estimated() reporting + 2147483648 on i386. + * Don't count unweighted subqueries of MultiAndPostList in + percentage calculations, as OP_FILTER maps to MultiAndPostList + now. (ticket#590) + * When compacting, if the output database is empty, don't write + out a metainfo tag. Take care not to divide by zero when + computing the percentage size change for a table. + (brass and chert backend) + * Add new QueryParser::STEM_ALL_Z stemming strategy, which + stems all terms and adds a Z prefix. + * Add TermGenerator::set_stemming_strategy() method, with + strategies which correspond to those of QueryParser. + * Correct "BM25Weight" to "TradWeight" in exception message + from TradWeight. + * We were failing to call init() for user-defined Weight objects + providing the term-independent weight. These now get called + with init(0.0). + * Xapian::Auto::open_stub() now throws a Xapian::DatabaseOpeningError + exception if the stub file can't be opened. Previously we + failed to check for this condition, which resulted in us + treating the file as empty. + * See http://svn.xapian.org/*checkout*/tags/1.2.12/xapian-core/NEWS + * http://svn.xapian.org/*checkout*/tags/1.2.11/xapian-core/NEWS + * http://svn.xapian.org/*checkout*/tags/1.2.10/xapian-core/NEWS + * http://svn.xapian.org/*checkout*/tags/1.2.9/xapian-core/NEWS + +------------------------------------------------------------------- +Thu Dec 29 11:31:53 CET 2011 - dmueller@suse.de + +- update to 1.2.8: + * Add support to TermGenerator and QueryParser for indexing and searching CJK + text using n-grams. Currently this is only enabled when the environmental + variable XAPIAN_CJK_NGRAM is set to a non-empty value. + * overview.html,quickstart.html: Fix several factual errors. + * Improve documentation comments for several methods. + * Add documentation for function parameters which didn't have it. + +------------------------------------------------------------------- +Mon Nov 28 19:46:42 UTC 2011 - coolo@suse.com + +- avoid packaging files twice + +------------------------------------------------------------------- +Tue Sep 13 09:29:48 UTC 2011 - prusnak@opensuse.org + +- updated to 1.2.7 + +------------------------------------------------------------------- +Tue May 3 17:55:49 UTC 2011 - tittiatcoke@gmail.com + +- Update to xapian-core-1.2.5 + * See http://svn.xapian.org/*checkout*/tags/1.2.5/xapian-core/NEWS + +----------------------------------------------------------------- +Sat May 16 19:26:33 CET 2009 - tittiatcoke@gmail.com + +- Updated to xapian-core-1.0.12 + + See http://svn.xapian.org/*checkout*/tags/1.0.12/xapian-core/NEWS + +------------------------------------------------------------------- +Wed Mar 18 13:34:33 CET 2009 - tittiatcoke@gmail.com + +- Updated to xapian-core-1.0.11 + +------------------------------------------------------------------- +Mon Nov 19 23:41:33 CET 2007 - mrueckert@suse.de + +- added xapian-core-1.0.4_gcc43.patch: + add missing includes for gcc 4.3 + +------------------------------------------------------------------- +Mon Nov 19 22:00:09 CET 2007 - mrueckert@suse.de + +- update to 1.0.4 + +------------------------------------------------------------------- +Sun Jun 24 11:41:40 CEST 2007 - mrueckert@suse.de + +- update to 1.0.1 + +------------------------------------------------------------------- +Sun Apr 1 21:15:32 CEST 2007 - mrueckert@suse.de + +- update to 0.9.10 + +------------------------------------------------------------------- +Sat Nov 11 05:10:49 CET 2006 - mrueckert@suse.de + +- update to 0.9.9: + many smaller changes + +------------------------------------------------------------------- +Sat Nov 4 12:08:31 CET 2006 - mrueckert@suse.de + +- do not package .deps and .libs in the examples dir + +------------------------------------------------------------------- +Sat Nov 4 11:41:25 CET 2006 - mrueckert@suse.de + +- update to 0.9.8: + many small fixes + diff --git a/xapian-core.keyring b/xapian-core.keyring new file mode 100644 index 0000000..ec2f0fb --- /dev/null +++ b/xapian-core.keyring @@ -0,0 +1,957 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v2 + +mQINBEotw/sBEADdemb+B62zlcGNLuvKIY9aGb9N1OiEsILm/BshHAsCeGIauWzh +GbWC9tjMWpSX+k6WdQatwcyDzvvrSlQOuxTCgsiGInLkK0hKHH/qwtqkr4EqGI83 +yMTfS1NBC3N2mp6c0CfhIzknrGRGRtVed02muVVNIKf7ElKv0crgFxbVUchKBb55 +6nKFDVM0trddMS8MlYzHyFM1z6rC4RcGpRPgZgsCQ8Yp6ep+eR7kioeqaWSaq9zd +lQeLjX+QfKOjcoTNDmgbl1tsGNWC2XMiiCD7xpRHn5ZXUguuMIWN0UKV/YQ080tv +iO0tboyVijP/Nc7/+mM+SJOKOzkSUfiMIhHGD0HqQqtHUablSNOziOOIvUjopj6b +qAY0RIBY4rGJqs/Ta7n63HgTA7TXHHIA9IXKL2aN3DZWVKRZYZxCRnq9+S2GUIYw +9x9ZzjjpEkY5wYyGX/weky56Yp8OTPU352x8JLx66TgmdlQH6n2EqyXBw+OmzrP3 +TYRU9NQa70tHaXt8VkENAmkh1CnENUp8MEP/p1xrte+2gPXqD8eR3HtauyD/2w2m +AfZxcLtiRWkBbcjsgoxq5LJS5wXnHAximo6zebLBzRf+Uy8kfs92IfnzZcnXlRoI +/UR4O4g6yVRxD5mPJBv6qyYCxkF3phnf07emaus9ZKE6weptUNWcr1lDLQARAQAB +tBxPbGx5IEJldHRzIDxvbGx5QGRlYmlhbi5vcmc+iEYEEBECAAYFAkrkqQQACgkQ +1cqbBPLEI7z6fwCfVF0wiMUAAsatFHj4eoZP6Z1AKaMAn0CDddXek9/EjHXU6RHB +HzmmPuwWiEYEEBECAAYFAkrkzPMACgkQrnto870qlTvA7QCfVbr9PI691be4KPNT +OE1/qJcEFWwAn1yKKfPs0rUFYp/Kdk9XimXKrCQOiEYEEBECAAYFAkrlOQ4ACgkQ +/AZAiGayWEMnxACaA8TxUbtmpMbZdijz+JWUKSNOTt8AoM8YRPzo/Qx4s2Tcrf76 +KIdqYXuDiEYEEBECAAYFAktWmRkACgkQdwG7hYl686Mg2ACdHVxyNE/EEXMhVHGO +11afvKyhpDMAoNKOpsy6F64wft0X6Ft2l/bqgLwhiEYEEBECAAYFAktXtpoACgkQ +/R/ZI1P0XTIlDwCdEu5NEcRtwZMmosxBO9q7wJKZkmAAnAoC9u47BfLE61APPTCS +XYd32sUAiEYEEBECAAYFAktmAfQACgkQArxCt0PiXR4a+gCdGjGCqHKmx+OJYO7n +WtBQbNbJtqQAniZ2KdgKJ2tgWP3gYQ2iH/82U1kFiEYEEBECAAYFAk7HdOsACgkQ +py/2bEK9ZF1EiACgi+VMdUwslSX7DKfZ8pVRVTAH8BIAn2o6AKh/4OPO/WNBuJTG +Jgw6C5AviEYEEBECAAYFAlROsrMACgkQZKmaggEEWTOqXACggN3kAlzLoI9YexDQ +LiaPU2yvB6gAn2shedpMHsZajwVl6ZVB2m59BT0RiEYEEBEIAAYFAktdSnUACgkQ +BjK2hooEmyEUfACghdeotVSWyGKBnhBgfVdsZcAMzT0AoKYVlksQOcNUx6aZ5S4I +BFGyEfLhiEYEEBEIAAYFAkxJFKgACgkQipBneRiAKDwDOgCgpFlATSJjmQfKD/ZD +zDBemLRXkDoAoLjJwgB4sHZeI/A3WvoGmSrowDf5iEYEEBEIAAYFAkzu0bgACgkQ +t6wuUb1BcUtC2ACdGg2TiqMQtHFPaenZ1LfLIhm/IrIAnRVkpPeVvEwqzyvKe+a9 +Bfc5gmWCiEYEEBEIAAYFAk7ETEoACgkQx2zlrBLK36XQYACeJASflOfAQ+rY3n8B +J+lutJfkM04AnREgobmDIziYEnjgnKnbuAi5HSpDiEYEEBEIAAYFAlKGNfYACgkQ +9t0zAhD6TNGivQCgh3F8Ov+Rv0V+zpJ/3pSTAE0dd7gAnj8OOtiXelVSAKkVC6m/ +iy6SCqXhiEYEEBEKAAYFAktXy/sACgkQ/AZAiGayWENGqACfZzHLRCWZnDpZNper +RPji7JqoJo0AniYmMw9m0szCGd0UDAwjTh+WRC54iEYEEhECAAYFAktXXlMACgkQ +u7W0U8VsXYItwwCgvUtYj3XeQoh8NnKEBwsueTzGiVYAoKQKEXPUi7jlLvNoRTfK +MOq2MLdziNwEEAECAAYFAktWmRgACgkQwqNdSiQ6EylUtAX/fYQTuFAHuWZiUgFd +Sz1MZ3+yz4pGmcyhEnRdH5qfLhAjkRFkv4IflTzD4OLkjhWyr+GTGvxzps1WP/zs +k1JRuouZ1DT1fHliZydxc5k/wzZiUDOmjoOt2r2bsmmgG5mCHz31SOoJdn1qC7V1 +iSUKRl5yUtkK0ypVzdUhTKDJjvxM8xvrp/dBZ6aTg37CWIF+pWQCoUu0XLOO8t8g +gLNBtYxwFCkahMqDD4ydRo7RUJe0E575HMzaagJHll//c8IYiQEcBBABAgAGBQJN +RO2VAAoJEBdtaL3wGtIo+awIALxdG/qnRlqU38Oa4oQbhw088+5y9eXKRXmao1l7 +Ead92LUISe1H+w1Z5e4iTA7vizDISz6HdZxxt0TPyjmnt3w6HyGtFBL1UVtnbM1V +i4gj1XOBJj1WzrlNBkEhg+/B9meAuqpuguF2zdaMpfc6AX5AsI5f+6ngVnMwli+k +IpYcR+GuzCZiGzoJ7x5YOhPTx/tZU0Vw7QNIXe6xST7qv0lg5CTruFAXxrdlyynz +Cj3eOakIvbxRlwe5M8+Zj5aa5NSVQG2aKsDARdTV+maitfjjrSEXzMKJbxU086iq +QeofOhyfKfXtaLyc+8pMI6+3cABdgzUYlg2GSGE55jvnfOCJARwEEAECAAYFAlCD +LAMACgkQNdZyc/n1A3BPKQf/YpYUOfYng9TwhpJ3XkS4jgAdDeMSzcyBVgEG1zg1 +JNoa6hCdokLgdr3fFPXi+ysQC6rVaa/atH+YZG3eDfXZXFHqK5fI2YNXUfVA6rkz +2Wxq15+5AXSlTeOVZ9BHv/eQuUZWMm3LA2rqORC+FWb+OTRas/UEx6k1ps1uasaz +HQvNIRC7gnHRDArrV1ofMV3hCim+g8vWCdd8qYNM+DOBogjHALUt6ZBTFLRl6LGV +6WI2EnU3dNFr3zUcxH6cSocQtwgiBf1fcA7Ro5HtBzZp0v0BcENe+8AHZm97BLZn +VbSESpsb1L5gQEvE0pnoCeXNinuozGQudV1xuutKPDwuU4kBHAQQAQIABgUCUokG +TgAKCRBJM9q0AO9d+xVGB/9KT5czhTi8UsH/PwQtG4QsLJUn29354hof+TAAO3Hw +WnL1o+2CFN+qPr2CeyG3cP3YrUtcrLelUjj0YgbOjH+M/PaaXUy2WJ6JT6MTwXvp +zGBwAJVZY/bkos/nyTkM0/A7tBPeaOsbZbsFY7muOq8tO8OscqHJA7OQcOJ/xI/F +pwHHKmSPRGbrSP78DBAhKYTy3UixY6HDOV2vwJNlz9cCBUTPoclGZxxFQKErGkUn +moqG/tsI8CApeTc7yUSEF6Lvs/sq6K37YzeF0es0iP+uAJXe933hU73sMOYpCUI5 +MtPtTzNdxvI+dybIjkJJhB24ny3LpGnvBc/xxgru/OatiQEiBBMBCgAMBQJUTFkw +BYMHhh+AAAoJEOEbfgtS8GruSxMIAIcdoNyde5XP1CK9wOuLyaoLU42ejpdDWgSV +2SyC5cFSrobphafx4z7407eD8I35Wo0Rhxr/ktTapnyvark3qbLelRvbL/BPxfo3 +GlMQTMUIU8vIC+d60YigwemJMS7qfZAiALkZGgK2Vr+uDwkfX2XWb+vquyA5PRZO +QWmDQ+1AFTKnEDyEMCijmAJHRnFY7wql2GqlMOizDaDE49S5nEgZBJD+vXrTSF8s +YJgI3fD+0PfKs2PKNnX/eGmqfWeG/Sn6rLPp+kM4MFNB2l1OpxH8aM2sgd7IIYd5 +a3B+PpUFmsbBknMF9uzZaOSrqQrtL3KLCNDDiN6dMaDwV7ZLBnKJAhwEEAECAAYF +AkrkusMACgkQfmUo2nUvG+FMjA//feyvRD0zjnDycJJvcgK8FLowTRTgg6CEDgYX +fE9UMniA5DY5Zlt+MoA8oJXFFTUmFdBMkNwj/AyQ77RYCT3k6kcwF6keJ3QSolQi +FdteGQCsTdk4stzl4gZ2WSxpKwBAuDQ5VYlJqQRZvDU7/BGjjeEp6NK35YbzlQqR +vq9fv0PeMY+8Z1/s4r6sjr7YonVS+ZqQvSZCntU/Kw5lc3fNYo2KqwfdpZ0+S9+x +SVm87mu33l5UiTqn9GyulrYGd/hx+zLai8y/z9ebcgoWrmNd8LZVbnGipfIAclBP +Q0BK9S131NrOGYm2coXdvye+opudLI5oGdG9VSHYI3voeID6nxmTFWZchXxElZ/P +cwxfS1F3acpAWZ5pLDu/3ZF+b8+AME0+K9Fmu59UHUihCDtEh2Pa/gw9jXqZQ1Mz +dvNrIVS69wYPrYe264fC7cIU5efNda6AJdgPUOZSv+gFonoXr+hGBCRY8e08C5uL +LB7pK8aN6b3xDI41JMLc3czxwN40BLnAGaChCdOc65D+GlkNpfMh4nq1faA1OFAw +jhaJT42BQMuifsHggUzg31GfidEpCBjrf+syQAaAhmWT/S4I74/V/TdIbXognCwo +qP+e3oN4Zp5+SFrjdQKDk236RglZ9ru3ZZYD5c+1A/zsL4kVbhBWAsUlaaHO2bLa +84CXq5yJAhwEEAECAAYFAkrwm/kACgkQfmUo2nUvG+FyeA//fNpoOk0iK016ecFT +zxCUhuGVLoUsnuaMUxiL9gFd1q30ATBJ00Wrfq7g8fO0PMfKVURuWknKOt4sesRq +2lWashd/xrEq43dkRq9wlMzQkfsu58LPlLRZtdQfhBtXTMton+w4QpnqRkHl2ry+ +3g4d5iqpE+S5wEHbD6fpe3NSnHNS1vi8YrwyDsT4N7g1f5aj8TUefkSgJiy041Zu +6RcjF5qCAhbDU7SFRBQcOKAfkW3WncsI4Kr07nxF5LkU1xzXiCtQcef3I/MNvb0S +07NFn6cKF2fayWhwmPuh704rYIgrZ61VC+zqccOKrZsXvUuDxF6xkIYrI2EkuT2V +sbaXq53hq3VOPaFUjJ4liorZuAZH4xxclbH7b/ycVsa6uvZls2RqKqON3yGlI5aN +AZbyMF1GNO3wq+8z0SoMKSAecGlVgvhSjCPYdOctEUeFLP92rX65+Ng7RTYvS4F0 +TRTzi+H78pSB80ECgoAJXraWJJg8kc9rB3ty1yZP+4rmgEfZMb4VXve61WEJ9L2l +7x6NGo3AE/RPTCFQwQiYImVs6bF4TzZwSKDpbZzrMmLjkNeiZOf3ENbsWECmWH16 +fzT8FWSGMuYS7uZ5SIi5SyTyQE6m5gT6jvbMouJRfNSU99LUIclaAeYfWXgoOZM5 +WNZ7EFTvY07hJLoJVmGrJxgIJpmJAhwEEAECAAYFAktWn5YACgkQIZ9rYLK7/Py/ +9A//e/YQcrfQy2Pfo2LkW70o0UPrjfzV/4YoCYIryQTUAxOUZsL0JlIfBbUIrOxF +tMAVIJh88CUGVOylFALCeJHWJQAjKCeV9vu21zPuf0pOOy1USXNf0raHp/ydt+fZ +SjNe0D6p3Q66Vsf8r08EMvXUV7EIS0n2FUkCHpbzOrMNTv6l7hB4LkawAMTzrT1L +bAjO0M66dXj9coO+gk4ckd0dXNU/xHTpYIIH8seNpZn7M/Bhbp1B4V4/Udlhhg7V +dadNpochQ3pyBx70TIZ9hShiXcWRWKXyRJGKHztRgC641AyLezlUPGgKPPH5of2Y +VC29Mgb/GjHkZPMfSG2hmioiXSgv8GZaT8++W8MvEZjAEpOxEvBtjHZQJ+kiPi04 +m5RD+NBi3bJs7zvXvtBAwyweq4/vdkiC8yDRRNLX15XfHWf+n2xyB+IioVjQ2Fgw +zha3bgyNZbqFMVW1o8LopFVK9oZ0Z7ScveAZX+UtI1FtqkFN6W/6MtKPDmmLDdzA +cCl4Rfxjwq/KEOS4c91RTBp+NT8KyY6XbRrCmACbOdFIxipUA4AGmJKu3gDKNuod +H6Yr4t0YIAavFg7gqOhAnbjvggCrdBfDKfIIU5cJ6bPyXzuP6Zy7C+MPre/ehiWB +rGe9q/r5zemmzgKce8emH752a+rDje71r5M1gi027Tb6XCOJAhwEEAECAAYFAktX +67gACgkQ8jcjNv7Dl0XCRg//V3AfUr8nPy9A/nR3kzwCSSqBiwCujYvPVp8nkH4l +nzRV5S9mIpVqOt+XyHa0NqMWKm6rQe117mBVru2O+HWj8WPOeUKnpprDo8m4cTfK +Og4ahZdbwWidZ07TR5ST55wHaZaUF9XppaCk42dMUWwt84cKaPDUF6gdchV3qgQ8 +HQ3q+D76nbOyxwiTx8vdoulU1Q7EUlAXpw/7soeb4XfkNaJeerYw1fOay4g29jiw +U6ylTM6E1kdOEq+K6hUwe2lTGR0jFrBWIk8yO9cX0YhrbHNpCYB/FDbE9cOBu8sZ +99NKzihg8hH6fs/KSzbrDE1gHFTgN6pXC1Tj7vPFtnzeBd65TxsRqqeS6eaJzzJf +i4fG3o5jtjKVNOBa7ERULRy3U1BIWFRafkJkQIVS5iSaM3BMBS2hTNcvitJqlRVr +TdquTDg1QZ7DxUh3qdgjFnlzCMcwrikg89flwQQyVwlqabAZHMfe6Rvz8C9+2UiD +oyNOPZC9DWi9KWCMJB0lMsvPDEV0MPXQ7dX0gZF/frI6j6jNoinh8ZNEOmgF3fl/ +C+tma/Ovs6xI9fCV+ytttLTUXYwLsSDJit8JPjEtIETgQcOBpGWItdsrjRKUwLJQ +zhVXFsdnskptKAQGZwbls/t24OTHtN9CDeSCmGYpdvHWnKeOlG+TmnRD/0UZWI1U +ipSJAhwEEAECAAYFAktl4eUACgkQihEbXK5CaUQQVxAAt82+u8YoHzK+anz+rnF4 +kYxJ/eh6GKHD3utK4TbrATskV0jRKy8/7Ynk5QNMfWbbOyO34Q6rgL5J14QTX+v2 +2Y39d7w6gK0qrhRRgXwbiGw6KZPe/cRnkSZL4JmV4XTYEJ+bMGVBknfpVv9W+38o +p/vgvh/X0xdT0CNTFd3fX3rNltmjAte3pDw1XM5Jzu+4+4SiLArFweY8F93LNuZw +0PMhOGTkatjwmJOHtje0IlYpbHHhBLr9jipD8J0WPkNuJ7/u5LA6kXL94tcL4CQU +X18i5VfDl4YT/tDWcN5BJplx2TE8avQfSDeWthytBoXlatH2nLS8a9qEeJwRpMZA +rCMIohB4Ex//dL959axXXTFPbRM9ztI3BD5UvPMLjmbTPjVi6q+1U2q6j2N97DHP +h2Bvitfjy0FDHRwIW6sdF1RHFg/DsqsRZj2x7iFe6FVbFRk27dLIFAJQ/EYaVUpO +hTE7VKOFUupV789AfVWTO7Emb8oHm49El1Y7XTzfZp8by70IWxg15i8or9J5rVzE +QnpJCaauKY4x4WaBfEfNTycnThofIIMjmNamdBk6IQEiMinjYUQAN617jQHt7wIU ++VLXkVdF//Qz3HJmGB6jREr+F1ilTunNWPQgUYFSB65ep3P4iaPYhMdQk4086got +clmQFAXsq8J69p7gnjBG23+JAhwEEAECAAYFAktukaAACgkQMfsebhJZ8o/oNw// +edveSI0SB/t8z1Nam3W7j5HG1SQndBtMcDNo7z7ztzlLayDoLinoz7Ilqog+E7NE +1yobPc/65rEb6/V9xwn6gdcUPCgyD89zy6tNR6sSG1HeVgpW8ZPZAYXzFkh9kn04 +4Bk1IgD8qE+TF1Fgjtut+DDtQu+Hey1aS60TtLkQsM8FsG1OpNeODxdwVFqfTSiE +XPdVHWZ5EIotSQ5F5erh6lP1tKi2vfoZVjEID+LePmEALl1D4ClRF38bYe3htgPQ +FJH69OcCVFL8KfMccqj0CmGSElesTWhdyn2FtjnORyWVjzCC6GaYOc3HEyahFIJq +aG/Uw2rOQvITo0l3tJwvnr+DqkRdqDnpSKw+8xeYkjru7Uqgqp3L2Yzk+nbh4cFT +uMnAKDc0drhztkJXPakpzM3p2MM3jz5p2Q4XzGD/ojMg9TxbsknuQv+9tQ2p053F +zvHtNXwWeQQMI+pBd7pw/OfJy3wJ6MRWaWyGmuupmz/sIfBnmFmkeVGxrefEnqJc +zAM2CaOR2zmBh4CBd88nfBgU61+0uFSo227a7P51TWOe0EyNWXKFeNQkfFHiPgHq +dMjPJe7tam/m4/E8X6KvgzWgTzOhKtXf1RghSr2hdKOYB4WkZ4w20F8z74HvvGz6 +yFakq4LM3QvTsuStb6k44N1GOW8gtnrjbd6xXXLeNheJAhwEEAECAAYFAkt7kVoA +CgkQKK0yshjMuP7mvBAAvgYNohMB1vT6OL4oS3tSQgtm/4NhkYUUsLmcyVyw1jjn ++G2RRJTWTtaly+REPwZJ91aT2pDKgiUeS77hgI6KMVlHKcisXl2cDyuyX1oxrpCO +SvRVEV6GlthQjxV3UOa9oAR1SF/3oLleHdV/YpNPRRmrdz1vFka8Aj/t1N0d+0Yz +WyruUvrDPrfbDUketHFdteXZFcHd94vB4rBAOf7fEz85K4CnQKZEg50UWKu2r1Ew +2e97OQ3mSdUKHA32wcabF5gslQJJXB8UuMlsXm7kFBSs3NcqjsQwbZ03HL+IzyhA +/P/wwJGRI4DGiv56Ra/BTrIA7Cs7B9U7CUlmhlQ7h0UeHYjtZWWlwzec0CnCNv0B +94/m0UzLzW/ZNjte3A2tZ5akjfHfC4dBX7DK/9P1kQmF6XQ9GI6hHmut6Pcu6MGc +cqzJnLhdB/VJBorUNclmi8OLzgw7ckGhGS4BaAooPQjVssm3cG+xGqEzeB9bezEl +LaPeK7v7JUgq7ABdthvaOzG7DuNtdEsTQjkSVHn6ii7r8je9zok67/ILjGX7PXov +E6KUckKoO3cDKwMuPnDwktXGB12jQ+A3VPpOx/s30a/4Pkp3TEyAMGbyqPxSY6TM +agmA9DWq7jDLcZOy40v8HwkpoBy2iCJxGlMMH8LxCYkV0VidfWEEiZi9aIjKKIWJ +AhwEEAECAAYFAlCDKAQACgkQe1hbMIB8KocWkA//b4UQQovkmxricdBqlX86QkFm +gdqW1t9ZHx6NFs0+muwIB/v2+eCikr2kv6Pcublywey1PGBs8ecQHMtzdwxr5qyz +dydp6XIgtr/y+zOpqSJI4MfUh787I+oESTCkSi9eDaw62OdX+gCCYCFdtAz2iaqe +xI38X2qI9z092s5HY/9kAZr1Raalu/23hSGlwWA7SetokJGZcgr5syYt9igDy+oG +3t0BbKUibUC/m/IIwHl8/9HxvkPSaTJikaiyOhhkFrdqmafolC3iVu4CdYmJjs/C +nCKgvmVD4aytfANuucX6dfOiCHc2awbr+j+3La0YKV6FvQI2hi4YZiIrIpVObfFA +YEy3yxkxHUR3itdNW7lbBYgXrYWevdf+mhRfR27hZOLEFfLVwlPYtwLF1/rTDzfD +FEunZPjqxJOwT1Hnywln4Skve6OVTeGsWdYeBP8eqG3N7qp1CP2njBGkGKYkJNvE +IlQV5FXGHS3Wf7f7NcLgGK75CdyOOZlHeWXRr79eEZJghdgD89lvvP0rozPPY/IY +8cOQ4SdtEBgA10i9dH66VTLtDbwSkyxL7pNbL80vTCWyGBYBpPzaJDG67CSvVSnK +ioCac9LrHO0YIG6MOyHl3eN/VFskptCC2qUzisiFqvgGQqw0d94sUVAY6yXXb8oO +XikF3yfv+AY7LD3fKUGJAhwEEAECAAYFAlCDKOcACgkQ1wD6SBOyhtnw0hAAoRIS +QgU1hJda++WPiMcLLpsggvktEoo1lBUddHVpkXR8bdEOOSP3gHb5ArP85/wsVSGJ +0NMcFWRqU+oNb+6msYXadFIUKUkO2v31k8MhmCePcgsDQQUUQNFa9laFNPmi7/o1 +63DPdfrMS5bD1BXZgUccblMbr57pRPWyzSo3ufjGgnYIoqZEnjpfx3ARJNxWHQIq +bZR+HtIta7yVzthLbjVWoXX6FeOJlxARWdki4SWWTPqCOSIXsrnSD1n1K96PSXPk +Ga9PoTJ7el4tkEFFJqvaH45WwuGjK497/yZy5GMRfXWTAJeMOJ+PDavd4JeJdkDD +anOwAnpFVJKbn9Q2y2VlE2gHm00UJjM1O6EH6jGESxqmYMYQz/VKm3I2cP0BNkpe +XSzY5HEaEpv5OBR96FHjgvSVmFD+w70qym3k4FcAsG8Qs84BpMyX1h8v8cns5PZs +GUbDGeq5Tmo5Y5bNmjl08tMeBOwO636/gGby6XTFL/fShqFSK96bUZgwGQvf2F1n ++BueaWwzdZBSJA7igmHZVH04uEDjRlqD3VOCKgfqE6hfkGsAI4LIcm94y2UOgdYt +aCR5wBThLb8NJ9uyn/sdRtlmOHiT6lWnMD+NcANBc97N/VvaUbFAK4N5rY5kH9B7 +rrZpWqc4/TnhCJJ8INlH1xqNYzowvjKuburDgbuJAhwEEAECAAYFAlCDR3UACgkQ +n4j7Uvr3s5OGRRAAipdTLPSt774FT9/6i2mMDNWfzxQNuSs0lIbRpEtPZI5F9qr7 +uQ7xp3sH3g2Pbj5ihKRqSDW0KUA5mx63YcN57D6owNQNdcvqrJAwWO88mQw6HURK +KzrIFD7fISacS8Hxq5hSjvZT+AiZXUNLSMQirX0qUvXWMykU/bW4V4yzHshvYzDb +YL4zAxK0KCnFn3+vmPlKevBoQaDe/m87Mp/bZGInl1e9mONA/5tpXcf2R/HmIbIV +CiMEK5ziWTGHD8Roier/osaer8SNNBqZKVfobTtMd6XdPu5TXwmZ46dBuiJGazan +GYoAIZdJhzaj56aqyhUUp2DrCnFcb+S428tZcICIwm1qNeenmHJjKZgzdXHMeQ16 +8HFPJG8BSYoGm8ShL5eYdbqsGL6jTV/3FHtiKrtJdl3HhvFUDiuE9JfM1Ia3UZbK +kZ9hYz5eZVTYjhBOd1BB1RaDd6mVSrdlbrMRbZz1h+gU92s/GiE1Ava19J2u75Xp +nmHccZPa9O0eDfkl+20DqBGRNfkiRdvJS9VwPUNtbX34f+mwzUkJBr2d4g0et1Ie +zGtz5tRXkOH/S7FjZyOQ7ceIfEraJJjzfuVj12V+dg2K7hhw9L6zB+Ayjk8dty2+ +9KSTf2cMgD6e5QZz/UvpO4nHl1z6GZ0RWrevGoKsVGfVJG75sRT4kDylYqiJAhwE +EAECAAYFAlCanzwACgkQWWajClP+gjBC+A/9FAUG0DpwmsfLKmAog+YKuGQZbmdP +ndCuNhigKCuBI7gLDojkIs2Ch+Wsfci09jQTJ1r0u2JbcTfk71vlOxZ+hROBqFLz +mMi68oEPJd5FD4k3gcsoqY4AMKY4K0i9/EbdM+VM/nxKscz79iZG+y3uQBd+PHwm +tTNt2AFSy7Sa6ycrottNBjcVX3rI4hUUnuq+ADfghrfODiRDeKUXjtgp35zje6bA +hzGbV8hYk9eCET9Wek5w76nRQaonbv+dLdEY0S9gAeqoLy+oqD0Ki6SKlXL6lcCb +AQJhmeUpcGFnfb7vLgApaDPNYEb3fzRuafGBniSOQ/L1JpSlBTHsaL2Jw1g8jI3C ++diJtZ/U/AS3xeM0mgOQ0b0Mcp8wXxSokNHXa6mko11XcEndp/aJq0WRnsDiuzNO +vxoZRNQTfE2RM67eF0M6OhnccRR8HClMVCRi2kRHgavaKIekTihWAHj6/hqvvuwz +zmmLbXYF18MMnUosg0rM4N6M+ot2k54FB7tNo3psrMjx2i8cU99qdvFCxmVkm8zq +0MrwtgImc30+h1as5ovtPZCXt2978wJBXGlIA3SK7mce4nUMB2Msn8JD9Otl1mXc +pdlpcJaiP3sX5j4btA6dgIHwInDn1GZROoQ9ziTPIg37FcWDBsxpUApUggQJM8vf +RkH1F7mLqysVf8mJAhwEEAECAAYFAlHsNd8ACgkQ+4YyUahvnkecUhAAh8ucthAJ +GlNRVynolv22kHTEYnbOyeX77J2DzwI7VneXomUXgjqtSi2IfRMady0QTQt8/E10 +KcPg4Pr6+jv6vo78re5LMzyDpq8zc5z6osNNMMy5D+GqZX+Vux/3ehL4bTt86p5V +C7gvPcFR7tlBiK0mfyiFRBDI9uXyGvTyWD4dtYwJLJFW6cOf+45oRM5jsOdRtXno +rQ3j89dgKyDfqjaieQ3fyRmCrxfnVHVLNTqc64sd6LAHdUw7QQoObjLv/iKL6n4K +N7AKdfIgOoBQYe+KznN7OHD8k+SLWCG3pjcLV0p1sKY/xV6TIgCxqiXVpMgRvu/L +D2PyWOUNbBRMjQ1an11C47lj5ulv8KKxxcWZc/MMOX7cvcDd9qGbvFXBfvbES0XD +SnWNTJkqaRjc33b07nTNpJjGCYksCf3VMst8aHJ04XlbCMUffdisKNWefvm5pFi2 +XnD//fivUMBevBZxRjA++RMD2p4mo5SE08PEhkF0MaKRyxjt5vT0RCg4VCGpOsT7 +fGbrVwChvL0MYv6r5p9CuhwDoOEKY9zwMqgt3U5n2h9+/tsIqeBjvnyLvT2h2b+x +0Qe0+YL7LZGLzvET7C6NVnDB3a4feF3gyVcRafMpeFlpnFGturv018TMoSWX838k +E2uCN2md3B+cn0rnvKTxHe6v/4swGksEgBqJAhwEEAECAAYFAlKKiqsACgkQ2O7X +88g7+pobshAAm81O9IXSH+iGJaOt3VJXkYPv27y4ET2blNCPyKft/1zPfSr6Nisg +TL9/yGjLbP8/9EMOZq85d+raDS8juHtlAo034iVs7PLv1wAJIoh9qV/Ysn2vXuK2 +PGDBnDOASOq82G3QXNgIASZvoH1Q+ElNSlr4MJ6eqUZsUTi9tLLx0X8NnGQ+V3fa +GqOQjXnIXU4WipwyE3OplQ0edh++pwukNryWQRgnkrmmlTM7wc5u3CXdkr6eNGP0 +4HAFFjwO1ytXsPACWZ43S3sLNXFjxgiJ9tGyVwz8xzu/oIazOX+d6Xu6kDR0GiVt +zXv5kWN/CSBPAvsAipJihgMVITcNrqy0r701jMsVfQcENRxbpAuqRflbeVKB95gP +RTp3TTWyv1tXL0+P72CuAqnVLL4vGAax89Q3swGdi2FVGeKGuR8PAosfR3/ppdmc +zdG959l4tay5QlaOqxTAGgGBO0QG11VrzVRjxzQdLTeiXE6gIsCCnAU+J6lzd/vY +/wAT5oFytnagQcB7W344oblW6kKnWVOj5/4Kwzk2M+x4FJqUBxI4MzXh3paMXZJY +bFlBgbKonViGmOsOMYFiax7t0H/P//fEj+QQyp8JGfDVBrp1uMFlH8eDtVgS03dn +VLqbPThz56GBc1UxtpFLBSd1ccI4Qu+VdLN4K8eE6SwatKCLWMQLWYSJAhwEEAEC +AAYFAlRMhH8ACgkQ62qlNODAZRxmIw//UHxg4LbCgCAVI5vWGjZ9RQ1+M40gvcYV +fUyiZw4o43Q9XdujrVVOhpe/rc3FKe2NpcBllbxKJQBG+UWhjq+QQErDa2uHWjgo +g36yjdKY9y/XRbauvIsKPbKkieUyBL8BI4Si9aZeJtGCrJUxZpkvX0zt2RmK6YFo +k7vO6cd6AcHMjVt4BiPVj29QnOdbQHf89cdkLqs0Ebo2IQSf1rKVj8K8qcZqV4E5 +q6cHUiqTvxFqNaJuACpqQ2mS1wYAJWngRyI+Hy7chs5paehw6If6vvPHTjnwCnzQ +70SLGRLk+b/s2orZtROAzFpnhxGpE4ctabIFoh3NtwBVxL2y7PBQbYg1pzQUL8pe +PNHuXCd8s5wYReZ7eIPg9x09yYvD0U2YAAN9GWuDWP6bELuHzQrfvm0FInhfKBYe +Qa9ffcqX74EGrnsB0bo8nz+r4hhTsH0iVrHgJgrySubQ4CAK3MHSmZiwv49sN5ya +wydm7+ZKA8EZS5lFFZ6ElaZh36vTcQn9JBKwjz5EqCTIV3MnDVbPHnOI8yII9yZx +fmDgmpEfwUSyw7xUlv4okCsSzvW41P1oorYBo/CDZBKshrz4eh+WxAUFuFkVXOf7 +nu3JGGlLT0ev5PK5VA8+3/Xm7K8kJAltsDj9kUDOqbGEuC5+qwOHJYfmFj6x5mdM +mjDiDCG3RlSJAhwEEAEIAAYFAkrkursACgkQ8aab5CnA/+6SMQ/+OtfKTclUG/98 +i4ye+lheIUiDYsrH6TzZ7ga3AUsjpKXKva/i0PkZHox8uTTnS3xWhxjBUL2L8yoV +88Ww/GhVshlPYDHUN61dKwl8De2DamvqYG4VnoFzNLWdixnmtWU+PfyJdVzqrzJC +Wlp4SmHiN7J1gmvWzXNsrkKz8pQLpIll28z91JnGE2jr6kSc/1yOTBTVPKjVhEUC +kIHYlY3jf3MD2vwomNKji4Xhqz8Z9Ay4uP0E8VW6qzqsr5vUswPjtO7QvJgxGpXU +g9u139WTNvxDHQ10NtfQz3Xo5QitiXkx7zgiv5RzxQGg4kXeXonYvXJoMRWGOlES +9JWmrQqbLEXJj5mf4iUUErvtlbruzZCj3ScRXzu65HvTCHHXhRlBKqWzWfIw4t61 +CEx8D4EStRplhXWGEsNmZYIvu4V6nrMBy4Ntb+tkcEwgzjEPw3GoRFjZ+M7uesxn +CHvU10HjQV6GkZl7smja6zTbENxoqdYFfVZHBUN8idiyOBwTVp1rmYqF1O+5UUyH +P1AJtsoPhZY3VfMnVQQMbgoWuTedWK4T619/tvgwdrsj0XzjGTKAvoLSxG8ROD6a +TWJbu+Otqz3LRD8tpPvGoRk2r3kheYlmJ082ZQrvLUVwnN2H/E01Z7yVi7szxvHo +96rmqr2wb1x5vr4JLk5NYld6VSgicMGJAhwEEAEIAAYFAktcHSgACgkQFigfLgB8 +mNGBig//fpUHJwqKVjTAxdeGGMjKJaUL0eIFrpW8hiRRLYALVVGH4DiZfudbzWy+ +jlgpalfnPjzGN49fpuYj+MQUQ4tlmARHjelLmkCi6YcBWE3KBPVwAOvEvwnCF4k2 +OIf4ap1asLmeKbi+ooyL8fYh5LdVcPJVtQqV2nNzshbjQpQLKR7tF8DBnWeJU9j9 +4bdbDyDur9sPChhcRkyQZrorHDyTkegykKOLiyiNyyvk6MGUc6KqUZF0eMk451m4 +KRgMO6tn9so66XDh37eNMo5hXjgo4HZf/mqQE2GOhtI3IgYla6MZ5kUhJjGx7hYS +lAhkbC5IQocTmZ/H72EWPMG9MtG8bxLCT/+dYel0YXQx4AfV220tS6xGELtx+4kX +OwWWE4QN7/u7loFoVD1fvxvvNuwcsWnfFTdpbGx+ISs4O541bc14qAhSD+XJsk1P +f3IZcNWvwELH5XODV0KFri0dVg+C91+yxe9YWQfkuTrbeOKfbjHGg4h/wKp2Nb9t +o3O+g+jBk5eSbCGYqll2YpFHTm1MXtdg1+ahYKiduS9aD6VN7W56cLqgg/fX9oGa +13/qWWLIwG8TaR+tGrHbqZXkgxQs4dA0Vies4LwbsR02dzCfDM1a0wndOP3lOR3G +Lnv6WNRKEw6rdYA29YriWMLQwK4NJD2sjl/yitJnfiUMOziVCHKJAhwEEAEIAAYF +AktdSncACgkQUK5whca99vCCZBAAtx4PMsq4QVYV41IctCBwbvn+C8jYPCfMos+L +vZoFsZG/XgMtE/WgBJmS2x+Ggs621Go7C+JZ1drckn1S3jkZKZrYQtAv2m6n0l5x +kyY8fYwLdbLGKuQ7pljQQ1P1AoKsQ4urVdZbBHdZ8DxM9h6hVd0gGlzo1ajM+N6t +Y2xuJNYFPlgXWhqEtvCqEA4VTm/gdoCIgTGYsvFFOAC1QImNtltVSobd9hGHcIsT +y0own/E2mD0Rmv0pd3Z3n8ivIYpGVWC6LKvxwtwO/JBfyDpdh7ToJ4BuJD07LmER +zLkZq6QdWngQnn8ofaDZXuW1xkAIXwfnpSCXn04d0YV0Cvl/MuyWSIDd6rvgPREU +P6i1tWrX9xe9z8l6KLfImy2Cfy0OwCJglayf9tENfgox97XTKLlVveeKd81JrnCJ +CqvU2DzFBTmYF3FluogGbB03rZqmKesmpt83gpBncrxIPFsJZZNFo4fzlvewtbWg +ayrqggfKSCoI7D1Ze+uoWINJVvr7WLnTra3s0XgpNaHIcryLxRGcvNCy2bOR0Yad +6Qx1ndO9sI/Y7TJczN8I32UhUJUdk/q5O9e5kFDvMqFhk6k0NJVuU+P2RDjbbdP6 +xg0874vaul67tRFITUFHYBx7iHgXE4AKBIFEEWSxIvzDHongFp2t51qAAnCOrjZB +GGJFV7iJAhwEEAEIAAYFAku+k4sACgkQ/kh3c1hskhro3RAAqruCPA5uTa40imJt +taygo9+e8dABcpOyYmnb5rxzDcBkybWGfT+CUdTUvPXfHQfDMBIeJW6a2JmvHiu8 +8NflIFLR91XTYh0Y21NwVfhDcGRhd3BB3Bi8QOtvb9LotK6UKehBu4lKgjZbdmB8 ++P5BaWPwQTD1dStf/MpYJuTikgAZwbtzksozyqhub/fzaCQ2H9rH0ZaQKH+8Ctzw +TNH5y34QMW5KVrCfitGlEg+KUFL9/iO+kBKhDOusmgNwYiM+0ru5coATWmQZ8AQy +0YArT5J7F9UZZW6JJcGHUSGxXAa1yZjIZ0mwQfxSV/+DszvxikISZTuYrt8F1mwr +XPGPeXoGLUWOeZEP0O8m73yMgkpsiw+TIseUo2ijN/4E1gwwMS3bs/IHPKn1x9g4 +/PUSW9NJmV8XTjLBVKVSUJVF1WtZgD0BoGgcWDwzh4Y0eYnveZmJmOaDG4h3uamN +4TKxGkqGHkO/9NiHYdt4+XckkOFG/i9CU4W7TFr1EayIscSZ5fkZYVb7k+MnEeWy +EpLRgRcGr+Z73/fOmL7GVDaHFQNyja6hzQZsdoWMNVxFs+h7HrtDGUhJ/i8JmFE4 +OXUa2XHL7Jrsb8fuoaQ6+2tJYB/FxfJhhWRddAv06zbrp/AAQeMJ2dVqrjqdxGY8 +DBbREgYyrMAuDA5JYp5emUDnNneJAhwEEAEIAAYFAku+k5IACgkQY/E4EG1Zwchv +kA//eS8FvkpMP+++1JbtQ359C62ysFopa9v7epq2EstZboqoMtd7jXV9OI3HJGpE +7NnVeQgiOKHssld6k17ZyOdSlMXLS2V5iQIy1UDReKDPw8aCbrLxKydFMPU0dOsV +ISr1Ypd101y86YQt2HR0CJ86JnHb+8CnIi28TNL60sQyiz9Yx6mYX7Le4sWDHql1 +fcyHBt3M2CmrR3AxWs265F1JbyrStSU7TwHQ7ZdLAz4IoxBLadnq4YlYPzfg1PQS +uX/5hVtbfNFIqnHjRuDIOBLAYE6rRXk/XGD1z/e3ZaJDHnfT/ncBvsIFpNMQsspX +LSMaSRVZ5rV+dSZD5F8IMJo0b+YMNOpbYuzF3lB9a+MVklqyz/jo+IqrrMogSBgu ++S28ckSlbD/lfBuBe8unf4WwlJaleiieVC9JPCAUyyC4SGMp28UEzQOHOniLqoWF +NwF0/8ekg+LcNUjBx0fvGVuzDi7Np4Zyc0MW5aP7Kxz7RqdDIPqo+8vC3zRpSw1p +z0RkUWlrigiVF5LwELDSgxDXzv6tsXDCwJfwb11PWUKbfvfPeEB6mwuMcIxWiR8h +Pb7+hIO/VxuWoK2k/nfpgH6pq5ofg9Sq4kk0KG0jCCGjALayBN8CrPvyIINrvuvg +Dx/yYczDkSIvph4KapGIB1K3/3XdI2huW1Oy3I1kLdwKvpGJAhwEEAEIAAYFAkw9 +R38ACgkQ61zh116FEfl/6w/+IcWlfEb8qzfgsnKOJv11hEhiXRPOP15aYHwsmBwY +bjrXB3+I4Ocb68BCKGCgDhSdnmGt/zA6dB7qRYkKgCxnLobo+GiCXJ+z5XhxeCDW +9HwmBKkMvPRiAxFEidG+3iX9ban9lvJBVQ/vnThhFi8mD/sBH8RzNMnD3BWxbC6s +ysOMhFnvuzYTRpE1czFB6wL9t8DBP39uX6AFDtGvZRmCn5zTGXRRq26oVbPv1vA5 +u+SHVcfMpvNnrTW1E5w1f0qxb5nYFqSBthacmNDiyEQWZkRinJU23OvySXxbEqnb +rConQfEXGxltagWqZ8hGS5rlkUyoq4JOR8cJEec6lLMObV1dZdghM6ZGbB74Zu3a +I64NkdyyMibtvWliy13GPuLn7yHOHN+14P7JkBZpU4E8xME8/XSxRWr6EAaOH6cj +6OyI7dwxkKmkPQ66tWT1h/AMEw1e4IPbnwLFI4ZEIRVfugcfFrDcnxzMMG/WqP5M +pQfR8NMbEWurtKWArgZGpoe2VEbqykUiB+imRolNfUIH0TUR0Hy+rSg4xrdHzDGu +LvW+DMiRMR72bGkhbpnMlS7tCJ2n7RL3J8cPuGOVZF+19h71dkO7fgCZaahpNQaB +iIffHmG55dn3S1fgsKA5fDWIukZK+oprw5lnbEvNtuVYgV0ojaSFVIWZrS9uEF3K +p7CJAhwEEAEIAAYFAkxJFOIACgkQfFas/pR4l9gm8xAAhRUfl2k0D9Q5oYl0PAuw +eGf9CCqvVauX8PtA5Z2di5QTp6MLMzylvV+yuCcG38fT+37g/g5HBXJRmcuyFYoN +zN9waX1CqFeLGQgNYeh53rog72noMzXu+BgIfVaOlNaVZpMxJEXC/1VKaS+fYVbp +F+vAicMhWPmliz93bmk9jg2iS0frbAq/GSnuReVF9c6FJSRzQ7EE8df8OrelJppT +v9ChalWWQy0Q7f6eFQaPVQBZMAo8sQ2tG6vjmAsaLrW6zLC6LXKDaeclqfxMjOYb +GIltJOaRd70zAotDBUDCn2/YFtmOPJSldjGH5pF5Y43ANP1LpIl/dGSAYGDJrcN3 +dZX/JdoAElio9A7pFe3jOzJgbqrjmwOOm4Ei+VOShZHiJ+mPJBE8/RLQir3es43W +Zi7IKCfohhgAelITA85RPp6GbJfh82bcjVMWgUMrV6XqEYzo+oYbtL/lMXM1vnhG +U1QrBI6IAm/YiWGejAHzEh71ZXI/iJ1fkq+S2LbnQpZ0tkD5sdIgoLLC5/d4jKdQ +KUe7WO/77AdqKdPrYNLvJjpsKBDbHomwPicgMF86Wrl5HmO4oqcII2XCc/j6sDtM +3rCS2Ghau8YxmpRSZgT6kuLvBcw5mpk6smL4mC/ny2A4zfHCNChLzc9of4VP+EQC +ZqL7QNCbOpFUL/oC+Fq3GECJAhwEEAEIAAYFAkzu0bgACgkQuLJMBqwShAVY4hAA +tzJl5zQ/P1h3cxEDwrCLygedEzOuiMQWeWG7OQtsElAbza+mngl+yiD7N9LJnZbc +9otNr8K7XmEZdLWE9vLH4vIMrABehhBxh7XtgvVLQBXhHw3/JTgRMVs8W+L5Ob/a +KqlmFY/DdD9LCoEhObHVE8WFOFCYpOKg+GLrpjfsW1sKnoC8MOwOX6Q55tc4PFpT +A0ES0pEO8Mjp0QOiI7k87cz+7F4aHln3voA6DyQzxQ5BmrMsJapkFJjG2LiF8Lsr +9wXKrtHQBon0uO1SPaMVW/5flafiJSnpz5CiSb6r7XhdA4k30SuIe2Yh+Tttnw+B +Z58U+SiGCfaxI/mQI+6wnQtbFWnHOdWG4fwmSzrQes9HQqJMA1qLU9BnRoSsIqD6 +3ro0Lm6Zs/G7NbdJr92kuGjO4c3pTEgLGG3IFSURVj6TwNMQs5IY6u7Hu532FTXD +kyc1vMFiFSePfnPcGHD2R+gUSODuNU+gcDXXeVC/ahzb9APXPT6CSrXTIDOE+YsI +Bp42NhOxsuR5FiwU1wtmrLE84IFydEwXqwy4wZLE4GAwW9JBYd4SntG7keSI8d3U +kugnKmHkuCz/LwYjd2OixRj3vUYahq5Xog441S+lhlAETxQdcGdNfE+Jd6WBPkyi +ibz6aTuewDI/UWfAHxCqlhHsAPjtZ6uiicXbVVjVPHSJAhwEEAEIAAYFAk5Zr+gA +CgkQ6vz+v4/rjr9hRhAAoXGWBZBiUP2v2JiYEaCF05TiJZ2gDiBA9c7A8PqGzAkW +1TIBzfsMWILdYFZux8zFaVQwygXDWOiulJY95bpt4Vex1hK4ot/EXiHshpr110NI +ktpET37RdBjTDTfjMG1cESjGP3o463WADfY7WPY1GoqnZEh5dwodBkduiY/DdG81 +hfox486kOGViGl5PEtVMJdy5OGvilP8AhQsG61wnzHLGSSNuB9EPP49bVd6S4YCU +04+UV/UTsV2edpjL/Lu7GVFPlkDoyTMz4OK2tQNwXVf8wTdB8EqgdUR+QOsCv8ah +fpBcMwUC1Mkk9vE3fuaewZ2U4UelT0htHApf/PbI0k0+gWyAB/DqFGCJEpn1CyXA +Q2G5D2UGaK67J0dQDij8GLs6yGQ0EBCzN9MNarGcFdYKxxTMIwqQl4g3dePAcLJq +Jb9MIO0MldyZUkY0RirdMl1mUKqw2Gsq3nGYYQ0dZEC90glAUurCfWLNh8fLE1y8 +eg4pfLFzF57iONcRoTBaK9y1O0xQgN018rWMAkj6rMA94cbgKUPmT2JCZ2iFmTTN +AsZYCh6G1mUbbbTkOrWn3hCAAo2mzazGrckEjqhM5m3KTvmRyIGjpkvAeO2N95v5 +042JcXyZOdyZYMO+sZL2526ckDpLkORnNkCk9PsGy7G+72bCT8JPrVjwJa5AgdeJ +AhwEEAEIAAYFAk6tiHkACgkQs0ZPiWqhWUi+sRAAiHTCFeVVpGEMhQzoi9WvJstx +BMdLwwNLKZNwL8QxMbmeX+/BhEKULZXefNKU5ZgylbNSD/adguZx0DZzqj2ncEyx +ZAq7sCAtIJoN9WGZW2LYtTECAi+sOuz4uh1t4Zoj8FyseN4BeLv7U32mLKmywB+K +EoetLpBC8hCu5Bce/jLcZSyVgmwzOY5fVsjrSkaSDy344NHpNL5G4ZNktKZfIbSC +UbQBwdLNQ/6+VIvGdjCe8N4xVy8Q7pvjXL21hHEPKAGdNOlOFKvZxFnn/oFLzxgU +Tymxxt7zKnUopi/9KqXJpxcNU+ccoxh3Os1wvlxCPGKAv/XJBFXw7acv3DvepZcY +iEdsY1ETJS2eUqg5AeXb4ZEq/BpWOvaLY36QO224o10JX0ie1g0C411uelTgYN9v +hsUTCJwZbNL1owSp2aaviYRMl8F4dvUxvaPHrrayUdPXOi8fsNB/nGwrz9Mqc76M +Q4T64jUAO0B+h1lJZM6ILSRLM43HlSMhkZviqSx5Bcro1JUQiuQTFlksyWgacZRc +Om/IvFOJfyOcaerAWwzLDbVGaXzvJfza5omdjbDPJ8gcUl2oC9qZoYDoMJXB5Us0 +gPSTs259LPLpfq82Ktm59xfI5yR7dhWd+FwOxNs9j7DJmEcj3Hg1+7ECfCcLRdAe +PqmV493s1O9MZfoqcqqJAhwEEAEIAAYFAk7ETDIACgkQOTj5a99Q/qUl4Q//ZODt +qv8tTPfPXtv/07FU0xcrlBOAzol61WIiWCUV++dkaF4z6/aFf1rNcX0Kb3Ckx8rt +zUk/rxy2qVzvagMiBYxo8wmKNpyFOUPpszI+6G5ksZhVJMufPm8MfHKn2SyNFWYM +fjafnO/l+yjOghV4rDsrkiG+Fivr3kGV5WZROzuha9mClau4JU+gvuVXEiQGnpg7 +zIf1EWfIQYR7zt6vz0PzpTX2CSVxSAa9b1zQqePH5HW5QfajBJCj6lY3JbuqODrh +3ke4atcOhlMjQiIx1hRm/k+pj/O74D9fE9ntcDCUvCraZAQ0mYP1jbbX2F5YoN52 +kGRMtswbFFmHl7gc55btXVAW8u8/TtAgyBKO/qvBTEskWFAQEW6bE8YGVJk/LMiR +o7EbQxsITuAfKW7VlMtY4J3SSEUt/+PS0XvbmKaElFY8xGtEDk7hGUvp6uLlVcOn +Jh2db1byQRghqClytReTIBoQeqKNasfbnY/Q7/olJrCaE3jm9vbpVcoI5xkNiak0 +q2dS2j1EEWKOJ5otfPTOYv/heuKW2uCzJSAUVZeflEfPn5VwVWC9+NjiNM1rcEGx +T+Mbbp5EZmMcpA835/YSsYiD14bs0D29jadqbvV2MmQE7wCnTxriWm+PT0YAFBL8 +o0Obh5gWutBrcAquPeE3NgeFXHmexgTNBz1iw0mJAhwEEAEIAAYFAlKGNeMACgkQ +OTWH2X2GUAtt+xAAjlSrt4aH+BTb39xIoTR5DdGQytipo2Ohq4iTi9dLhtFgCWvT +82b9abObDaD1kSiYSGsrDowhjF3WzfsGRuICvPOuKnEv4B8vEqIyFbHYAE0kw50N +w0Pj4xYzPxVzvtXNPwXESLfiUIQ8htUxdKEBwjcbCekFTXplp9iFzAWIAQoBM6GL +HZpUn1+nyhogx9gitKrDSBRJ+D6UB6NyiJypvLgJ8wUUtedsPKfiYGUwr6HDWTvt +8SFqLRje5lbWNsyTWMbSC34X6/VFrYZ7QFwrS4lNvW2Syai3hfCjr3ABq/efWqv0 +RTRYMNAmvDGtBRJwwSyUs/tpretDDxofjAasFH7e6494A0ZukoKahn3ynAivNtcN +gicYhOpRyo2NO1PZcT2RcBxHOHWN/cWJF7bEsK1MN/GWPhwja9effRzRr0/u/7i0 +J8JHX0RwfTySyZCsfVU7XNLuxQJJU+5HAvs6EOFYjulVLDotbwzhTH6rCP9RTdut +B1+MRJ1qZ3VgnqFxAVJb+49R5+njvQ0GlwtR/EelWUUKufC0lp8gAIjMcDPB+HsQ +hp83ZtyKubd13nfXHUW/sNhaSHQPZx0QclXXvwPrScbU/OjDixuq5fFza5H5Fwvs +IT9UhW1to687joR9fd8d1Nn7vJmtLKu/MuSYQqQqHZE4dn6magi0gbUnWmqJAhwE +EAEIAAYFAlRuq6YACgkQierc45uA4GmgMA/9HpZgOYnQm2yRQDKWwCT+NSB7PUTM +Pp3qFOEeIAa+BMVjBpLDdyA2e94gvdrNxNmCWCbFpdPJChWXQ2vQLMOA0qTel0gm +01YtUHnTPttmoWO4BRfPDGnzlE/Gtufy5uh8EmpS23O6plRVtULFqK6mKfzFoM6K +pyjXn0hqZ5eulESDUEtzCnRVBfxz6SxZLbrgVDgG5B8opM4dBKteFH2PA0dcNPa7 +j2IA/g/gq+7VKhCerBW1f+xl/9szS4r7Da2KP0CuoW5fTL6CS1NiV/6SL3H1Q6TO +4Cvu1va5bP80lCx9iR8qzKLe1r+AaHl6D6os+gu6RAXMsrVz9UYnySNk6afLvf2G +QfF685Kn4dqnRCMlGkcCG7KiBJ8dMKjEbZ6fzaYcIiOOCvEliue2FdeWLzBXZuAr +eo/muBqgysmlwRHR2c/yRASCEKLkv3zcZ2G3nPAxZx1sfypHDJCWyVxi7XPQkLPI +8lTnFm6Ydi054IREYFeTriOggnfOR5dYBxKLCBRxfr8M5c/MV9fmJtDwuTm6CD2J +RpGklqicFec4q0m0kCH07aA3YWEwSEKLgxw5cEJHJ1M4Pi+Nu0pYAFcKfnpHtmU7 +opJL2eKv8wo9qqSwTLerkTY13itn7wwIYcHfGsqwPCfERzY0GfaEFxCI0wml5Joh ++nLyYfrzfk6PKCmJAhwEEAEKAAYFAktkYdEACgkQjL+aMihhp5C5BxAAkxw0IJIN +dP7/Zeg/Q/khr1+trSPi4kkjp7uKofMTa6uHpEL9gh+8EgJtYtUZWuK0AgLlKk3V ++wiRosX+wugdY1nbWIqW4EENkFiGH/XgKlmHZu+i1EPMdo6BLojKc8i1FXOfmw7m +qkQiTtKmf/R2LrVxYV38YfLvJ10n81OQOoVinQF+GrH+xmpUCRVZlIw5iDueU1ZC +hTBBRbE7nZn3Lj5ETsL/jndyJVGVsykIh4a45H6Cdol93gE7YKSNgnhB4lkIr+g5 +jMKZplsS+RYyUHNUNSnOWtYATebOzv278BxMCdXaWqnnxhuTZuK3khzGTjh1tgCv +oaq459p6yGjMjYAnr9WXmv2Bhq5lzo3+PUpMCBhcu16FilKhFAcnw7E/GXeqBDRg +0aY5jvry6v6fxuf9tiaS1G4rC43tSSDxFRMZNELeBQJPmxmW6htqXPyR7d3SLg+i +x+Y1YlD5lAXu4cCEosUPQLbuf49DG/NCL4etnmw4MSmWNjngF6PyV1iW9oLaiZ4x +7SYrGXegf7prjyxdPP4aRNQwbD9wYWIo62xxUevQy0BA7gqBD/CboGWPX856tqqS +ihGhIAaYti16gmqTHig+Mevy9HsEAVBSMgnoQ6bysrG/CnAVBM8DQwin+StKGVPB +4lgZxyCMh/dpyRWVGAiIQv2FvcToknGcxWmJAhwEEAEKAAYFAk6oDJEACgkQrvbx +oqdFdkVxDRAAhyBGNZn+Dm/xRQ2qFcwIpLqsbcCT8wCCLOVPTCJ3jtKkxfUHYM5l +tT9RYRIluNfHP5WTjs3nmSW4+lGiktFtK2aIRDQNkShtJKinnfJ98hw6vUZeNvMR +xJYD9Um3sFF1IxmxJHeMYbPow4un9KPBe2NgF1/iIgzWR5b2EPGLdGz5cAAYujGK +5uIgi2/3xQUJ9cCcTZJ64ST/1twTqBTBhhVrXe8aZUu5w/bxbXyVhtMp1bswmmvE +0NrqWaR/KKUlx/0GLCXorkHukvgPh2bfOS9RlGMeIJcgH8wVEZs40J6urgP5fcAz +tl+4ov5im4pTxHMhHN5US2zN3ssN7+X0sKK6ZS4RQES0auQaTwTICZybEGJlhkvd +HKkzKGQEQ4f+FhFEWg8Oxk+/UWAwGvOJ/1SFWgLZnbCMJ4qnPkpq3WthIismf3wi +mZjT6quZa8CWq32DcjNPLiblBuoRax150Dh8dtEaauoM/zAC7W5wNwS4wErqyk0Y +Lej40fwiHOqz57JcSQvy8BIBTgeHgdzJ1WvJ2HnIWqJf5Jo6t2z54dObdwpJks2q +aWOZObuyUnqMYal46NeSCRHnujly+jg+GqIOHb6VQEWm6jfRYDV4oe7yB+gLZA3v +cE5G/AcW/hmKKuCzoLdCIK0BpqlMFuemJ49qkamBUrWfj8gekwrBuBOJAhwEEAEK +AAYFAlCDJEQACgkQlzJd2Pn91QZw6RAAoDY8W945juMTgKWuurKe1/XlMoLiQ/Vt ++kvrDQXSOdkQGW3X9GUnJKDea09Io5wPFcP6HhyQQsKRaRrcPqnFpgpwZ1dyZbBV +QDuTcQ/ulQ2lbD5n1vlGzoDb+pnrni19z7e5+w8l/nX6Z4AT5aRnBUl9P5AXF+r9 +UgEUcEkz6iwukeiOysjKEEZuYxdqszbIn0pvZByiGQl3BbHVI4BWDAyrheiWO/Vr +vtMzf4ELr2NZK7qOBy8iDLBtUUiLJD/kmXhCF7clKHeC2UPYdmjil2c2auxw96Xs +10PtsFCWbcLj0+4Qu5TATtzvYWY6PeiAOwiqZHE+ywGUK2dSU+u9TBnY3Ab4vt8i +zb/VckugwVHgVTemYVs3K8MIz2r5C1SvF+tCx1b/yckf8bkYdm9D2BSi68GyEL1k +MYZ/Y5+0yPnUG1/yjsAlWi8cWF1aICCtMuueSnmLVSM3k1CX/wpGHkslj+f7UIf8 +1uIroTrwGoF/U1p8seO0GKb56AwOAwoTGtMRQO+iBp73X+YsGku30mMK3OYcebFx +1KrZvUbDhcp+mQ6/f3rRzj/0HLGg00Rx/DzKqjFWhWaF14YktTgt0TQ3XhZu+ImZ +n4Opp6wS7ZMVcDmK3jkhr5CIZhAwt2SePbIpba1Jydp9pxyrpvY5Di2AIYokVq+I +mT74x7spNTOJAhwEEAEKAAYFAlKJVHgACgkQf3YGpEXcqA400w//Sa/IRg2ptK7R +yf2KqX33ZYHvKpsPPy0PMgU/yjbeVMkaZibqeYWLuTcD9uqhgQ9ZjubG9/CYNM9V +j4faWtLHULjC2t5gyU+D4JrCJzVLHxgCYBsuwfV6B+JgzIOtcbt66gRrZukpg9XZ +XU1KA4o6MMCmGNwloOQmSqIXLn6izrzlDzEgKwocbdYEpg5ruTZnn1fVNp9ZJeGW +hW3jvCCIJVMYPwrdb3tQRZzR1foURlWqgS+q5hiJo+Wmhb9QwdwM36bb2IlY0N6W +np2vNt8GHyYMlbUGqKSPm60KkFbeiqcY0bUze+stXaOWi/uw4nLwtG/R6EU63O2i +u3Nw7RUrZt7NSL0bncMsJ1TM45BeoqYj41BMdmZrTUeOPT6zmgXOs/UCh2gTl7eZ +BAYXhD3EpmaInDkirRJ4J/Dib1zwSTf+xv7+U3rc7YMovWjNvxXzCyBt2BVaX8Oa +3MUKibN4kCmxbE3OakwAr0zgRG8kSs2uxZ/KhSdJvBVxzdAKaVpqxXQNOPpIOXhn ++xr29aXQDJ1h317Zlu6WbfI7IYVJjQwK20uIUEz2IFQQNKGQ1jfpEwmNWslJThgK +uo+kmmew+Egi3A+xBRx58XO22yxiJw2vub/UHhDuFou8pbA49eXdjTbF5aTlbd7n +7AJcyR+DY7ZV81QAf7kiMQqZOXHpw1mJAhwEEAEKAAYFAlQOeJIACgkQbmCLY32J +Z+nTwg/+KaDvbXBevYDLTvSmgFWiMv8pHUBvGxnylrgOsFsw+YDwp3sJSQ8ZMqhs +8GCiQNf43AXM+Nr+74wyq15L8loZaW3ZWpbE4QnnmyrqpLA+eODHFx4h0BoBEXB+ +ZIrxDyOBAXFl9M9HBLDKoyPyO6J9Bgn/EG47N4JxrzrQB10HZsjg+Zw4vmAuVtkf +Di94mbIolRFTAolVOxb1N9A/8/iFddrLYdUAwZt7+8/+afloVzVeLFQrnLLVslAz +jttmAS7tku3a1Gr5j836C2FsRUB1EqfslA14PWHLrDleLTfI7ox2GU3xW0f4LqiD +IhAl58Moxve6rMuSWcrSUFkkVBON8uRjZpkipCXA4nYkvfDKJbBVQdXuyMb413NX +TN2rP4l5IojKf08fUxARkcSJ9Xb0sXgGjmDb8DFPMoYb4i8MCRZx9DfMZ+WoJ2zF +ciwrezIX+gBFh/MPK3WOTEx59vuGVFvTuvPuNrWq6VhQ1ysCV7reHKkJBbcd2yh/ +emA/GuNBbDGBFWQdyNCA8zmTWpZoUhGiktin+Twb0wM3Ah4wg6NV1LNkd238KpnK +ZCF93nI6YrVgiDNiJKIMTGKZC88feyeeNmJyJmDPZ2bJhUBemhwDalBzxtlNUkdJ +xoLiNJDSLygBbb8nuCTMxkIej+fKCHOUnl/oBLNjEVGoH82CTEWJAhwEEAEKAAYF +AlQOfAAACgkQ+z0lgztqr/i9uA/+PtLe+qSiaqMtj4xNThVSD/bY8+jKRLMXuqx+ +MAj85e1ZjnxlGQAxgdFR8IXcIcWH3oS5tsqmmv4JyX6WA25mbgjVM6QX1o8D5DY7 +/SqkvqNypLAhgAT7w0Z3RnBb0cE23OI0Kyn/KZikfliRm4OEvXzwB0Abn0uWGbaD +xMqOVWmXEgS6tZvZlfHLN0rLI7+ztgaljgKivvi4ELOOJZ5hSMgDk7r7XlHfRstE +mr9wIP/UUVUy3TsjgCTM2Y3Qy0ypvR5EGhpEpjv/iucIQZsdV/BsLXhNuPN6XB7T +Dje+Ca/IGFJAwGTnSzroDZhSxltxD+mgKWrShFTGhHPclLU6yNv+et5KVCARh1Q1 +LF5VKeNrcyG/zwgfowmy1c2gib+1IdIjGnBBnlZJceslQ2tBaWoWCC2X2vXDldpU +cGqVQUgDeVriahDQUcwDRDHuOOXpbCfe3Qbm0kB3G1+MpKg9Gk27nKeljo8I9/1l +jAXQSq1xU+DAoKAYseVYMvAK0V/FF6yU79p60PoEzvl2rzdI+aoiO6HzXDy+BsyK +raIvKzWFvHqC9IhimZkulPzGykbHKtZoH4DQOtoHDXCCiyg9XWl4U60mCh/WlTgU +cyBCv2NYZTQmBeoOvHcRGomlOwEDqNoJFB2R/PqcCT/gd4YUQapPrNNcXdw7ovLm +BG3iNoqJAhwEEwECAAYFAk1GiMoACgkQAIBvK9cppFfkLg/9GhpAnAqlz1XKSIFQ +1rEWJqJ6HJKKF2fVHEkupcWIfBCJ4to9HryOsWYc62NmU+CEk+sy/V9/7kRQu5Qy +9KBQ01f/7LZCwpqFXoflxn5ZQM5E2Jcwp3GBgIHNQtByE4DZVXYVeWaq5LZkMeW4 +5ptctETPnN/WbHV4Qd6ys4UgsVDw/p60RXxOkSM9lxtc5b6QwwddFBBxLCrMMWf1 +8c7RJleG0h+XH5SELQV5Fmd94yjR68cWh3PrkPph2tanMkT+aQu9TzXRazb/a+FK +p7u+tXwt9rPIlz9Blt5/4umDT85KHuyNvdTsxLe/AdTa0PpCk+nBOuzPtDZ4nmnv +Myty2Z6oQBfAaAIhKXTF9yGXvZOvUbMrsX8wndeSF8OnRyBE9/EeOIWFWRi1uWcz +St+9zp4Nrqi3hh18Z1Qh8LyOP9snH+4zsJ8o7hxY1pFLf3/A8qhxdt8JfzqoQMuc +56lqchbXf6IIEFDnr9FK/mPkAOgofd6vo2k5ruPWYAm1Z0eIAoUr2kEm07ZVp7Um +6Tv6MYYh4La+wKq8gtNDcPRvpFPM8X5LCDKMM5g6g2AoQuE8QDxjy3NaJijFsQJc +iN77v+FZeasvynmaQBixaM3QTJmZoYnIrr78YnRNTa6K8cq9ozpBvouLuVbUroPS +plit3z8hr+E6Elw4iea7oA4FTeuJAhwEEwEIAAYFAlCDJWIACgkQExjvrF+72865 +ZQ//fp3amebwnyLVlAR79NQy4Xp4ONZbbixNRbhbYX0nXMCetUUliKINcUZlUoqV +7fAa8p0gP14Z9uGowgSwcNgtza/TdaB+uhqom24aCPIOkqWKSN5TQzSSoS7Tv/X4 +eUjkDfmA+Lxs7CayCCKoBR8L1h9LtJNaYD8HwC7zpFjSAvoGEvwbayEYja5gKPq4 +eBm2mL3yfaMHYEMT10dP+UpmLDLtWC5PRo251RC81B+lXVIVKPhKfptoFcRyYlAs +MBkXpm+GoYFdhznxP+57LUtGURFK01E3QiWkfzhRXTtqwQYRcI+M+0eKS3h2AGIZ +JGmh2od/vXQLzXFqeHFYZYOWpEF8GHOycCHdIKxowRsJszu+3t44m06OrLeyqlNR +rB9JcTKl6GFI2Ym3n1srxfHLJBbseHN1fsctDw2O3glas/J01EePU3VycUJ5gPks +Lv6qi8YyVF/2wn0ULNfe4hihTo8AiKaiaXEph7hcrCeuxZm5X3H9ya6RLuuEjDaZ +KPscv7tddxEAfev3zlB5LSZIU2Bkdr9i5RZaybutesObLWUqC+hK5qc3tbbP3qmO +4if8MA3yT3gVxoN0iBYq6YTj7ax5RdZJkpXeYlxGsyPSZUC48Uj/8uu71f/8UMpK +HVACAcxyGlLtwLDOjN+vo3RTBxbpS/J9EjqbVIDn+ig38mqJAjcEEwEIACEFAkrY +ZFwCGwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQGBR7BzutKwd73hAAhDtg +JDrryvlh9A7M2P2ssUv/usvSYnFhbVGq6ooNSpV8gcrxmAdSIXd/BWq8Yx3BUith +WZhKgBE5ICA+sKB/C9xHTAwbmtpY2LrxLFuMAPhun4ArgXpFvUyUivmBjREwDxS9 +Mxm7Cbzz/W2/dCHRnD2KbsaHcxkaoyNGH8lZz7+vxOutTa6nLLAbLbCAb6Afp8cV +ejTrM1mWyg+rOk8SbyTL9LU9qXKA2w4S12SwX8sem8vV14R4ila5+P0N+wRL8eOT +Rf8Jc3rF/4KFJUMxxbvxd6KNAwF6XNvDbKSGNx8yXvy0i+5b/tNfWeX9IPpOn/Yf +uPYtSOXb2l87tzk5eqOw1oI8KRYzgQ28LSulsyj16ZIjL7ZbUHvVxg2ujdBWYUDD +uErDkHanmf3HBZGkh+N4rfKV8wDz7nG/mG4klsYuguWQRzytYT0USXxsRyUVRaQC +ACL1CLGC85ZWqBJA/rgoKh8Wkfux6C1uc6nTHspo5ix/XI0j2FY53ZNZfZk8ILCR +csSzl8XkuTPH7gsk64lhlV5SqdIL0t1ucXgSCU2aCi9BmVnUXstKu6rPs812XZvl +VtTmmPxsj1mkST5AniGLiUowLeAz6O5fBHZtZNsEWQ8Aq5doniy3Jcql4UoLufza +zArG8BOrwlJo2TGRaCxJ8l8ELYyNnm9mA+oxg/i0HE9sbHkgQmV0dHMgPG9sbHlA +c3VydmV4LmNvbT6IRgQQEQIABgUCSi4NDwAKCRBJxRkoGdA0hj4kAJ9UeUCAzflf +uEweRqaRkB7d9w2HAwCeK7uQ8amEmdPFAv68yRj88kxitm6IRgQQEQIABgUCSj4G +QgAKCRD0tLDMeX6/qxcAAJ9vCocK9MrqlFFMzVmszsLxBV1ZdACeNYfDrtazLH91 +sldfLq097FqyqtKIRgQQEQIABgUCSuQdUQAKCRBmcp35y3EcytR/AJ9XDgnSxVK+ +/d6RYJMFppEzbd+aawCeKcnRsP8xDS6uame50bD68Ty1LfuIRgQQEQIABgUCSuSp +BAAKCRDVypsE8sQjvBUlAKCHxHID0LFdsbN7rjIhiFTSUjqKSgCeIv0aI4iUvVwZ +IeAappnI9pWPMhKIRgQQEQIABgUCSuTM8wAKCRCue2jzvSqVOxUCAKCQ97wwyWs7 +C+YZ5J/gCDfJ6eMA5gCaAv9GSdTzysRAUlGynAyh2WYAqVOIRgQQEQIABgUCSuU5 +DgAKCRD8BkCIZrJYQ0dwAJ9cEksSm1lgC7Ama0/k2GvO4UXvQwCfZnBwSGDmuNHO +W28DCqeHcGmOhceIRgQQEQIABgUCS1aZGQAKCRB3AbuFiXrzozNZAJ96mCyqPYmu +FyECV+Uqkvru1fWGqgCgrnAoQ/BgbcCgQPWCQdtUddsdsAuIRgQQEQIABgUCS1e2 +mgAKCRD9H9kjU/RdMs6hAJ93FT6o02mu8GqT38/L7PpEpaWLVACeOLc7bosMkKb+ +F3sNDisrjjHA6SqIRgQQEQIABgUCS1pQYQAKCRBd4Tq55ytLvw9YAJ43Eqjzf23h +uQL3suux7iEYZDWA/gCbBbYVdC/C7mbDjvyW23gmE/Mv60SIRgQQEQIABgUCS2YB +9AAKCRACvEK3Q+JdHofFAKCCMgFXZ9VIwYbm69I3mu4UhbXI/wCghWREphfKALbe +m/SrTY6w1LKv7HqIRgQQEQIABgUCTsd06wAKCRCnL/ZsQr1kXYSzAJkBWcaoVRyt +kBsGC/1NURhgxXNySQCfcS+kLMoZ0y3lNhb5EmrXraV6lEmIRgQQEQIABgUCVE6y +swAKCRBkqZqCAQRZM/YjAJ4mvq5L177bheCQeVzfMUixT62ebACfeMGYEztL1zL9 +WSOFmI0JzUPM0kyIRgQQEQgABgUCSi4npQAKCRCMkDR/jwaAEkpgAJ420rFu+h54 +jIu4u1PfaOIFT4E66gCgpfLQH8bXcBTDzeyKdSNlA92GJ32IRgQQEQgABgUCS1a1 +lgAKCRAU8iKaVSrZNPoTAKCNMSiCG4jkrK8Wl1QeRAI8ZlKVaACgiKlom2OApK8I +aBRI8+kGbyVOOmqIRgQQEQgABgUCS11KdQAKCRAGMraGigSbIdvVAJ9FcSbn52f+ +PrX1UZ4rfNanybYH5QCeMAstnfNrF3BxyWDNsJG1EtKfHVaIRgQQEQgABgUCTEkU +qAAKCRCKkGd5GIAoPEpbAJ9MNcE7rWLG+WtrsnMg2EIoBInONQCfbPBzWAiw0vfQ +6FKGX8XKLOy9pnaIRgQQEQgABgUCTO7RuAAKCRC3rC5RvUFxSwYdAKDAqytouCj5 +0qMrvTn/fMRmtQ0RvACglCJxaN1uA0tU42kAt0MovdceRmOIRgQQEQgABgUCTsRM +SgAKCRDHbOWsEsrfpdERAKCUFjghTb2bovdLiey3xQMuloQChQCgjE+97XKe82C1 +hW/C/lLouO6PbMKIRgQQEQgABgUCUoY19gAKCRD23TMCEPpM0aJsAJ9LnMbl2Xh3 +MTscr11uNEZBhUeQwQCfSWWyVocCCBmO0euVQGvZO9FUUNaIRgQQEQoABgUCS1fL ++wAKCRD8BkCIZrJYQxjnAJ0bIBb9MvtcDr9Vi9c7jxRe78xJ9gCfWT7flpMbXe5/ +fiX42cXcNxkNHQCIRgQSEQIABgUCS1deUwAKCRC7tbRTxWxdgrmSAKCjr0A3GrQc +kdela44/EcCfl6jVdgCdHEb8SGPpzgicqQGu16mZ9BGY2dmISgQQEQgACgUCSi3M +AgMFAngACgkQTutBeVcJOPdnFwCfceRa0ZtWtgGqa4wpamFADDqCUsoAoJj3Uoir +IyHQoMnX7jZcxcWiuPhuiNwEEAECAAYFAktWmRgACgkQwqNdSiQ6EymmbgX/XlwY +KUUgIxmFLbVd76Nrwe98c1QxoCg0GJK6YgcFVoEVG67G5kFPWc9kIy6QVbnIda4t +H5NbjDbiUw8lU19iBs1DNwGODOZJHBD81oFbEOlaiH/W5MyOpQ2cpJWigpZFzEw3 +o6R6tW4QwOX1vaL/oWfSEaZlWtrZaJDEqcL3kbS8hXKIbxm6ljxLGzLUxFme0SvH +902YDipRmqOvSuMcN2Ibg7T+7bzNibs5ALK27AxR8Lhl2s0AgFZX1FOXPfSViQEc +BBABAgAGBQJNRO2VAAoJEBdtaL3wGtIoJHYIAI6nA84of84jG7sbk+9AGL5Y2fRu +sxgYqY33zRI2ZQCRvh7OLLbrx4dm2llfsTiBsek7PWTzLO5hvDri8YYFUo5hOcbX +Qq2kBHX1S5OXG86N5xU+D+IjM5U+VjKWx/sVT8kKrlDe6o97/aoi2Yj1vf86jjV4 +QzH5Kf+ipSZVC22BJUm0WUYx0P2C/Tzlto+xovRHtYzvcEGkhr7vbqys48p5N8U/ +70y3m07t5VzGqVEMwx5kpI7Es05dyLPczh1aBv66z/G7424tsfqwinPjNBZaHrlu +Ss91546T5PQKNJIpNp7J1hBATIJF8leCI5LmuLaKy/pRUlLK+vxGASZ09gGJARwE +EAECAAYFAlCDLA8ACgkQNdZyc/n1A3CL2AgAp+xNYyFY5evaaEJYNrEgjjh1A5La +l9U10DedULz+T37hcG2y0ILRZu6HtSTKBTDtg587las2Q2HoGR4LfBkXXKDX4Qfc +nVuOzi/W2NLiTYCmZGDYT7mX26xTy+KRqFHeLLMW9igAT7VPeUDkVuPoDba5irYJ +9MvnrrIOMfA8KxeYImhMWP9juyKPnxqRfhUejwAYPNfPfqfkOmmNtqhOLJKfqGhQ +2iTFwL5k4A6nHDwLelIcIpnSy9cfOLYPvyX4j4atRJgtLILQFB/gIyl8agdGx5MA +HEKAtKipiMCw5NZ0QbDHCfVofO9rgUmE+G7+GG5BOABoEZZIkxpE6wi4VokBHAQQ +AQIABgUCUokGTgAKCRBJM9q0AO9d+/sSCAC8Y+4qUsM6ksGkvAPmmv8GCPO+EPN8 +NR6KOtzwfdx40h2c0xC2LuHebgOoobnZiiDl8FGCPvZzttIo8SQnIImcRD05VdRJ +JmRxBAGYSUAZbV/t9rGLyu/18L97G5bkRUMWHHBMEpkwVhMu1X539AiCgI+p+Tym +I/ld2CaU5frH0KYtzIPv0as2WsDtbsHWEZWgljem6xe7po8ynk2tt/Flb8R70MDy +hP2NdkaPG7uVtxCsKhI0/XZYbL66HBmQR1fCSGUKyH01qdLX0NH5O6B/n9tdb34F +l80V9cw/mfwHFxdPVLHj37awX332mrzwg+LwuQpj88nk341+dUhdn3bmiQEiBBMB +CgAMBQJUTFkwBYMHhh+AAAoJEOEbfgtS8GruGjYH/3AKHVCuxrGn87GzUcReWAW8 +EjC42NtJk7pk1kzzMoSU5bssl93r31ldpAiLGagvGX2URVMKx8qP+WgD/ToGPDWr +BT8Yp8JAoQwQiyfIs70Jl2m2JbnaM1vJ7CBhtUFLrIvkqp5RiZtWCjC68qp3d0eY +ntDHI0vgg1FKNgvbO8E2s0o2U8rS+QZmkrki7siTvT1s+up+5/I2ljaVbixYe+wk +xPBlqof6jNHtjzhxUe+rTyqloIaG5ls7krRA6AS8UxiOX/X86f7F4f0AXWpnSWXM +AyqSnz9PLOyvX7sAlt1mJNp834uPurJZYgEtltE3rqpV+NXczVqcAHnQ4tapPKiJ +AhsEEAECAAYFAlHsNd8ACgkQ+4YyUahvnkfSgQ/4kZUzLmShHnY9zzN5IZ0CDPD7 ++qGTewi9DqGsHjikfmJGNal/D5734UMQwfW/mZ9FlcDdZ/T7+NXQHCyenoLiPMAW +CWBkhmZz2AlY3/XyIqUgb6kuDBKpu5Okc3VQmTsorECrdTDaVFaF6MEIveUrOiyM +SiJU8UvZ+j+yHv5tj6ZC7NNjC8rQGGPZ04QXTAGRHT69a1OKndYP1JInRrkjNuH0 +jdc177FVzTfROlOC/CF6uEWOaZvkLj6xJNRQwSR0m8d0sWt6ptZsNqOlJbVff3oh +G4W12Wd/5+2p3BoGloNoxY1bIbawZMKdloZRooEdlDcanm9CqftC7Yo3nkBA0CWb +tdUcCmPpyhWleBVNNtHirTWnUBy+JsfAPzO6H6FrT+CG4PMGlbRK7MPKwuhEcwKz +51fzvJNuuroKml3irkiWwn8Gjkneo/RFKLS2N/ZM+iE6ofpS5nXPY7N0cMf3jrHo +1p+7ppkWJLBf6cv13vYkJGlLrLu/XfnlLuAWIoNZFihrYbe3K2JONofgAjCTN3cR +uKGQkZpDXaNyd7bst6/rJtDV/3uDhx7kOqUs+v5SFCHOok/+YLMrCAVNbDz51zRO +P+pEu9pgicO5jncFWjxlm89YPOCj1N6n/9nstXxxT5tDt9SZOItwdmLployL4ivb +A8p1Dj+BcxnsXWYdIIkCHAQQAQIABgUCSuS6wwAKCRB+ZSjadS8b4VCLEACF9NBf +Pdl9IQ/ucFqNklA2DuECX7iYIJ8Vmopfvhl0YV3bKIWwJ94NMoLjV6YraxYUvJpL +WdGd7QF56g5/F6J0x4lW4su8s5hCMJzGf/B+rYMIz6uee60JvspHMPDRb1JSHGRn +Omj1KHLOZWkisupjlbOqUEFqwghWAMWtogdV7DL1/xQFF/IYSOzdCBVRKg2eJ9am +Qub80uZ3dsbDcqnTrbm5DEjduNLBX9fqQQeHFR082pf6zBLVbcadM842MBZlIb3m +zHDWZhQpVECXM3p8QGXLVM48gux/kOKucoHZSmn69S37NItrDsyhrOgQokUJGrz1 +ZXva+iG9/3PtV9cMK/ylr4t97pV6p+Vr1zgH9hXSEBoLGK/1dkFu7+2t+PiSfVbT +lqo6pJK0rN84xjnRDlXxpTDZn66rn709mbRcjV5NwHDMIJG/rFTuxmRKuvXLYOnJ +opF/Eu1pbjrX1V0mSFMu0/HfYxjnIGJwVbex25MvF2h6AvFPgnG5Oi44KZYpbUrO +zbAaqtjKXPG2miIA5l5gq4+u7LL85qMwYUMqkTYTxGFpSjMkEbDINdMVckwMibIj +XE517KbgFvO7wUUKI1Aw1UDCs+qwR7k7BHRENq9AMLYsqcpamFbw7tQONcU+EFkx +IbCHK/oCIJLJIB30JzaNVGdtCBohiFGw3W781okCHAQQAQIABgUCS1aflgAKCRAh +n2tgsrv8/Ds4EACjXChjzOqnCJdNlOTgG43huB8ThwyNN9iDNlYi+4qdP4Z5OJcF +vaQLFMaFJh9I8AlVYzzmIBjBLYM3JO2FnozZ39uyftgwKH4rR+PpubYevPjuj8hK +y3HrP7Jc0NWF7Zli4mvTLVqb1c4PgHQUaCAcSd7c97A3iBhgLm16Ne7sshiUcA8W +4QUWWgZ3gmmIaS3e8PNdSi3OSiXjeIYZye7Uvx6T9T1aLKtytGAAhbtHoWPVe4Xw +VI8QYHItbVXy56AVE7S9fddLV4qYYG/Lj7MZtwCAhJIhSCsE7OtA88iGXQSd1Jul +yhTdJhEsYCAkYeZ2Y8hKAkBGjNGRrEz/HxifpQfQxHGBn2bgTNCjVfSLY26U1C10 +kXZrL5WLi3rVvz1iepsgRh90vtR3Oz/0dkF+nbg/jadano+OHBEzYB0Xt455axK7 +QIKTc3OD7h1pa5HkM11L9lcLD8IYbC4lqhx92CH7ivoCWrmdgkxxbnTh3imZqmfu +VUDh9c9vM6XMJ9L9Jb0imPJBmC6HJLAogwznEhiVuNITP9s20sJfX17Raz5yBw0w +U4EJB/jNRny2S+12KQWife3J7fBwC+6Un1ivjjLqXgidW2/OwD2GoRkxu6sRLSpN +TWZitNUT6RylxljBbWUnhlOxeMO5Or2tfZACVNdOZufJ81pkz+VvnbXycokCHAQQ +AQIABgUCS1eaqwAKCRB8IF/xJsE3I3n4EADNXhUARWFMy3Ix1sMjj68+01L5rs4O +merCnk5PtwXrJgxUEYSflsMVAmKJWMG5Lufk70TTKeGyqbAk3Te/FnJysI2Q6oe6 +J6PCMPra93ujFnhVWyJLbyePVJyQvex4xxUTZCS1GAqOOlYLjggS5fpZgaasBeuw +73+ndgp2mN8d2uoePaqBfKmMFL0w7YuxIADst9JU/D6j+ftXhLddbPzVsuGwH2W8 +ywTmwigymb7R6gLyonczb0+NLu72uNxarIN2wa2s+uMAHVVhvyhPqjTKFr3dNp3S +K9oLlnLf3KCqxJbLce4/7sUr3fqeYkIr0sXL87d9FDxjblj9+RyVcWabAcSPHDQI +mfE3HvbmrSazuqaGROMr2CWtWZSyf+i7pv55uarWPlyechcNhoXErZ0Ta1u9VeOw +MKnrMQVPm4pJi6eQ9w736Vjx8fb0AHCqWAA3j826J1S7QeGSsilpQPbOIDwMFVEN +no7pY8X9yM8NtwtZ1wwpBBLqQr/CFiIBzYMSrlvKCKWJSnbnPBQgWtAmKP70WQkN +sWSlLqBLoAAyDS+jfBr1epoqglKhIbILN3Xo2BM50n+yJth26d2nToADsyDrC2fG +wHqhGGlaK1OZGWXWLLXmdVE7qDCtc11ji/5Py4Z4oaSX/7C16mBqrhBnvQ6Dq97G +hqu9tFmNBkumIIkCHAQQAQIABgUCS1fruQAKCRDyNyM2/sOXRd2dEADmm8rkdJdi +PHdRBkYMJR6q0lhEy5yh8VuaqN+apMzJXq+hpoQj6AbKp225z7re4IBNLjsw1J+v +BS6FxuMhdGjpXeGRD1TZKCSAdGcrxbGuNLFJkPpZUdf9xcCbgfflELxyC6VC9r2U +IVZxK+Z86AQjFBLZHrGlusFk+yb1Gv0ATOuNN4dr7wCm77bpD7YWGpgJ2Hqko7Wi +7u0nbY+Bk5kd9z4hD96jCNiVne8A2NtfgfmcD1NFUTyINrvOM2CtOflSD1Zu1w+M +eNiLA+up9eU9ME3PBZic6wTIP8M4LPI4zBw2q3fjcnbPVVe0JNx/9ZUc33dDiwDL +uVWzMvVHM7F0OqxN9j/0AZP0QZLVcZZ41ghxMELg0bMv1Ug+RzVhAnr8Q7gd/BCI +nxtDomcstmDy+ODzhtAhPPRIc19vifRA/yw5mc4gIandg7BbPcmsqY7cseBglmVe +TgkPXKN3KfDduCCFR7NjRtPI9xwieZiR8WaL6Z/f27/3jnygef9TOId2nlzlQRui +AhCsEJyGWcYuH4A4XLBKsMAAKge2CODnrnUbqYtErRecxTj/+2RA5Uc2gwxti887 +HGtDHLVTR8E2v/iqWuQxd4o/ySS8J3IxpdJzv4xOfRveY9P+VxfCijh2b5SBjSit +G4hGnc23mX0xu8jwVjLYVCgI8MzhKYS+r4kCHAQQAQIABgUCS2Xh5QAKCRCKERtc +rkJpREVDD/9h6LX+ZmyfVo7tyqPWhI7ZwCvzgPQiMtRE72Ei7mlPacDGLYL0vSeQ +F5cXGjVaTEFK/CVy+dNyi7L4kpgq5XCIIu8IhtawkUKrh86BTauB7TqXK2itzpzx +JzWOkw7uouu1vzj+v2p/0TAlbHfqyCjl8RS0HNSSHJ0ysii5CYhM9/oyGC4w8tDE +CANg12/nGBJfFtaoznGKAGK+KBeoH4TcjlnOP26NMQsbRV53cBE6Fg3OXFuAclCh +nKCQ++jld1dDKbDLNQSkE5oi/jcklADp98+sUV/1UVoZseKHCMrqGsAYBxwJbXGA +FWRqWq32dM3Tv59vvnvwr0MbSNb9tZ4pSEze+ILUTLUJ3Xn7fUWMYSb0+tvt802y +d38YsRNiQkVBISrV8ul+5/0aafWKeRWfFcveYhRLSgndP94HauFgiwNn6Sg2qhNA +Gkbyil2ocUOwurzUZPiA3l65fu+CBldVFXCEgMkAVHhTFP6G1eNTayQfX08yEahD +hD6Tjj3FsqKh2WdknmTf973j6jy+gXd7HHR154GFVRGO+rLeDMxOAiskxymTQTGV +xM9Pr+VsSQP0oAwXauIecZnTlfmvCI0LmFRsFSNztXE9Oa8AY3CQhIH8fvpMgdZd +VUthf9RMqSlufdsc8rVzv/jaAiKGbWgqmloBa+X6RXNt9VwyzqAvZYkCHAQQAQIA +BgUCS26RoAAKCRAx+x5uElnyjy9tEACvBt86uTEB5BLSdBeZYyGGj4pBhb1QYzmM +qMTPIg1GTaBAQHrEKkrcOUTTWVtT0WUkeYYvnD6uD7Ix1dI94hiNs62Z/dDo37Nq +jI+RXbL498xOWz9eabKJqG8jUd16iC//kNKBzw4yDo4mgzQOu7AHM539C+CPsnk2 +88J4O3jceyyOYuX70rSFkik7UqQb6v1J9/keok6GV5QQZWSlyjVwNXleLuAOJu91 +RL3UGsuCy72b5+ZxCbIH8NFQdsP7CkxYuHWfE+CJ+HIUfuHluKtYQfTvY5jYPKWA +Dgy+06pfrWjBiGeFyY5e0shcjKRdBBeIL1dRJzStHkTNetkQxLq9LQQowkKAN5KG +Y4VcF5dih1YGJDZKj9KgGAFe0EhTtqlLsVxY1FfgHNNTZRb+F7MrzbHDpAUcDYVC +YGrrvDkKpJUd7z6WTSba6vfcMWwT8fmqGqccksbxo7WESZB1MueOQT4ihitYQJcq +d6gRiDOv/PksPCSUrIBeQglhSUv1EvMmTM68xzTgqbhmx3NLC4fz+zYnI2eWo/0s +AZh75o7meU1/krzy8Ur8Ujh7mnur6h7CHKIVhkQqZbTHSTL1+K/i6fVu4AwCXoFW +I21caVn/ItmaqelPRNmSOrsCu3vUSGSzxSqgLx+3kGEfyF8lEfhKFFm+gnoyd39T +mFI9HmrZh4kCHAQQAQIABgUCS3uRWgAKCRAorTKyGMy4/nGdEADDZrs0ytUzJYgX +Yb48dl59N/uWIzjanYHRdm2ILyhQgKG7brewfh7DNtHkUldph+slbfO3kekkmYKF +tqa/khHT6Wam/lh9tFi5HFUb/Z9wunxzc6x2DhW9YXm3PKMS+iemm11+1reMWRUV +q4wjv/JARL3lhSbIlaLbXDJNUDVDs2DVheBz45SP8tnTGh9XIHpRed81EfoRQATu +pDG3MvqaEh6oX4mKsvEL+3fbmmzdPfXAxj/gbXAtN/W3G/wNkoGFdTHrghujXHTe +7iZcaeSwXfvUiso+aY17loKzucESAb0FWwHPIqA6NePiO6H3q71N4cBxPN+olRoZ +4jKc0uwoXFIgMcsR4R83rHwUjUyNz9q8/XhGGR3ogFhSySQc5oZjEw7zU8m46XhP +ZOOqjBd2ir5o3vo0lFdvuusqdscRvuMiKhXElLRf2EA7YOO8EJMwf9xLFaqvUa3+ +O9hdAbN8H+m8pCO6Fc7D+5bQPtPT1LVD1PpBKHW30kKkFs536r46+tgeLzu2TX1Y +AtEF2HeVDXQKvBkXgRK4fbCNiamvD7Ks77uAtgfQzxB2iX1zYJEBZ6MjoEm07JM6 +fDAVyx9UFD1skNPWQATYTCqSPBSeAssRs5gtcfdVolt4UKxV9ArLHxK8L3TAPAH9 +5k4vOXuXU05EG1rf85w0zYDnOVa4j4kCHAQQAQIABgUCUIMoBAAKCRB7WFswgHwq +h3ycD/0a4zXVB+4qb+8MxFG+IB7IUTT2U1FsztsBMxSuYTNXT+NlMy6e0+OfA8IL +g+k2FASu0bghqaCRBj+lLwKZQrjxsKeHFXI2zBxVv1HLj8GDxghQgYyub+aGUKs5 +z4370a3BZ7svG0bnr+uK2Y2KX++IyaaT7+oqWefBcdbsGJb4xLGWXhNjZGAOmpSf +PvQwvbi14kE1797G+AAR55oo5bthgWSJhy9jg4x7zplorYZl4OG3Q2HrgjkPRreZ +60cNWRD2kYiEGtvLOdV9MPgOxN++gXZbz1DoE2To2PZLgHJQ0kEVLR48hw9Cq77V +ZY65vkeeC8ar56r84WpDTHC6gnI0voLG/7Kf4VLF95yJGIKCLu/OxAhCi9gCsjiU +VwpwAgf4pvKGjq5SWTVuHt6SkNzLvCGyNfG+0ZrDurN0czPqLie/y8/zRhgGK/Q8 +dTOs8FWFjas8mAsSdCibC6hAZoGekHHLa4Za/zQJRhka5rb28GfFl+VxkzozOGO/ +fbDV+/sGNwMVr085nPLwEHRfp5hHDsnKQR1o0llQWO8WLXrm/Y2PYE84OggZHdec +SloVXxxEX5pky7GqSfIVZEynn9hGk6aSyTa0dkG4mOcNTNSBvYYJ3vmMlOx0jeRt +CJ5vx8Na3qF/rwpwZlchrUHgtYYVqy3mUHZEMY776JvQ6baW14kCHAQQAQIABgUC +UIMo7wAKCRDXAPpIE7KG2bqND/9c8bpJ6NCyHEXmYlBSorZX7zyDKEfS80l1LpH6 +e3onpCj1gmYfGdixMyVQUnUI4p++eHgKSWfHc3vVSXuX/DNahiSoGPi2xcDmceI9 +N1M66u+iDzD3ETZ0Hr82IYpxCDDYcUau198pKfix75Pq4bjUwduCnAK+e7VZtmC3 +jk4rkdDu2xG1pPMH1vYPRqFdZ+7AXrslGdmAv0O5bxjGRNnhOkOvd/FHjlxkuFuZ +JAwzGYI4qMiCrXYQE04vV2v7dMQbV72xNm7iRsWQaE3YzkBKj+M3nNgXgzNbSJl+ +F3IbqX8+mfBu8k01PZhrt4oP4sOHqhaE4vBafLR4EQuSOCwTbFoiXXBC6jYg43aL +4hHkrLUxxyOujENM5dWuumffttPfB2RmplUSPKqrEAUi+JJQI/wMXQdbf4qvmsYo +2WJRmd/HoVd2Ao/paW36OdrrffUMgKfsFSCmYC4w58YvjZO7Db8m1B8O4zAbDbAo +ybGDL45hZXM2qbrqkPR0fjOAshTKgoQKSZTWX8JSzl2vtLBGjfWD8q5LtmqhEBGG +ywC/ztijRq7BmAQ8RuYv3GkIaU9hztvLMrC2U8RXHnB2UYN79xpsh5cCI8JWFir/ +S629amr7L3bYJ2TnlKEQ93l78vkwKO75//5oYEsnd4RBc3HzStBjpb6e2ILl+pmG +FFBgKokCHAQQAQIABgUCUINHdQAKCRCfiPtS+vezk7rID/4xlm+Y3vUPW4GRzu19 +bVVA+eTmdWnVhz3GV8Dw6bA8gbycUM2KpExq0jLtok1nLL6lw7XvIXMItx9jSBA2 +Nl/L6gjyLxX6pS8h4BgdxDxCBRakpcjBtj/px7P+XX02NBqdMDtD1q6apfsmGrxX +FkpvR2LnjXDmdUpXoubJyKmuroEpJRZkloOFihw/tedpGW2/krptbfwELx7ytNYL +1tn72z/++iTHqjnksP1O97WRrX8at+nw59SOIrL3N+6oHwuwuQcwN05L7+L3gZ+a +kbs8PnliOfhfF9p0Fu2/T+hBzHK/isaknZLSOrScF0zanjnxS72jrGegso2U7UOR +GXqCPr2gl17x3rEgkV6je34EJjisO6bhbIdRh5KaqGiEA/RKU1sL1T2GG/uAJakv ++U8BAnl/FCPKnUo/aUz/LGthL017tXkUZDa4K587QWa9KtL6ZTa3nTi8mmAmBA9A +uG6m1KbNVoVyoeaGOjpNoXjk35eQ8tNL///AyG52jq05ylQQE4wKHaDU0I8WFks8 +kyXRABL7ki+KI2KouOknC/otYW/4cLou7l4mzRfNxG46Zb2ZIEnoJ7XDGgvGDIZy +izShLdH0c2N/iL2vlP/GwE3eZxhA0PQMkq5jsbuBuZ+VZAiwWQ3VATfflqRqxLXu +vkCHfRH6n1lvCVakWVNsDVVMTIkCHAQQAQIABgUCUJqfPAAKCRBZZqMKU/6CMHRr +D/48M/oOdU2Jgk+NOBPex26lFKZV4f2BmmfLG5Hv7yK7Z/+hdmwIgqJkyxuhvHcO +zv0U0l6PrTq0NaWnQqC1nU1RQDMBfkimPQHwd8LsCHIZBp7FCkUdt2WWdW4g++nJ +4b2pSHXQUwCYPZKxWkcKhcQ2aH8bmh61r5UcEbezfuzh7uq8KJ1Gl63cELvaR4Ng +ZeN2iK8PO455V6DGjQFlxC8oQDKfkgmOyIzcaus13sK4/Cu8EiCXBzV5NAigq3xi +9K5ecgRKkjn4UNoNPHNhvOnLrG0KFwC72T4XSrOLoAA7QwFr78JzFel0XMy1lC9Y +vLqXPr7DcmfmBjBE7v9OfL7hemZvaXk0B3Lqch038XpmmEvEexeylBixMF8Ysdg3 +YGE3QRKKH6mTDVRUnWy4MKjxZBP3JIaLnO6FNzjiWILw8Ckk9LhXMw7fW30BFYTw +CRyq0dBnFeVypQwr8HhOkWyt4KPJGKPCTT7Or/XtOxXwzF79U2BbKt5461Vf7TAr +Tjxb8Zon7spHpelYZmLI5EgfjIhHd96U4MEf2Mr+6HnJEjCXkBASBpUbtE6Lvhq3 +8uix5ktpd3MdllOo2m1PeSQywB0SKlet/5eYQd+ZAk337+4jT1dpYXHxNugWOTSa +NYVqfpkHFBn5p7ZhS3B4A9QeYfRrSdcv6m6zP1k9I7IpMIkCHAQQAQIABgUCUoqK +qwAKCRDY7tfzyDv6mp68D/9xxExXZPf3Fw4KYSNzmYJqpwukqrEMbWkMCIv6Xq7k +XAqJoAwr9t2DVe/fXvlnh7ZCmvYB0ZfJyYo35VE5XuU3WQHDP9Bdkd69zAFSMDNP +WVsb8GQVhxTZ2gtTuvRRSz4oq9l9SJl88d6tZBz4enDxrXKTnmF0nkf7afW46NF1 +RtjiTlQ+dN/o71B9zWzYPp+FBICrsL7HIRULZmnnbh/EvLOOwAlxO+YmYtt72JpM +0uKCW1OiwIZUVjH+tFJBWQWretwra7kR2vha92bbFdFzpqtiM/sWgANt/5KfVUlY +UX4YhnA5s5siet3+H1KYyva4RhXn5X1JGhlroaPavyA7wM3T2J+VwoYgLvnNgtPd +tItMqR0GG4XXL4wD+bl2wFvehhTj1ZgIGxkEB2cvX0CsD2zhvfH0lEj0jgSya9Oc +mn6wuEfCllyWyHwXj0INIrCCdbFf547BGVqLyr7X0Eb1GV1gWnRV+0LiNm8d4ReR +UNQnBJ9nz7BOIU3DdfnQvGu3tffMF7lQY8fBRgGfZFlvyPwfQ+TKvPlzzG3g35E8 +qECq2pzwjPhIgWLMbDDZ9hM60jxVs7FHL4URkd5IZ7ikfX2KTmh+jopYuDp2kEoT +tb1tiA/+xJcZ56csAgFmcX3i+t72Nt6EC6JvEvI6n8ZF6Lm7YOZQ3Ufy8NNRkH8u +EIkCHAQQAQIABgUCVEyEfwAKCRDraqU04MBlHE2mEACFrgwr9u5c/g2MfdKU3ZfN +qzEp1oIdQUECCfD2VlsL0fDoLcV8CcQ4L0KXsEcswo4ox4RzIDuecKAbNRgct++8 +wizfpq3NNI8aja8QAk0JlBvmc/qigGjtdiY/2GqkHQeRkkvc+yRfEWQiVuNOZK81 +Flm/t/h5hE17yV0kDEOIrTrhv7WCPog0ABJG88aM/0Nfw6C2FQ5q32+ExB5+aOnj +8zTuZ3TC0DN9ylDiRqzjpxY2f4RH3POyNB4MnU68tAZlX8G/4SkmjRmRBveblgAL +zNIMQz4EvSKS4ZlbgwTVxa0ghcRCw/nT+86repRdmqBhbxAqL8ONJynoRzDea7wH +LyUBXkqtQD7o8ghs6h880N09j+eJUxuimdlSBxVy42j9xHsE3uPkSsuXC57CjW3I +x+GwILY9pp1C2lkTWvOurmU9Q7iLys/6lCWIHLiwoaZhqIMF3tXZEabUtKOuLCTT +ZIPmIwJy2AehizKtLtmQI9T89nRWKsmfcN+mR9noFb2hqyU+EmVkmD+mPXuhBwAf +xmJMaqeqT3agBaYDwdCbOSrp7jjzl3llxldDFwOgi56vD/GzHuanSdY6RfWpQrCT +km8Vp4czE56pi51UI2f4R4rCuizYqqPcvYLIxi7fosM+WPD+nIIZ9ExC8NTtDNPq +IWviKLMGTq0EqEgHgwpkvYkCHAQQAQgABgUCSuS6xAAKCRDxppvkKcD/7mu/D/4h +fh6yEtn0ZAx+raOGGhuMxuMiJ740eBRL6ZUkgpsXZeWGJFSsb0fAbCHWDlOXBL3P +6UJoO9XL68QOxbBBM4o4X6VsZlRr6PKB3EEe91wjK1E1ixmYTSTyUaOtS9x975sc +ARxZapdJwb9LLA5TTCiDfLk/dgWHKqMlH+rT0+Oqwn9AAO2AsD67xkgBaOpZqQHh +PtoI0S34djMuqcEMgQ8N1MhLwMJcnlJwZKKdhk64SAbhQ+EZuYzn91vNR4tZHoRB +JKi2HGTGZm4h+/s7qcGSXHM9SGCzLMgwI4yo7NSwhRN2vxczWI4Vm6lkgBS2+DHH +mUNSEtavra3doWRfdcePc70tgLZQkK0cAzi8nmX+/aArLdukl+Tz57ICp1fhsFHJ +6phFHssM/9Rq09klogHgrVC95uea7KEis5qOwWWqRm6dUhAcopPPXH3eov99DVpc +KvgtfLLfTd2C6YEbYcCiG6zqY6hJNM9C729UOgKbECmZS9d1XLbIqkFpfFBPEg2R +/O3yhDbH/HkXgm5X+n6dSjV34CssXOm7VqT4eE28qRAkyxxva3toeMroWGTvW7P/ +HLRhpv8cWGWlvaE6m+ntMYm4B5KniBE3Uz5hk+bkJTVtuVEG1nLNTHJdFCY1NTK9 +5rbFYxzKR1e2rux5IZi/zINi1sTA8D1yJJbamUE3u4kCHAQQAQgABgUCS1bKywAK +CRA5ZqJL7E15500ZEACbB+/axpAS1GfBfSyIHOMQRw0Wye70GQFWGF9mVosC1EAE +Mh0fMXlN6MxjeRwOI6l3gQP2Fh4CyYTNbAah539zVTLpgeEZ7zkjN+x0MOebfQ8A +5ao+kPMFyzun2rs8YrUXJspU89Hqx54LGRU3M5f0Q1kYTLJhn+urP2JH/4y2cgFs +j23akKtKS4tou3AgMaQmj9FwpdYmeASIqwNq1qVLoDWU1wDWDSpz+JSXLr0aS+E7 +uyfPhL0NWGEvbvE8/j0KdmxPPVwpuewj7ghfXnianU6MHrnPN5MMnRW2aul6e7Jm +RIUqKfa1uDoeYu8YQnp+YfgR+Aq/d6GVTKx6cU8Rpn4Zmt4boH/IecpZW7cD1vaM +Ry4787d+BiAAQlncxyhXemkr5GVAmN3SPUlpWYfLCSxKoYnPS9etpLVRhO0NlwlQ +4YqB5yM5C5649MSgUxsohTnC3PcqC7GU4EN9lHzw2bEcX5Y+Dc8UABNWu4RxtrI1 +KoipkzfMIBg5uSwVa/4pgd2auVTjWbmuh/qlVXXALRPG6wftwGfTeIHGnQBNThZv +rXtk39fVQ9mi9Jym1hwTYifPSR5UeG96U32a59qXZgVpZ1b5d5HE+0NMrGq0wIDQ +C3PaTMMNenblHWvsjpBfsUssuVe63tqMNQGOhtvKuLKZzX4R5y6AR5BCmzkCyokC +HAQQAQgABgUCS1wdKAAKCRAWKB8uAHyY0drgD/9JFzmEVyrbOJPNDs/MNb1IuxdY +1/0aEWwYeOn6VoaOroGNAe3+tjPFHvwcBcovec6w38HmygnhJDBYG+fjIWPH79oV +EZopcV84r7lYWKL6X2x5ZHs2pgCShZntmvxyDDSUZ20p9mDQrUwWHqm/hCV+pPFg +pwGi253VjuuF0IW8sVyUkZdXVM/eHZ1n5V+TBRWhQ/WllRtqrcVFpjgV5/Hi9C/N +xbGMktPpN0ojrYM+jOIjNzQJpqq7/LaYZ+8zQlTj149W1ks2xHXkgW4o/1c6kWRx +vu4xc2DwvFcN+Q+QNm8HaGRi0rSeyPt/ImojNYfLCjym9SgRpXlOHNBpGBy4GLkJ +tQXGwnEKwL5BV3qyHn5yaBpkUhxlW7Lok9jkzV+3PIIqOYLyr7QObkB8r7sfW8CD +m8vBmSXMyMNU9VoXGRp6RxvQPH24/3CXSAYEHiyZY4i5iDFZ3DqR8HGiFvs2a4l9 +TSHSFU2lrbnX4A9x56Gfz/9b3XKoQ6YmhnXUY9mE6ySk9MqUHALNzwmBqPxt0lZO +IOdw13bJXVGABc1tgRqhQazAhML9efLMNQhua/PJkO8+wcQzihVql1QQjfvWr9DI +nYPYolcPrBM50cyYII/6t4Ygz2biN12G3MMqs0RdVADu8f0WDYUEAGrpeq6f09eu +aeO25zbKRV/dYVyaaYkCHAQQAQgABgUCS11KdwAKCRBQrnCFxr328J79EACMX5bx +Sn2cUNqHHRpFEjdK4+vThwKECA84A5TM/fMiIZl368zunEZHhRZBdLkaCra5WzOD +FVCXiiV9HZsijpow9uulSlaJQQ9oFfJxU/epobIt4QObJ/TIf8mlC+30vq3lDJZE +5RC5rA1pYKkYBk6R2v9Pbyu+K1DCJAYPaoOA/b5ygdTP1WAm9hiL+1p//qAL5L81 +U4mO+LftqOOxq4Vr1PmU0kyt2Yvxbu5ONU9M1DIYGQ33b7WJEIcf3U0MQq9oVYSd +2kqM+UmS8EQ1JBJrv15c8zWuswGJ8tGHt6S5+n3NdG69IhE55EqnSsWIvfRapTTC +pH69D09HjbyjkGPQvgHFXA/AS/ghfaYW4tW18ObSHpoC61hIgdHXU35jWntqWBoG +wyc1L73+5xQzIhoATkWYd4AQT44bE/Hn8n4U3/8sVCAZMI0/u3/7ndEl+D3AGkZf +H3YwUcaCFO9Z1mQxa7DR+msoyzzx0Sa+Xxv/o2LXhZRAzxJisZwvYXSM5ZyujiWt +fv7Kody//iXHrjbZcJequ7aEPAJjjP/F7+X/9KXubNG51JD0BWszIxlD85B1hMBG +WrC5+zgSuNxlM57DpOVM0ZKyrSOKqvPxmdXzv+zObre4uhsrrHIcMQI3uFSFQLvF +d5IIxmjAu6OConIRK6AuicDM8AAhURMvQ+1ecokCHAQQAQgABgUCTD1HfwAKCRDr +XOHXXoUR+e3REACfPv+W7e4maV0uJK/I5DAugtp02xDGDpMftDeyv6z/j0rTow0N +bEi/UYNss1rNnfLgve9DoXy7F0gLL2TE2CAmjPBEF3GOrt8MZSKgHrKdvRZO/3xc +XqPT7+pq6IlbdoWV7AQ3KtLwM5iPFJrMuNaLa9yTZe6ZhgpGKYYEQpNdFNTwKcT2 +wMXrwCJ0eHlvcJD2eGFYaKsuRL6QROsDJUl8/qQP79dodlRqIbNXq6xbP/Umrgly +W8Tgb37gO+/oiwy13g8JFZLfuNgDTJcELSBpyEwdhTNbV+nU/76HcEyZYAwzlgCZ +9UATM8WRYg/Kv1xtEd4MBqTa7L5Hy7vs1YbSKt8hr3UBsRHM2TVXmj/XsntHFJ5k +rz4vltDjztXuxnAXTuq7Mr8pch0xCq2NJlZp66ziMZXuatz8ag/umtjQaNgJja9s +6bHMwkqrKtYRMnKideeuNCmgkfsBkaJNtgpZJJ5fCqYqBGpEFWufRJaMq389ho2f +qp9P6pdCjE7lqxNiqqcDmKpbXNCKcKwwYlm+ctnoSXQJ+z01Zs4yDjByv3cB4tJZ +bXilK2mYwvfVR/4jZHxYMSAqwI70Tc2zBg5x68oKVRBdrdZeybjvFDSqFKGNyKaB +YVVpxEpoSnxphG9hUzpN77GxgOcLuDWE3sweOjyL86fQloyLNslnFm7U4okCHAQQ +AQgABgUCTEkU4gAKCRB8Vqz+lHiX2GPVD/4xdSMTURXKl2slPFXjAjvz9djo3D3t +NLBB2L6jxU06J6GGa7bJBo77r36nlyTDRlzRRN9K/gruRiWqemYc0Lu9HAm/zuZZ +6NqwwQSSrpNH7lnefAZa0zwUmWCGixLogvgCfRuRuUB4AMTInXeZCrPOKkYMJ0+N +waqQREBtIJzih4mtllg3rIA114ctQeduUJbjTjaaLlUeAJ24ZC76RBLDQ6rIXVPR +p5TnmivK7rAP0Rqhax4+MU1Ub9n4IgVfZdFTKumiYZZYJ9mPaunmrdsAFhV0WPuh +sLIweINi7zBIVvwJVhxnq5aUfEW2qWNWAhv0IoDg/PvCOuuX7ANz0yrnmLUbpyEK +UEG5fPST210T/uWJhgb+m/YFxG+Y3HF2TCGV6h4QreUYryCEwl5wa3c7jq76uXJI +pjziFATNBU7Ut4IMpl+4J6MNb8/b1TnbcPfy5SvtXPWWidmK7pNa5f/sONyPZFDG +2qwYPmSRnbf3YvHKA0V+Q9IAuKA38gaCxQFf/+ckMLrP8hGYqJyvnhxYakTEU2EZ +4ATZihiU4J5O6CtDPH7EufD+D5atzWgp26XhYnhFko6TNYgYO48mOx2g6CAkJrRE +YuU0coz7ARTWCXDp3wiQAMYAGKqG0Oq6ua/DY61FfcD8Ao9K2dnJa+yiVkokO8AA +Vd4ehgeQB5P1EYkCHAQQAQgABgUCTO7RuAAKCRC4skwGrBKEBfYUD/4r4jek8x5G +QaY9s2z4N6PBE6iPEhrnlmpEV5dIKpXOfRULbKBa0svvIJuHd3knBDnBU+xZulB1 +THjoO+22nYI2i/MYJ+wYegrlPSf1i80/KMw0Iy2i+fPZD8nUpTCG3vMBAlL/YmGF +iDH9sF7roW0YYYbt1F6DKMksZ+J2oNUrbqOFq+O2au8TcoSSJOlFf1A5UvaGOs6o +AYdH3T1qD5afxANfSTSl3y8SDSCZ8u99GeJ356Rjxk0G6C9/+PW/WcqdZ2oal1g0 +ushymmIe2aAIrUYH50SmzINLwioczoAvF+bDMoUHnoVDLnuk1/ngNaGiymae8L8D +mOc9BOGdEFejGmp0vJL9wV0fxPDPA9WMRJlGO/uT/FEjZTz9mVgbxJQWYFDs9Wap +XU2pX8iydQEwgiBXm0GCiTq/ucgxu4/Isa85onZpZ8Qc9GAgQHUnke9gnN33ybXo +dy2xA2NZI/7NHGDbjtiT6xAoU5wnzV4Qz9miLYRmFfzGOIfkYIevqGzA3jeeGMTa +ifNvX+ymFFc/6y0soF978lvvahzGT7XkTqJgk65gbNy9mqq+fM5KvXOcnYuUx5PG +QWcjL+0oRs1c5PYLOdaXmQgd9p9FPn0/lLid/34DFyG3bmVZABViEJRdx6a2Xejf +b+k3oxJT/TNz51XX7o50PSvnM4viyt6+uokCHAQQAQgABgUCTlmv6AAKCRDq/P6/ +j+uOv/v8D/9qKFnG1SYABoCZaqrA2MdjE54Qq/V4nOm4zUgvAw5u5RYPnxiS7283 +Kb5Pk56EsVXpAzaYYVLWVBGFiz9RJP3Kv1Qgu4RHBjICZpQzP4K9Zl7n2DyHO0Vn +6O4Y3IVb8KNlTBBZId/iQLh9mo4ulXFMBvYdioLRwDWUukldK+Fy+gV5tGfAynuz +y7H/iIa6D/M5y3MluxOUsG98qyT+xux78gpMOy/L2n/tf+ROymoKOgTjDs/miZSk +/KqaLVMFCH5jCJlB9MKKl7F7giGz2DKGdfFjJ1nCb5jpDhjlMMXHxVnlv/wRJOq8 +l+adMdD8Q0MtEFiILpNLnul4qdyJ0MRQyhXhbSKwBnrxlE4Ow3yL5Qgu4cIO/88U +NriHUcPaIbuYjgPjtzcYVi0+0I9e2iqkADkSBU6DCjz8MF2/P6CpjGdA3NIOv9mW +AgMn4AA3+lJVSt563qi+x1ICMQpStvYd6xfqEw8qiUlbnhakA7sPQZWeekxOMKC6 +aws3DB+llsjAvWAUD4mwCUa0C78yhnjacS7Uswp5p8edXblrEt7X8ZFLIHEyki+L +g2BZAAiEZjHSfGDkmoxGoHnej9DrVnUUaXWjRL4AnURWcrHqlsGVYYbQudrpBW91 +u4SKmNyfyWczfUo5zjzwOtt6qrS3nLu8ZMOPC7ufXF+RGaj8CKqDa4kCHAQQAQgA +BgUCTq2IeQAKCRCzRk+JaqFZSHASEACls5V3w8mSEVXol1QmM6k0vzoh7pofO7/L +cjlUDaQC/I3UHMGRnv4aooFZf42ufIDlaRErVhgVOnlb3H0xKSeH9s8rqvcOFBSN +wSqKS64qBeDJZXcu03iIfNhr5CTa2cWKa+7ElEpjrAihWd2OB/KhAsf6Kp8miDr1 +6x9/qjGQDpIPtahcfcJU5ELJ7wZdnecknVpSkFJkT/X1TRLhx2KhhNq/cLZlXXwO +A8BGH+6UncPZQQXQKzt4GM96SW18jNt6xmlR9JQWI495TDfHj8pqqtKfsX8XpjkP +9fh5eej2PV9ydU6QDJL3B2FOD9j36Oj/V2xwKzvPn5+gMNUh+gpDkK10umg0F5Cl +7rZfm5Jbqq+pzk4Ddn1mGqKpfP+QmnLeelbde4ABRTHV/LBxWmbX4x0V+J5XLemT +H3qkzaVqT2ra4GkK5hsNqMxLmgnikZNgMHUodMbVS4qu18Uu6Rfp0le27VQ+EGy3 +L4i4MtsKKoXbzfB5BuHR8Kyp2CXADKbMbSuPvz7xBMzHJ5DTqGSE7dMHDbIQHRYg +d4rYGe063rppEDQOR4hMqNmHghWSSFa9QtO+fiK2WHP17iDUo8NOEZJDGMZgbFeP +w5gLAnsbudmqSEpKrIQeN/W2H6qAPtslD7goU8geFH3lVYVtiHQ50u2wdsfA2oUp +Ba9LzWTM3YkCHAQQAQgABgUCTsRMMgAKCRA5OPlr31D+pRbVEACF4HtCnsS+zp+n +OL0ojBYbazzTBSD/Z1pQ9UiaB4FBmv+OorvBJAbZtK1yyBw2yOXNpJGoPjeOtxCp +x+YHAMH4j7olAaLJEs2eWDYpESefxPBKe8m/+/Pk1SACO4fJJlGTOvbG5SNl2W29 +CWGiNtVeBrV8m+ktIs4+4rll9rY6swyBycOtiFrUgPVORFl0guyACW8SKBNckCqw +y0+kEO6mqtfYLZo7/yDIrOlUNC98K4bnFiz0fPsQTfykF8MV01ELJ4PndFmt6rMi +PyXYvscrsgNjtBxBCucSRNOwFCuM9rx4M+HnD2xJvFpEC2tmGcwp1oIQyB+VFy9G +bBv5xhvIrtZQ3hxBmfp+VrA1zYwY4zvTDQZL+ggt0IPWkA+1ZufX5g1YjUJJKDdZ +DOS0QcRTBmN81fNHeOfKcrIRD91sW43Ze4lgBevOWRsSF4rqZo6YtCXWn+UilbAX +/opEDvOWnVE1ID2stTCMvLHXmzJ9Dz9bSigAZX0i//ROMv9AwRZxcqSGXECErxQw +2gqKT7G6bwWjjK4XHa9BWtby9Tzrv9TleFjxQY0Pf06aC+w5oO59qS8E+y8tWoGQ +cQ8RBRdGzcbYsX1i6x5jndG4r0jfLQ4ZzTeZ+y6T3LqxEz8YbDED4GjsZZDknGnF +HSFhSdvMIOgIoazxsUBaHSMmioYjOokCHAQQAQgABgUCUoY14wAKCRA5NYfZfYZQ +C9/oD/9SGl9/70S7U82JQZo91G2sNzMyXUPe2UhqQ8ASlIFP0fR/RHs1DTMwRlui +fikIgUr5lyZsqo9jXeH8xw1RL+AxqZT+z/4OsuWTEAtWH362YzOfcekzXVxi0GSn +0oHjGg66O7jW90vspDKck0svh5mnr+LVBRcpAjaURDwIWvHSTdAG6bD1glbngo4P +V5SfH5Loto6zKCE7MzHUhg3myxzEt4rqB3DFOALty3n0/nnzEAU5oVhTYVXk4AUI +WO5NM7dFhFgU6oKyUCP4NypCNjQCrPvVp3CUp9ghf18ek0w0BZJFiIYP/BYRSSFw +cdT1lXKOzznPhgZ6L9nnxpitpbTwZklLHj5BhRtVmQeWGFXHYGzdjKci1lvJkFHh +YdisbyXT0BRwZKLQC63r9hHXSL9B2y2bhCkJOTZkTg6+hHGktkAO44uWCd0Oa1gN +beKmc3hlA0Dt1TSVpIAX/b04xKG6iRuO40q8U2qao/ryQuxJOiJEjWw7Z96wvVjz +y9F5BILF69UjrXkL7m3bwfr244pRbaaEjvbeOBLOOYrwmD3B31Obxu+WwDb+Jgb0 +0/qizbAb9l267yjhZ6MVwl+2UKimYZx1j6trJDE34KfEbLoOWXKoq8B7QsK9Wu+s +DYHodl2csPmuhO41xVRl47L02vT3rYGz4jTbKYUJ+4qOE5GI2IkCHAQQAQgABgUC +VG6rpgAKCRCJ6tzjm4DgabANEACA1SV4yIln9tfw+TucEB7ufOQTufLLRKERalKK +Uj6Chl7GyoFC6h/FMsrHXo4Lyr0rkfDS3QxPq2I6MhPxspeMCmyuDBOZvxqd5qUC ++270UhrdFPd9tciKnQtByR6CV8vRCZg8xF9ULoTpzgTb6ut0P7iqDyM7ORJfKNrg +8bOK1L6YfsD/opltKkxgG1Gp4UBo7nwRcGbAsfzGA3BKZUZROubaz0r8AgAAi4Yr +iAIDwCcLH6kZRP1dPWSKi67CvzMTTuJcQF0a9IVA/+Na+s0vvhNdadCRZjeWOjdP +o6KTwvb0Q+G51/GZBqX+aVo5bo2EFHZ4ihw2sGSugQzsK1Nbx32ASgC6zq5nNfbn +5JEu5iyP0e2Mw8LmKlVvympfXr+8s+aSuLYgWZMNBipGje2aoH5Uos2mOot5Z+pM +B91hjcEVxPJ2MKPPCzX2OrfIzTNG7MhIVFz4TQZP0lXwy0uLrwt6tvak8Yl2DWbG +a15FZxh/ysFwKyuDDhyA9vtTpyZVbcoja6FpUgtV5kdUZKEDxXKfGblf5myFrtQr +LZoBrUf63bTxjgHuNW949QLh5+qGjGsufhh0lhAH9rDKbcNzVTBTvwjlWu5A5Pgf +XMyKZMdhMGu4H9O3ORdNtpNc++Qq+ftXHtoPpBzMKIefqQJwCIXT+0SBdkIPaPKR +j5LFfYkCHAQQAQoABgUCS2Rh0QAKCRCMv5oyKGGnkH3sEACiFTUH341j5s8dcveg +Mh5tucUQ730pZXQ31ZJDPSTtmqUAxIWlWGjKsR9AyGb+EoeebweDkbxRtW6IBmI1 +fh0rgnkIuZQTay38t5kuiB/+njfab57hyEjSO90w1oQjEZfTxFw3b9SrKDFCHiKX +xpYSovLqMEnHx7B5FFHutD+iGV2TvORocTzVQvNLeihJZcV6flsFwBfoLi714WHo +y4K+KleW4Cu43SILWueD7NNC1Ik7p6afdzMY210uq9oGb6WCDSPEjEyDk74Jgy/T +btI04KdVkirA76v0abOLsK9bleuyUFO9Wjya7flSDooDIWhkLB8EtS9VMBUKZxw5 +lp4YCFVmEsAonUPcjeayQEKFmqacOWkdS+EG3PwGUN5rUOplK55gAbr9ycWxUlw/ +7fRiAHtm0IKGUDCauHfBKbg2Tji5jz59yRfe0/beNioIWmK3FXYidqqJScg4Jif6 +nVNREzcBoUiBrYzg0LPTQAq/OX5BlfbiLxUXJz51GWa1fbKOVNf+8H8u5ViaWaYn +ZvbQRhY7jPvrDLnWifqVA1LRzkZTxA7O0Fh7DC5GGb/Y2NlbFtnHOPIi2BjJriqo +NJd8KR4n+Ypfj8qh2PhRYXc/5bhzW1Hr3GwZtQtXJm88Sv2QZjmwdOOeX5C27W/O +K7CdH+vDJGCyALuc4qBySqmSm4kCHAQQAQoABgUCTqgMkQAKCRCu9vGip0V2RVEa +EAC0cuUBwYjdeTIJBOY9klKQ+PGdLaGcXahbxuMhTiN4EI76dp86ePH2cnMDizxS +RhU4zXA9Yu1CLsQbg/vpi0AKGOY698h1yPIFAfZe0OVvlhbSPNsy4TzuSwjS/Mad +JBT58vTJpPKtyk0XWpRUqVKrakC2Z2gESIpOisYqrL05E68EZh3JtooOaBaDE0i+ +6DUsDlzdcSVVjEf6xm6WWQBKcdtWrTQOXcInd6qf8hxLfIA+zQk35pAApRAdZdiM +xrOGpuuJe0aqI2NZSg+PJa7Rz4Ss2RRfbCJ04QquA4zsFZXC6axWxbD5u0sxQy9k +tNi2bSS7q8yd6zx5GqyKzOlPADGqbl0UkJ7UlsO26nxJaHBeBKJe2OS//FbRdqhb +k0HJsko5+83uFRvm0u6bXwhaOB4mhXYBAaMfShDCVfH0vjURLl69gtZS2/AG7gVr +ikbi7PWLfEClXePBdH6uUuKxege+6kC8/JUnLdEVa1NhACvAPDkqTk7KXSBVWi+J +EtjJc3PIjUAYhWR1+IhT+GzCid6NygaEvFKPkSZSfOStbB15Md6bpLxqtggCq41K +8A+WEMJhYjIr1bmbCNw9L8nUfYa0+/22EOT+kzx62dIT7PjidiIwnJr2R8WGcIas +qYnTtJLNsW0pnj08eWkxvWT6SREVnSKfENC4NS/390ceAokCHAQQAQoABgUCUIMk +RAAKCRCXMl3Y+f3VBg2qD/466oD3X61gycvWCe0BhwkpmDPE5b14D86f7z5Wket3 +ODlMZu0ySEKKGwuK0+YMRLbPAmLZivt2MavjXqmba9RVEq8kFGw6GUeDf3ZEr82y +5d2wCJVkryB4pdYWe7O7DhOMycPiQPwHU6ZiqH0NXVGnDodtbxkNejLvjcwNTO94 +f4TrZCAJC5lXRyQMmWaTdiRvOyN0q4MhIBshjuCE3UiMzU41WaLG99N410hCHPVo +sBt3NAlp2Jn3Ui5+4c7/wf7M23d/njqDJPKj87+s34frzuf2o915+EsMP4nybGvg +qsa9VEwYxjqsJfRzYfbvtfG2LQQWROSytAMsc03JQ2b1q5Nf90UbYnq/IL2aFlaU +GszcIItd8golL7BYwj19pjwgtbzeIdOhpGYF7sGgz5SNa1FtFdZW+p4Vsv5hiQlP +efO7DdLU4FxVjICizFN9x1dDVKE7PaDrCC75rofJZuE3JMddCs/x4V5WG1ERCmQA +Q6inGIKBSTpURut++PdH7mw/Suhrw70W3CS6qA3/1GMLw5zTiI7AEWsuLkKfVniH +pAKK/mSAvPgP0SkU+YxcOUyz/mtUG2Yq8UZA8Nq9XqvwXjcBbV7dUgE6QaCCM3A1 +g3YKH8tFyTFE6lqb+XUsQtsFm2aUN2fh0Gxyb0UEK9IMyATDLwadojYaKbLOsJrH +u4kCHAQQAQoABgUCUolUeAAKCRB/dgakRdyoDnmDD/9+MwZWKmBbBXpN9/X+W/A7 +GF0eL3TcSb7f29fRPbgzP4AL1zZnNTktpIBfDgtQX5afXeMvEGZvTQGJhQEfCAia +2Ge/Wpg5erLiGuyMtsoXIdMZ/r23zCGGiTiwg0DXkWLTar09FmbRtb/tOcwzxDVo +aCT+1GYwQW6kZmxZAorYgIVgAhJ0fPfDJgTgPkc10aqjKwXpkdcW2Jdw462uFGNp +6W6s2ycWrBDljVOHC8X7XLRUJzMq/2+J5plJN6skfEAkdYdFvxVvrNdfIF/Oqe4d +MXpzy2VuxcW2r2tJeUgIuUZNYLwDTApXxPmD81RjlOu2+uM8pGuKI3gkqizDWdGR +NPRfMq281xPDo/8+k2C0gkSJQ1kXuCDx2L80G/hpepr8sfsUYYUxkjQVULfOK6tP +05X8+tUV5Nl7uxr25MEtvbquZORlBesdHPu3F8CpOvMyXuBE3PVi/dwh4zq4wvoW +dmgaRcso/+EVJcCXJ3KmU3JlGPRNwtLzmvpfeGq3gqwWgb5gZgKX4iS7Mt7bth3A +HevvQe7f6wefLKhrAUVq0DHLhb+zOvdtfMi6iF5/kH16Kymrw77Wriwbci9BDf31 +eTR1Ced+3dfDUZFfTohsSLxjeUb/MhMW+TwQJWYUfXpgNy5rFhz6BgaZS96Fsg9D +mRSsB5ruVjuN6mX4v+UehIkCHAQQAQoABgUCVA54kgAKCRBuYItjfYln6fPkEACJ +MlT4ua3dxGYfOfYXc1KQPJqGIFg5TCREWVPNuJBSIZV5l283WLDsBm12UgeW10sw +Q17U1cqzdNR4ucTUECVH9Zd7thYUFqtdBleGzOkCYnTTYwFqfHwZilrXXgys6Jtn +51l0UYWAziAPdntnhctZ3Tg8z6zYnh6TrlNSCY9Wkgk/2blsSdbMAWWuB969JKYr +lK3u9almpO66BR859OdJWNiI/r8nru7KYilKSMJGO6n4ZNXu+7ltEo7usXE9UesN +zCv3frr1y5xBSoYSB6cLNe8uvoL1ytIIN3Axm1HJShN/8w6NV6Jeq8ryBm/gietz +GXGetvCawrNZDSQyc5LUq1EBOtO1ppDESN2l0vqk3BGGwbLvPhkIad//11Gllo8P +VUewH0p8HLegIiwNFRECQ8mFVxmxGkHcb2T+hePcYe7xI9gf7okyzuTps8G/IAwc +g94S4BsyM26FPBaRVWZf5/CcoAD8udbofGpiBZrlNro70r9KJ+nDh3nghsM+b62J +JPzQoZZjGj9tdtqfjBiLOUWOTxce3a9TNisU090WVCfUjbq7HuPcFjONv0VIHcGF +m1/Qtb+B8rw/XeVGpA/Eo2xBkzEqzEnUt3P9y+vAV9sM5qDigfl1nx8GG7ilS/rz +FSmkuqXy7mbp3gO2vQG9LK9F5ci8rEcyphuypFbiTYkCHAQQAQoABgUCVA58AAAK +CRD7PSWDO2qv+Om2D/kB7Za3bSN9LXFX1+7tyNeW41o1BmR7oKz99viq4y4VPYHX +f7ZgUoCW0ok2FqvYR62XeGvDAMqV+klZdCZVkqlFo6AmAuD4fDzhEZDcS8fsKUnm +HiUklV4ky4SuetEsFkrwZ/Mg7RGblCkqOPc6pv3VX59wgCi9CiDcN342K4tJWTFX +vUJXsZmahy4+QfYDjjPUt1UWcqb4o/NPQtALxSMooCqtLuUl6os9GM85W2CuWU6P +bZTq+3VwaHOM8YbEG9HKNkVYVHPLWqzbf8VvOhTmzL/7Go/QeIVTmcXUG6L2F6Af +mHpXtIfE4GB0irxojoO0WISvkm33b28o9s6Ow+y++gTJJhsmgXHR5fuZJc1hl5MM +DtgWvitIxxR0q/ZbVeSw1pta4XtQvAXjzx5BOfHp06QChe9v8mDMnP6y1HhcdKen +QBvMDTEeTjUKSXw5p1zTPxBErRcGxTKIsLLc/uwC++dfNMSU2/PDbBHMsle9UJne +ePoRKc3H8HZIACUvDj+PSzrYm9b5olPUZQS4/gjQqYYatBlsQKX/fFF84QGNF8ck +4on1lOMNGIMn8CkBtzmVD2Jcnp2DflcNexpWbr/m0dhUlOEeNL74rjC2udbYiDNU +X/lrSwV/JFG70+6UtXLkfVf1tsFQUblZC7Tac4bo/EoEqpvDZTeD1uAfpMCpl4kC +HAQTAQIABgUCTUaIygAKCRAAgG8r1ymkV+DxEACW0KccM1YG3MDsPSLVbSHIoDJS +Rt84tzY6cE5FbraAuzricnZZlVR9NpPbA42/YB4svq8ORgwVkRu4JXIfetZcb2KX +6QaemL3ecjT1kYDgFEn9dE2o2vh8XtDLhhOx9i3UbWYfNdg9T6i/GM9I3AlM6s3L +1NLPZJANIxhQJuWnN8hufim8GlAxNsnvaGBsg7TZmauH6ufpNMqcnju2Dsu/lHWt +nXdTimizCFhTeWZHtfP0+ohVhDXX7Og4aFtpZirWTxrtZxc25EdOSCcYsQcex854 +MHTnC6rC8bw0AyEGGlNZu/mr9NmkTLvv5Zp55IF7twAfpTkMgZSL7ccbEHo7Dc/w +5CNsnDPeVKFG8kwAcNCmVKW1z0FmM6c/YDpVFT4frWaWl/thh83/R4MbEoO30Gks +NLMKCJEgdkuywX/8UwrKUS1TYq5aWPNalZqY2uCUGtpeY4WmhIRTJ470RTph/qug +KvNVUgem8Ta2wKw9qrWQcSpwLJl6P5j2kFTSCStGzx4gALC/GenkHDXHI6sn13Fn +1x0mjnacLdd4Jq9vpb70FOyRIJPTRaW5wvHLuIWVzApeFVM1APuWTl9kcWxjuohk ++EvHbQd8X33OebKGv5jeMHtaAshzNon4ChOkFGczdo0MMdulMlZ7gGnMbvXNzxpf +acy+DJ/pE/uwYGDbzIkCHAQTAQgABgUCUIMlYgAKCRATGO+sX7vbzh6UD/9X1kKl +EoDJiKRmV6SAqWUTnvt/rNzjZ12Y4rbFRAO7YifF1iXUsY7OyUk7DefjW7vK6u83 +sa9MuppMEgdeijamOkR2L8tvgpx77y8IshvxXTtWo8hlSRCX+A0fycTwS1BHD7UW +VdscHKPj7JxXkm0Y2WQp5cbXBfPfK89zst+jB4VdijU5kX0QSOI+y15fRcFOVjJZ +TaFD4gBK6m3r+bSts+YaX233KXjB2wN8932hQ4d2NHcsky/DcfRq5y1wPsSZ0YD6 +9K2a5nUlhy+9LnqMqpAWtWxyhz7SYKebISAwKF/bvIdufZlyxxze6eE6ABVANdJ8 +AO/wNo6kpt7ksmrO17kAPEwv482vb++42HW2dXLcelG5eZzEoyZxLwTx9etLxYow +vutkpH9scSowSBwT9vsk/gLhMvuGqma7BzD3UBn2yr4PLJH+cmyUsSC+1dzHlwwz +j8uloSGm73HI/cVFnVoNijF902H8STyzM5ILa3VjBQyp+Q5bMou1Sjr7IGjDTj09 +elU2Af9SxfXF97W290Qj7oCjAe8RptooHTuX2Mxz8uVfsZ5u6lM0BJIj7jJR4V29 +rzCYzrHOymzWCU4/rtStyAVtazpxBQ80d/m/22U5YznhiAfGmHCb0VBUpK/aTnMq +IvB8iJmi8zn7rMJNJYQHJ1WeT2sZko+LGldyoYkCNwQTAQgAIQUCSi3D+wIbAwUL +CQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRAYFHsHO60rB+YJD/43EvVWoWtszVx2 +Y6Mh7IbzKxAFh03i/em9xlI+I7K1WSdoixk5YBuGsLsgW07gt0NuZPcwRruy9AzN +uI3kHckdaUOC6trodKoATRDpzTlleEAu75qynPY8YFT3wRjSIAkrxYQU3eCUWQt5 +QkAf0VTlYqj50n7D60zK8NNp74gqtYBWiK0wI++vjh6dnUHYKHiC2a6WAAaXJkX6 +4DjAeR96c4oe4EUFRmc7iYflaWgMb0mVgtbRSF8c5dlsCmvDXZPFc5uEhAHZgOZu +8TunX0MY3w1Ldj1x+RNDfb6MjstHM+RJF+BpI3lMbFe0uaL3LyrQmHv3mI7Ua9LX +fPRkhgC/zhgX3+0RRIfKgjhG3FeCcyVsssTb4VffZ8HV0jUfWuJYg+lMEMAMPjsA +VkDnJV9c0OtiMB090YjbhJm71ABViOv8l7aY2M9UETicDLD8jyKQqNDfxRUSX+QW +6EyhgY6YccKtPknjN8hmT+uQ9LoHeLjl8YEJtKLfdLDIKR0R8s8OfaAvVy0b/nm2 +mlRa6kb28FultZlgh03olCQC3E/Ay3kNL5amtr5I108rnh7LQbOJRLFMq9WPK2vO +DDix0sMQ18mjuyDDG5JU3BfmGUAUZDOLR/Q8zZ7MY7EdMXyMx/njlbf5bbL06pIc +uwHVwkOyzBgXvIB9ATQPqk2iee/vvrkCDQRKLcWAARAAsITBKoXY9UIk1TWFwe9T +nHoFnmIfuuNW33Zk1lrGF26pkDyVrnnHobDNbZlDnyE4Dw0hIbfOV+y3B6dCL/Uy +sAIYbCxqewGfaSEpMd9Sm7elb4vUI+MG/GLa53dKlw/U1lZ7ogWdPormwi//Gkax +EWzsRBlO3dztvsakBx7I7wEq2t9zUYZnvNUFMuN/gUZetOUemeFKL3JyOrD6m+PM +uANOroxs4N44Jb+ia0P/U19YiiEViPsPKtq8OMo7mE21qF6CNS5asCwZ+tQIMhLH +OiqlkLjkWvSue2VnQm2TT3dahOFmxJZ7fBNglTL9FQEFysn7fk4qAMuRKJjRJoip +PmLVciTGv9HIdmjroElygpdqiHD9NsC8nfp7iUKB9siWbqgaE+MoCPOb67z6TKRR +EQCVO+aWtp9L1iz1yw0ZBfWJDR8V2hpXbGFiplmCzRXpt3attWvSk69Q+NPKnMGy +maqe0Xafi3weBSeJ5vnNV+6mlomNx6+HsiFauzlkRFOl0wdBvB7X3hNgQDP0BxFM +HeVLe/GY9YC9pcjJRmilzaTKRQxrm8ZYt/QqZ5IYomXJm/Al0Gl/Ei2skDXAXk8Y +LyRE3FZuj8o52cnorUkNyrRrA+b+w622NrqNW7GU/f8e9U1HoDgHdiNqo6ZJOw0b +2+jcNjzNl2CKkLVfng8hwUUAEQEAAYkCHwQYAQgACQUCSi3FgAIbDAAKCRAYFHsH +O60rB7qQEACHtZsw+yRgyYou9wFVvyIG0K+R0D6ztYxHOPjwjAhZ470v3z6k95nt +xN91SK614BlHuoMc4rt+3dejdkTlcddJHmT3KVTYuF+N4pjMArCTP1PrBTXMUYUH +8+k90TflFHqn3LBEMJG1Z8/SjkvnbhOIL9k1buM7UEScNVzCmEMMoUMpfufXX4k9 +D3yqteywOmam0kJUzfJFAwnAh7dVF5F/GCBHfOSrEZDCNTiwqg2gmtrn3k+H83Kx +pp9br4G39a3YIVdWq5Kx6wk62AXLE8qBFZ8ta2GEJZeyjlYYJzXJdu3yhc5IVjWi +DCc4Jsn9XTQ8Efy+lnSktV2w6UKeTRfnVVTPAs2d1Wcqjyc5lbes8OoJWKcP43Az +I5gr9dwS4Wy9J3lOhmw4gPySiP22MgUGLGBpY76DdZDPCJya++WSY1YKrlt3BqJv +G2ODzXnlbdn49YR1k4eL/CTnt+/tGWmTlrUsrcZidXY+3g/xW7VJkO/g58kNu7w2 +S9BDPTVCzlXeoYS64J4oCbA9pyu45N/ZbSjVKZQL09XCh2hHFwt8rVlYhMMdk5GW +oL6kxz+bixHBLE7RfpSkafk2HdXwL84zNBjI2gaKvY+bzCxAubbhWlGJ1b0aps5y +pmeqyzCnc5E1mTvcWByYOBEjJk5peo5Vnzh4DCLB/fa15JDUzF7cFw== +=NjhQ +-----END PGP PUBLIC KEY BLOCK----- diff --git a/xapian-core.spec b/xapian-core.spec new file mode 100644 index 0000000..fa6f316 --- /dev/null +++ b/xapian-core.spec @@ -0,0 +1,185 @@ +# +# spec file for package xapian-core +# +# Copyright (c) 2024 SUSE LLC +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + + +Name: xapian-core +Version: 1.4.22 +Release: 0 +Summary: The Xapian Probabilistic Information Retrieval Library +License: GPL-2.0-only +Group: Productivity/Databases/Servers +URL: https://xapian.org/ +Source0: https://www.oligarchy.co.uk/xapian/%{version}/%{name}-%{version}.tar.xz +Source1: https://www.oligarchy.co.uk/xapian/%{version}/%{name}-%{version}.tar.xz.asc +Source2: %{name}.keyring +Source3: baselibs.conf +BuildRequires: automake +BuildRequires: fdupes +BuildRequires: gcc-c++ >= 4.6 +BuildRequires: libuuid-devel +BuildRequires: pkg-config +BuildRequires: xz +BuildRequires: zlib-devel +Requires: libxapian30 = %{version} +BuildRoot: %{_tmppath}/%{name}-%{version}-build + +%description +Xapian is a Probabilistic Information Retrieval library. It offers an +adaptable toolkit for adding indexing and search facilities to +applications. + +%package -n libxapian30 +Summary: Xapian search engine libraries +Group: System/Libraries + +%description -n libxapian30 +Xapian is a Probabilistic Information Retrieval library. It offers an +adaptable toolkit for adding indexing and search facilities to +applications. + +%package -n libxapian-devel +Summary: Files needed for building packages which use Xapian +Group: Development/Libraries/C and C++ +Requires: gcc-c++ +Requires: libuuid-devel +Requires: libxapian30 = %{version} +Requires: zlib-devel + +%description -n libxapian-devel +Xapian is a Probabilistic Information Retrieval library. It offers an +adaptable toolkit for adding indexing and search facilities to +applications. + +This subpackage contains the header files for the library. + +%package doc +Summary: Documentation for the xapian-core libraries +Group: Documentation/HTML +Requires: %{name} = %{version} + +%description doc +Xapian is a Probabilistic Information Retrieval library. + +This subpackage provides the documentation for Xapian. + +%package examples +Summary: Examples for Xapian-core libraries +Group: Development/Libraries/C and C++ +Requires: %{name} = %{version} + +%description examples +Xapian is a Probabilistic Information Retrieval Library. + +This subpackage contains some examples for Xapian. + +%prep +%setup -q + +%build +%configure \ +%ifarch i586 + --disable-sse \ +%endif + --docdir=%{_docdir}/%{name}/ + +make %{?_smp_mflags} + +%install +make DESTDIR=%{buildroot} docdatadir=%{_docdir}/%{name} install %{?_smp_mflags} +rm -rf examples/{.libs,.deps,.dirstamp,*.o,quest,delve,simplesearch,simpleexpand,simpleindex,copydatabase,xapian-metadata,xapian-pos} +cp -vr examples %{buildroot}%{_docdir}/%{name}/ +find . -name \*.spec -delete +install -m 644 AUTHORS ChangeLog README NEWS HACKING PLATFORMS ChangeLog.examples %{buildroot}%{_docdir}/%{name} +# SLE12 support needs to copy this manually, since %doc would include the examples subdirectory too +%if 0%{suse_version} < 1500 && !0%{?is_opensuse} +install -m 644 COPYING %{buildroot}%{_docdir}/%{name} +%endif +%fdupes %{buildroot}%{_docdir}/%{name} + +%post -n libxapian30 -p /sbin/ldconfig + +%postun -n libxapian30 -p /sbin/ldconfig + +%files +%defattr(-, root, root) +%dir %{_docdir}/%{name} +%if 0%{suse_version} < 1500 && !0%{?is_opensuse} +%{_docdir}/%{name}/COPYING +%else +%license COPYING +%endif +%{_docdir}/%{name}/AUTHORS +%{_docdir}/%{name}/ChangeLog +%{_docdir}/%{name}/README +%{_docdir}/%{name}/NEWS +%{_docdir}/%{name}/HACKING +%{_docdir}/%{name}/PLATFORMS +%{_bindir}/xapian-tcpsrv +%{_bindir}/xapian-progsrv +%{_bindir}/quest +%{_bindir}/copydatabase +%{_bindir}/simpleindex +%{_bindir}/simplesearch +%{_bindir}/simpleexpand +%{_bindir}/xapian-compact +%{_bindir}/xapian-check +%{_bindir}/xapian-delve +%{_bindir}/xapian-metadata +%{_bindir}/xapian-pos +%{_bindir}/xapian-replicate +%{_bindir}/xapian-replicate-server +%{_mandir}/man1/xapian-check.1* +%{_mandir}/man1/xapian-delve.1* +%{_mandir}/man1/copydatabase.1* +%{_mandir}/man1/quest.1* +%{_mandir}/man1/xapian-compact.1* +%{_mandir}/man1/xapian-config.1* +%{_mandir}/man1/xapian-progsrv.1* +%{_mandir}/man1/xapian-tcpsrv.1* +%{_mandir}/man1/xapian-metadata.1* +%{_mandir}/man1/xapian-pos.1* +%{_mandir}/man1/xapian-replicate.1* +%{_mandir}/man1/xapian-replicate-server.1* +%{_datadir}/xapian-core/ + +%files -n libxapian30 +%defattr(-, root, root) +%{_libdir}/libxapian.so.* + +%files -n libxapian-devel +%defattr(-, root, root) +%{_bindir}/xapian-config +%{_includedir}/xapian +%{_includedir}/xapian.h +%{_libdir}/libxapian.so +%{_libdir}/libxapian.la +%{_datadir}/aclocal/xapian.m4 +%dir %{_libdir}/cmake/ +%{_libdir}/cmake/xapian/ +%{_libdir}/pkgconfig/xapian-core.pc + +%files doc +%defattr(-, root, root) +%{_docdir}/%{name}/*.html +%{_docdir}/%{name}/apidoc* + +%files examples +%defattr(-, root, root) +%{_docdir}/%{name}/ChangeLog.examples +%{_docdir}/%{name}/examples/ + +%changelog