From 0519bb92d1eb9afc045d6fe2acc83b2290a0d126 Mon Sep 17 00:00:00 2001 From: zyppe <210hcl@gmail.com> Date: Wed, 7 Feb 2024 23:12:20 +0800 Subject: [PATCH] Initialize for grep --- .gitignore | 1 + .grep.metadata | 1 + grep-3.1.tar.xz.sig | 16 + grep.changes | 590 +++++++++++++++++++++++++++ grep.keyring | 972 ++++++++++++++++++++++++++++++++++++++++++++ grep.spec | 91 +++++ profile.sh | 14 + testsuite.patch | 26 ++ 8 files changed, 1711 insertions(+) create mode 100644 .gitignore create mode 100644 .grep.metadata create mode 100644 grep-3.1.tar.xz.sig create mode 100644 grep.changes create mode 100644 grep.keyring create mode 100644 grep.spec create mode 100644 profile.sh create mode 100644 testsuite.patch diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1c08386 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +grep-3.1.tar.xz diff --git a/.grep.metadata b/.grep.metadata new file mode 100644 index 0000000..5c7f788 --- /dev/null +++ b/.grep.metadata @@ -0,0 +1 @@ +dddd7c9985dff6354c150f8f30d590dceaa9f34f5864b6380a7e5908c06da809 grep-3.1.tar.xz diff --git a/grep-3.1.tar.xz.sig b/grep-3.1.tar.xz.sig new file mode 100644 index 0000000..8eca9ca --- /dev/null +++ b/grep-3.1.tar.xz.sig @@ -0,0 +1,16 @@ +-----BEGIN PGP SIGNATURE----- + +iQIzBAABCgAdFiEEFV0/xQDINEhtHupnf9n8ywAL7u4FAllZVmwACgkQf9n8ywAL +7u4xhA//XVPhqEAX90n4sj+iH5KzWOD5g6Sg+Yac6QlCv4t9wlacl+bFsD3tyzBV +RU4yumS4PRONSsQKcFgdwv8/8hGLzq/LthKLN4hOWG28EOJGYPBSqloq+/wNtRLO +6L96aU+D/S/IyREkvIxl/aRnX+3itw4dw7GIrAUi2Mv+yZ5922KmLwwAz57VxWVy +aIU+tznzXWmnXguuIU4xkNd9ZO1veC6FgVaaFdonIwqDSUcN1grk2uwEtNu9V1uZ +PNdxoOJJErrkVmxi4V+nf2DAa15JchKzcdc8r5Ot8C/hPvjf6pDdvs6MdJvnQq/1 +ihxwpts2IeVdAi7Ww6S6/injfMdiU2PAVDYjS4GTV8OKfsIkjkbtt4GMLlIvSG9Q +VHnlSVJKG79Ms81cciHpA9vUt7nqsbJTov+xNgj+IUSRtvOy92xHUA1RsqGcUS4k +IS4J2wzx1TInh3OetK/7AAKQ1Q+xUdIqVUe60bvVX4Bw3Gjdpausvwa2Q8jqIxjM +fu7zLdUtdToYJLFc/YlQvZjvn9LmrlSQmkiZurBr+EGPEB2lhZveIlkmGY/RX7LN +7VIKCKGZZ4tIMzKTyANetDa8NavSfjRlM4E8X2/qn+1SJaNzk6ggOSfdu6+GLLcW +Mjm+Fsf99/EzJ5+fk0aUdVkrmsASY0EdetxAQfPhdaHtcv+u9HM= +=lqPi +-----END PGP SIGNATURE----- diff --git a/grep.changes b/grep.changes new file mode 100644 index 0000000..4c1f498 --- /dev/null +++ b/grep.changes @@ -0,0 +1,590 @@ +* Thu Mar 17 2022 bwiedemann@suse.com +- Make profiling deterministic (bsc#1040589, SLE-24115) +* Thu Dec 19 2019 schwab@suse.de +- Update testsuite expectations, no functional changes (bsc#1155271) +* Thu Feb 22 2018 fvogt@suse.com +- Use %%license (boo#1082318) +* Mon Jul 3 2017 schwab@suse.de +- Update to grep 3.1 + * grep '[0-9]' is now just as fast as grep '[[:digit:]]' when run + in a multi-byte locale + * Context no longer excludes selected lines omitted because of -m +* Thu Jun 1 2017 mpluskal@suse.com +- Use https url's +- Drop no longer needed explicit pie +- Enable profiled build +* Sat Feb 11 2017 mpluskal@suse.com +- Update to version 3.0: + * grep without -F no longer goes awry when given two or more + patterns that contain no special characters other than '\' and + also contain a subpattern like '\.' that escapes a character to + make it ordinary. + * grep no longer fails to build on PCRE versions before 8.20. +- Cleanup spec file: + * Drop support for old distributions + * Create lang subpackage + * Use fdupes to replace duplicate files with symlinks +* Wed Feb 8 2017 mpluskal@suse.com +- Update to version 2.28: + * Improve performance for -E or -G pattern lists that are easily + converted to -F format. + * Fix performance regression with multiple patterns. + * When standard output is /dev/null, grep no longer fails when + standard input is a file in the Linux /proc file system, or when + standard input is a pipe and standard output is in append mode. + * When grep -Fo finds matches of differing length, it could + mistakenly print a shorter one. Now it prints a longest one. +- Drop upstreamed proc-lseek-glitch.patch +* Mon Dec 12 2016 schwab@suse.de +- testsuite.patch: remove +- proc-lseek-glitch.patch: work around proc lseek glitch +* Wed Dec 7 2016 schwab@suse.de +- Update to grep 2.27 + * grep no longer reports a false match in a multibyte, non-UTF8 locale + like zh_CN.gb18030, with a regular expression like ".*7" that just + happens to match the 4-byte representation of gb18030's \uC9, the + final byte of which is the digit "7". + * grep by default now reads all of standard input if it is a pipe, + even if this cannot affect grep's output or exit status. + * grep no longer mishandles ranges in nontrivial unibyte locales. + * grep -P no longer attempts multiline matches. + * grep -m0 -L PAT FILE now outputs "FILE". + * To output ':' and tab-align the following character C, grep -T no + longer outputs tab-backspace-':'-C, an approach that has problems if + run inside an Emacs shell window. + * grep -T now uses worst-case widths of line numbers and byte offsets + instead of guessing widths that might not work with larger files. + * grep no longer reads the input in a few more cases when it is easy to + see that matching cannot succeed, e.g., 'grep -f /dev/null'. +* Fri Oct 28 2016 astieger@suse.com +- grep 2.26: + * no longer omit output merely because it follows an output line + suppressed due to encoding errors + * In the Shift_JIS locale, no longer mistakenly match in the + middle of a multibyte character + * grep can be much faster now when standard output is /dev/null. + * grep -F is now typically much faster when many patterns are + given, as it now uses the Aho-Corasick algorithm instead of + the Commentz-Walter algorithm in that case. + * grep -iF is typically much faster in a multibyte locale, if + the pattern and its case counterparts contain only single byte + characters. + * grep with complicated expressions (e.g., back-references) and + without -i now uses the regex fastmap for better performance. + * In multibyte locales, grep now handles leading "." in patterns + more efficiently. + * grep now prints a "FILENAME:LINENO: " prefix when diagnosing + an invalid regular expression that was read from an + '-f'-specified file. +* Fri Apr 22 2016 astieger@suse.com +- grep 2.25: + * In the C or POSIX locale, grep now treats all bytes as valid + characters even if the C runtime library says otherwise. + ( Fixes yast2-users and other build failures - boo#966780 ) + * grep -oz now uses null bytes, not newlines, to terminate output + lines. + * grep now outputs details more consistently when reporting a + write error. +* Fri Mar 11 2016 mpluskal@suse.com +- Update to 2.24 + * grep -z would match strings it should not. To trigger the bug, + you'd have to use a regular expression including an anchor + (^ or $) and a feature like a range or a backreference, causing + grep to forego its DFA matcher and resort to using re_search. + With a multibyte locale, that matcher could mistakenly match a + string containing a newline. For example, this command: + printf 'a\nb\0' | LC_ALL=en_US.utf-8 grep -z '^[a-b]*b' + would mistakenly match and print all four input bytes. After + the fix, there is no match, as expected. + [bug introduced in grep-2.7] + * grep -Pz now diagnoses attempts to use patterns containing ^ + and $, instead of mishandling these patterns. This problem + seems to be inherent to the PCRE API; removing this limitation + is on PCRE's maint/README wish list. Patterns can continue to + match literal ^ and $ by escaping them with \ (now needed even + inside [...]). [bug introduced in grep-2.5] +* Fri Feb 5 2016 mpluskal@suse.com +- Update to 2.23 + * Binary files are now less likely to generate diagnostics and + more likely to yield text matches. grep now reports "Binary + file FOO matches" and suppresses further output instead of + outputting a line containing an encoding error; hence grep can + now report matching text before a later binary match. + Formerly, grep reported FOO to be binary when it found an + encoding error in FOO before generating output for FOO, which + meant it never reported both matching text and matching binary + data; this was less useful for searching text containing + encoding errors in non-matching lines. [bug introduced in + grep-2.21] + * grep -c no longer stops counting when finding binary data. + [bug introduced in grep-2.21] + * grep no longer outputs encoding errors in unibyte locales. For + example, if the byte '\x81' is not a valid character in a + unibyte locale, grep treats the byte as binary data. [bug + introduced in grep-2.21] + * grep -oP is no longer susceptible to an infinite loop when + processing invalid UTF8 just before a match. [bug introduced in + grep-2.22] + * --exclude and related options are now matched against trailing + parts of command-line arguments, not against the entire + arguments. This partly reverts the --exclude-related change + in 2.22. [bug introduced in grep-2.22] + * --line-buffer is no longer ineffective when combined with -l. + [bug introduced in grep-2.5] + * -xw is now equivalent to -x more consistently, with -P and + with backrefs. [bug only partially fixed in grep-2.19] +- Update info handling scriplets + * move from postun to preun + * add dependeny for preun +- Refresh partially upstreamed patch + * testsuite.patch +* Thu Nov 26 2015 schwab@suse.de +- testsuite.patch: also disable long-pattern-perf test +* Tue Nov 3 2015 schwab@suse.de +- testsuite.patch: disable unreliable test mb-non-UTF8-performance +* Mon Nov 2 2015 astieger@suse.com +- GNU grep 2.22: + * Improve performance for patterns containing very long strings + * Output and pattern matching bug fixes +- drop add gnulib-perl522.patch, changed upstream +- drop grep-F-heap-overrun.patch, included upstream +* Mon Jul 6 2015 coolo@suse.com +- add gnulib-perl522.patch from gnulib.bugs +* Mon Jan 26 2015 schwab@suse.de +- grep-F-heap-overrun.patch: fix heap overrun with grep -F (CVE-2015-1345, + bsc#914695) +* Mon Jan 12 2015 schwab@suse.de +- Fix last change +* Tue Dec 30 2014 meissner@suse.com +- build with PIE enabled +* Fri Nov 28 2014 andreas.stieger@gmx.de +- GNU grep 2.21 +- Improvements: + * performance improved for searching files containing holes, on + platforms where lseek's SEEK_DATA flag works efficiently. + * performance improved for rejecting data that cannot match even + the first part of a nontrivial pattern. + * performance improved for very long strings in patterns. + * If a file contains data improperly encoded for the current + locale, and this is discovered before any of the file's contents + are output, grep now treats the file as binary. + * -P no longer reports an error and exits when given invalid UTF-8 + data. Instead, it considers the data to be non-matching. +- Bug fixes: + * fix issues in multibyte locales + * grep -F -x -o no longer prints an extra newline for each match. + * grep in a non-UTF8 multibyte locale could mistakenly match in + the middle of a multibyte character when using a '^'-anchored + alternate in a pattern, leading it to print non-matching lines. + * grep -F Y no longer fails to match in non-UTF8 multibyte locales + * grep -E rejected unmatched ')', instead of treating it like '\)'. +- Changes in behavior: + * The GREP_OPTIONS environment variable is now obsolescent + * In locales with multibyte character encodings other than UTF-8, + grep -P now reports an error and exits instead of misbehaving. + * When searching binary data, grep now may treat non-text bytes as + line terminators. This can boost performance significantly. + * grep -z no longer automatically treats the byte '\200' as + binary data. +* Sat Jun 7 2014 andreas.stieger@gmx.de +- GNU grep 2.20 +- Bug fixes: + * grep --max-count=N FILE would no longer stop reading after the + Nth match. I.e., while grep would still print the correct + output, it would continue reading until end of input, and + hence, potentially forever. [introduced in 2.19] + * A command like echo aa|grep -E 'a(b$|c$)' would mistakenly + report the input as a matched line. [introduced in 2.19] +- Changes in behavior: + * grep --exclude-dir='FOO/' now excludes the directory FOO. + Previously, the trailing slash meant the option was + ineffective. +* Sat May 24 2014 andreas.stieger@gmx.de +- GNU grep 2.19 +- Improvements: + * Performance has improved, typically by 10%% and in some cases by + a factor of 200. However, performance of grep -P in UTF-8 + locales has gotten worse as part of the fix for the crashes + mentioned below. +- Bug fixes: + * grep no longer mishandles patterns like [a-[.z.]], and no + longer mishandles patterns like [^a] in locales that have + multicharacter collating sequences so that [^a] can match a + string of two characters. + * grep no longer mishandles an empty pattern at the end of a + pattern list. + * grep -C NUM now outputs separators consistently even when NUM + is zero, and similarly for grep -A NUM and grep -B NUM. + * grep -f no longer mishandles patterns containing NUL bytes. + * Plain grep, grep -E, and grep -F now treat encoding errors in + patterns the same way the GNU regular expression matcher treats + them, with respect to whether the errors can match parts of + multibyte characters in data. + * grep -w no longer mishandles a potential match adjacent to a + letter that takes up two or more bytes in a multibyte encoding. + Similarly, the patterns '\<', '\>', '\b', and '\B' no longer + mishandle word-boundary matches in multibyte locales. + * grep -P now reports an error and exits when given invalid UTF-8 + data. Previously it was unreliable, and sometimes crashed or + looped. + * grep -P now works with -w and -x and backreferences. Before, + echo aa|grep -Pw '(.)\1' would fail to match, yet + echo aa|grep -Pw '(.)\2' would match. + * grep -Pw now works like grep -w in that the matched string has + to be preceded and followed by non-word components or the + beginning and end of the line (as opposed to word boundaries + before). Before, this + echo a@@a| grep -Pw @@ would match, yet this + echo a@@a| grep -w @@ would not. Now, they both fail to match, + per the documentation on how grep's -w works. + * grep -i no longer mishandles patterns containing titlecase + characters. For example, in a locale containing the titlecase + character 'Lj' (U+01C8 LATIN CAPITAL LETTER L WITH SMALL LETTER + J), 'grep -i Lj' now matches both 'LJ' (U+01C7 LATIN CAPITAL + LETTER LJ) and 'lj' (U+01C9 LATIN SMALL LETTER LJ). +- remove mb-non-UTF8-performance.patch, committed upstream +* Tue Mar 25 2014 schwab@suse.de +- mb-non-UTF8-performance.patch: make performance-measuring less + system-sensitive +* Sat Feb 22 2014 andreas.stieger@gmx.de +- GNU grep 2.18 + * no longer mishandles patterns like [^^-~] in unibyte locales + * -i in a multibyte, non-UTF8 locale could be up to 200 times + slower than in 2.16 +* Wed Feb 19 2014 mvyskocil@suse.com +- update to 2.17 + * grep -i in a multibyte locale is now typically 10 times faster + for patterns that do not contain \ or [ + * grep (without -i) in a multibyte locale is now up to 7 times faster + when processing many matched lines + * grep's --mmap option was disabled in March of 2010, and began to + elicit a warning in January of 2012. Now it is completely gone. +- Reformat spec file using hints from spec-cleaner +* Sun Jan 5 2014 andreas.stieger@gmx.de +- update to 2.16 + * Fix gnulib-provided maint.mk to report correct version number + * The fix to make \s and \S work with multi-byte white space + broke the use of each shortcut whenever followed by a repetition + operator. For example, \s*, \s+, \s? and \s{3} would all + malfunction in a multi-byte locale. + * The fix to make grep -P work better with UTF-8 made it possible + for grep to evoke a larger set of PCRE errors, some of which + could trigger an abort. E.g., this would abort: + printf '\x82'|LC_ALL=en_US.UTF-8 grep -P y + Now grep handles arbitrary PCRE errors + * Handle very long lines (2GiB and longer) on systems with a + deficient read system call. +- removed patches: + * grep-gnulib-ppc64le.patch, upstream source removed +* Mon Dec 23 2013 coolo@suse.com +- don't drag texlive into bootstrap cycle - makeinfo is enough +* Fri Dec 20 2013 uweigand@de.ibm.com +- grep-gnulib-ppc64le.patch: Fix imported gnulib long double math + tests for little-endian PowerPC. +* Wed Dec 11 2013 andreas.stieger@gmx.de +- Update to 2.15: + Bug fixes: + * grep's \s and \S failed to work with multi-byte white space + characters. + * grep -i would segfault on systems using UTF-16-based wchar_t + when converting an input string containing certain 4-byte UTF-8 + sequences to lower case. + * grep -E would segfault when given a regexp like + '([^.]*[M]){1,2}' for any multibyte character M. + * grep -F would get stuck in an infinite loop when given a search + string that is an invalid byte sequence in the current locale + and that matches the bytes of the input twice on a line. Now + grep fails with exit status 1. + * grep -P could misbehave. + New features: + * grep -P can now use a just-in-time compiler to greatly speed up + matches, This feature is transparent to the user; no flag is + required to enable it. It is only available if the + corresponding support in the PCRE library is detected when grep + is compiled. +- require xz for SLE +- require texinfo for makeinfo +- don't autoreconf +- remove the added german translations, upstream is up-to-date +* Wed Mar 27 2013 mmeister@suse.com +- Added url as source. + Please see http://en.opensuse.org/SourceUrls +* Fri Aug 24 2012 pth@suse.de +- Update to 2.14: + Bug fixes: + * grep -i '^$' could exit 0 (i.e., report a match) in a multi-byte + locale, even though there was no match, and the command generated + no output. E.g., seq 2 | LC_ALL=en_US.utf8 grep -il '^$' would + mistakenly print "(standard input)". Related, seq 9 | + LC_ALL=en_US.utf8 grep -in '^$' would print "2:4:6:8:10:12:14:16" + and exit 0. Now it prints nothing and exits with status of 1. + [bug introduced in grep-2.6] + * 'grep' no longer falsely reports text files as being binary on + file systems that compress contents or that store tiny contents + in metadata. +- Add current German message catalog from the translation project. +* Thu Jul 5 2012 jsmeix@suse.de +- Update to 2.13: + It's moderately important to upgrade from grep-2.6 or newer, + since a Turkish I-with-dot (U+0130) on a matched/printed line + makes "grep -i" (in nearly any UTF-8 locale) emit corrupt output. + Bug fixes: + * grep -i, in a multi-byte locale, when matching a line + containing a character like the UTF-8 Turkish I-with-dot + (U+0130) (whose lower-case representation occupies fewer + bytes), would print an incomplete output line. Similarly, + with a matched line containing a character (e.g., the Latin + capital I in a Turkish UTF-8 locale), where the lower-case + representation occupies more bytes, grep could print garbage. + [bug introduced in grep-2.6] + * --include and --exclude can again be combined, and again + apply to the command line, e.g., "grep --include='*.[ch]' + - -exclude='system.h' PATTERN *" again reads all *.c + and *.h files except for system.h. + [bug introduced in grep-2.6] + New features: + * 'grep' without -z now treats a sparse file as binary, + if it can easily determine that the file is sparse. + Dropped features: + * Bootstrapping with Makefile.boot has been broken since + grep 2.6, and was removed. +* Mon May 21 2012 tabraham@novell.com +- Update to 2.12: + * "echp P|grep --devices=skip P" once again prints P, as it did in + 2.10 [bug introduced in grep-2.11] + * grep no longer segfaults with -r --exclude-dir and no file + operand. I.e., ":|grep -r --exclude-dir=D PAT" would segfault. + [bug introduced in grep-2.11] + * Recursive grep now uses fts for directory traversal, so it can + handle much-larger directories without reporting things like + "Filename too long", and it can run much faster when dealing + with large directory hierarchies. [bug present since the + beginning] + * grep -E 'a{1000000000}' now reports an overflow error rather + than silently acting like grep -E 'a\{1000000000}'. + * The -R option now has a long-option alias --dereference-recursive. + * The -r (--recursive) option now follows only command-line + symlinks. Also, by default -r now reads a device only if it is + named on the command line; this can be overridden with --devices. + - R acts as before, so use -R if you prefer the old behavior of + following all symlinks and defaulting to reading all devices. +* Thu Apr 19 2012 meissner@suse.de +- use -mlong-double-64 on ppc* +* Tue Mar 13 2012 tabraham@novell.com +- Update to 2.11: + * grep no longer dumps core on lines whose lengths do not fit in + 'int'. (e.g., lines longer than 2 GiB on a typical 64-bit host). + Instead, grep either works as expected, or reports an error. + An error can occur if not enough main memory is available, or if + the GNU C library's regular expression functions cannot handle + such long lines. [bug present since "the beginning"] + * The -m, -A, -B, and -C options no longer mishandle context line + counts that do not fit in 'int'. Also, grep -c's counts are now + limited by the type 'intmax_t' (typically less than 2**63) rather + than 'int' (typically less than 2**31). + * grep no longer silently suppresses errors when reading a directory + as if it were a text file. For example, "grep x ." now reports a + read error on most systems; formerly, it ignored the error. + [bug introduced in grep-2.5] + * grep now exits with status 2 if a directory loop is found, instead + of possibly exiting with status 0 or 1. [bug introduced in + grep-2.3] + * The -s option now suppresses certain input error diagnostics that + it formerly failed to suppress. These include errors when closing + the input, when lseeking the input, and when the input is also the + output. [bug introduced in grep-2.4] + * On POSIX systems, commands like "grep PAT < FILE >> FILE" now report + an error instead of looping. [bug present since "the beginning"] + * The --include, --exclude, and --exclude-dir options now handle + command-line arguments more consistently. --include and --exclude + apply only to non-directories and --exclude-dir applies only to + directories. "-" (standard input) is never excluded, since it is + not a file name. [bug introduced in grep-2.5] + * grep no longer rejects "grep -qr . > out", i.e., when run with -q + and an input file is the same as the output file, since with -q + grep generates no output, so there is no risk of infinite loop or + of an output-affecting race condition. Thus, the use of the + following options also disables the input-equals-output failure: + - -max-count=N (-m) (for N >= 2) + - -files-with-matches (-l) + - -files-without-match (-L) + [bug introduced in grep-2.10] + * grep no longer emits an error message and quits on MS-Windows when + invoked with the -r option. + * grep no longer misinterprets some alternations involving anchors + (^, $, \< \> \B, \b). For example, grep -E "(^|\B)a" no + longer reports a match for the string "x a". [bug present since + "the beginning"] + * If no file operand is given, and a command-line -r or equivalent + option is given, grep now searches the working directory. Formerly + grep ignored the -r and searched standard input nonrecursively. + An -r found in GREP_OPTIONS does not have this new effect. + * grep now supports color highlighting of matches on MS-Windows. + * Use of the --mmap option now elicits a warning. It has been a no-op + since March of 2010. + * grep no longer diagnoses write errors repeatedly; it exits after + diagnosing the first write error. This is better behavior when + writing to a dangling pipe. + * Syntax errors in GREP_COLORS are now ignored, instead of sometimes + eliciting warnings. This is more consistent with programs that + (e.g.) ignore errors in termcap entries. +- changes from 2.10: + * grep no longer mishandles high-bit-set pattern bytes on systems + where "char" is a signed type. [bug appears to affect only + MS-Windows] + * On POSIX systems, grep now rejects a command like + "grep -r pattern . > out", in which the output file is also one + of the inputs, because it can result in an "infinite" disk-filling + loop. [bug present since "the beginning"] +- removed fix-testsuite.diff obsoleted by this release +* Sat Feb 4 2012 rschweikert@suse.com +- keep executables in /usr tree (UsrMerge project) +* Fri Dec 2 2011 cfarrell@suse.com +- license update: GPL-3.0+ + There are no GPL-3.0 files in the package. +* Thu Dec 1 2011 coolo@suse.com +- add automake as buildrequire to avoid implicit dependency +* Sat Oct 29 2011 meissner@suse.com +- disable the long double checks on ppc* as they dont meet + the preconditions in their double vs long double usage. +* Tue Sep 27 2011 dmueller@suse.de +- fix testsuite to build properly against locally built grep +* Wed Aug 10 2011 crrodriguez@opensuse.org +- Upgrade to version 2.9 + * grep no longer clobbers heap for an ERE like '(^| )*( |$)'' )' + * grep -P no longer aborts when PCRE's backtracking limit is exceeded + * grep's interpretation of range expression is now more consistent +* Fri Sep 24 2010 jsmeix@suse.de +- Replaced configure typo '--without-included-rege' + in grep.spec (only in case of suse_version < 1120) + with '--without-included-regex' (which is the default + on systems with recent-enough version of the GNU C Library). +* Thu Sep 23 2010 jsmeix@suse.de +- Version upgrade to grep-2.7 with new behavior: + grep now diagnoses (and fails with exit status 2) commonly + mistyped regular expression like [:space:], [:digit:], etc. + Before, those were silently interpreted as [ac:eps] + and [dgit:] respectively. This new behavior is disabled + when the POSIXLY_CORRECT environment variable is set. + Regular expressions including back references are now + significantly faster in multi-byte locales. + Regular expressions including "." can now be significantly + faster in UTF-8 locales (though not in other multi-byte locales). + Several other minor bugs were fixed. + For details see the NEWS file. +- Adapted RPM description text to match the "Introduction to grep" + at http://www.gnu.org/software/grep/ and removed the outdated + Authors section, see the AUTHORS file for the right authors. +- Enhanced RPM spec file so that it builds and can be provided + even for older openSUSE and SLES versions. +* Thu Jul 22 2010 jsmeix@suse.de +- Forwarded the below "upgrade to grep-2.6.3" to openSUSE:Factory. + This is also a reset to full compliance with upstream. + All our own patches and "speedups" were dropped in the below + "upgrade to grep-2.6.3" because they had bad side effects + like bnc#618455 (SLES11-SP1) and bug#616037 (SLES9-SP4) + which do not happen with an upstream compliant grep + (regardless of an old version 2.5.1 or the new 2.6.3). +- On Fri Apr 9 16:43:45 CEST 2010 duwe@suse.de did a version + upgrade to grep-2.6.3, which brings among various compile fixes + vast improvements for UTF-8 / multibyte handling. + Fixes bnc#255977 (SLES10-SP2) and bnc#415228 (SLES9-SP3). +* Mon Jun 28 2010 jengelh@medozas.de +- use %%_smp_mflags +* Thu Jun 11 2009 coolo@novell.com +- rediff to avoid fuzz +- fix build with glibc 2.10 +* Thu Jun 4 2009 crrodriguez@suse.de +- link pcre library dynamically +* Wed Feb 11 2009 schwab@suse.de +- Update to grep 2.5.4. + * This is a bugfix release. No new features. +* Thu Aug 14 2008 schwab@suse.de +- More speedups. +* Tue Jun 3 2008 schwab@suse.de +- Fix last change. +* Tue May 27 2008 schwab@suse.de +- Some speedups. +* Mon Feb 11 2008 schwab@suse.de +- Fix another icase bug. +* Wed Nov 28 2007 schwab@suse.de +- General cleanup. +* Wed Sep 12 2007 schwab@suse.de +- Allocate MB properties lazily. +* Tue May 15 2007 schwab@suse.de +- Fix some icase bugs. +* Mon May 7 2007 schwab@suse.de +- Try to get something sensible out of CVS. +* Thu Mar 22 2007 schwab@suse.de +- Add a variant of the mbcache patch. +* Mon Jul 17 2006 schwab@suse.de +- Fix matching in unsafe encodings [#192390]. +* Sun Jun 11 2006 schwab@suse.de +- Fix crash with -P '\xa'. +* Wed Mar 15 2006 schwab@suse.de +- Don't block on opening a pipe when devices are supposed to be skipped + [#149660]. +* Wed Feb 8 2006 schwab@suse.de +- Fix dfa generation of interval expressions [#148453]. +* Wed Jan 25 2006 mls@suse.de +- converted neededforbuild to BuildRequires +* Fri Jan 20 2006 agruen@suse.de +- Fix a formatting error in the man page. +* Sat Mar 12 2005 schwab@suse.de +- Fix word matching. +* Mon Nov 22 2004 schwab@suse.de +- Update to grep 2.5.1a. +* Tue Oct 19 2004 ro@suse.de +- locale rename: no -> nb +* Thu Sep 23 2004 schwab@suse.de +- Better fix for last change [#45689]. +* Wed Mar 17 2004 schwab@suse.de +- Fix dangling pointer [#36172]. +* Wed Mar 3 2004 schwab@suse.de +- Update from CVS. +* Thu Feb 19 2004 kukuk@suse.de +- Cleanup neededforbuild +* Tue Feb 10 2004 schwab@suse.de +- Fix configure test for strerror [#34231]. +* Sat Jan 10 2004 adrian@suse.de +- add %%defattr +- let rpm strip +* Fri Jul 25 2003 schwab@suse.de +- Fix parsing of bracket expressions. +* Mon Jul 21 2003 schwab@suse.de +- Fix use of pointer after free. +* Fri Jun 20 2003 ro@suse.de +- build with current gettext +* Wed Apr 30 2003 schwab@suse.de +- Add i18n speedup patch from Takashi. +* Thu Apr 24 2003 ro@suse.de +- fix install_info --delete call and move from preun to postun +* Mon Apr 7 2003 schwab@suse.de +- Only delete info entries when removing last version. +* Wed Feb 12 2003 schwab@suse.de +- Disable huge backref test for now. +* Thu Feb 6 2003 schwab@suse.de +- Use %%install_info. +* Mon Nov 18 2002 schwab@suse.de +- Add AM_GNU_GETTEXT_VERSION. +* Thu Aug 15 2002 schwab@suse.de +- Add i18n patches. +* Wed Apr 3 2002 schwab@suse.de +- Link -lpcre statically. +* Wed Apr 3 2002 schwab@suse.de +- Update to grep 2.5.1. + * Includes support for Perl regexps. +* Wed Apr 3 2002 ro@suse.de +- build with current autoconf/automake +* Tue Feb 5 2002 schwab@suse.de +- Don't replace autoconf macros from gettext. +* Mon Jan 28 2002 schwab@suse.de +- Add i18n patch. +* Tue Sep 4 2001 schwab@suse.de +- Update to grep 2.4.2: + - New option --binary-files + - Final newline silently provided. +* Thu Mar 22 2001 ro@suse.de +- added split-aliases as provides +* Wed Mar 7 2001 schwab@suse.de +- Split from base. diff --git a/grep.keyring b/grep.keyring new file mode 100644 index 0000000..a09d527 --- /dev/null +++ b/grep.keyring @@ -0,0 +1,972 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v2.0.0 (GNU/Linux) + +mQGiBD1oqk8RBACzNl7EsCbcIuagc1tRE+PBaq270/3vWDvtcjx/V/qAS4Q+v05k +UwzaMZ4bJPKrxXaAPDZgHxkroe4cwugdmZoD6G71jWlIwd1e9TKU7rGLl9ebD/Ux +l94ojk0i4dtBHpnZ2KkuRWHYcOdG6WhUnENQeSUAFgetSQk3wqs71Q4vrwCg127j +35bSSgDDDBi1nqJ1dEmHAOUEAKutrdr5mvLcuC5PMMIuPNXZP7OUFJorMJBUVyA/ +v4QDjObdKnfTHTDJtaegjXXCTk0riWkM0b+yzWkmgoZWLRBZIshQueHAyTksxqHB +QPgs3Liu+PiIzJ38/2F73+Qs1ACBu7afhDduBAttbzs0BVr92j9q5esnqjO6ZvIw +D/h9A/9VyLaDgBJyMvq26Hvdhh9Khg7jGIrw0yo3FT1u5AbI7w5u6o23/9sgdwNT +oVlz3Uc5f/f3ZaYu2dcY1Eftbu8WBiCGMWotwHNlYchLsttfGPWUxkooE9wsXPz+ +nbLfcDTEN047HYJYQFJxg/XTPY0J1J1qQJkuT2O9jHr4iKOT4LQ2QmVybmhhcmQg +Um9zZW5rcmFlbnplciAoQXJrIExpbnV4KSA8YmVyb0BhcmtsaW51eC5vcmc+iF8E +ExECABcFAj1oqk8FCwcKAwQDFQMCAxYCAQIXgAASCRDRdb2Yp+NDXAdlR1BHAAEB +b5IAnjMVb9TiCpCx8DWBNqQpkwY4SsSnAJ9zjO7bXBrHkAOAo/clBqCWJ8kPiohG +BBARAgAGBQI9aN9iAAoJEFv6731hyNsvsCkAnibPg0h2rDFAROrB1Mc4j7wLMKQg +AJ49B+FD392RI1+W8lXVnx91N7141ohGBBARAgAGBQI9aN/ZAAoJEK0ukR0WASR8 +tm8An2pEZSJT/Pfp9IAG+Y3352b8/lGzAJwLcRv1aPS5z7qlR1Ab7OuNboeTT4hG +BBARAgAGBQI9aOBaAAoJEMoQ78fa5xN3gX0AnRYE7IMG63za+Ajvh382k15KKXzW +AJ9aY4aqnhTYyDpol4nSn+XHlFM+FohGBBARAgAGBQI9aOFCAAoJEO8CPHIJF9GJ +wzUAnRNIevh/YIFSc1FrcASXVIcjUxDtAJ9P1p6+U/hW+VOgAw0mhUj2nGkDMohG +BBARAgAGBQI9a2zJAAoJEFgpV1AFAIOLTFsAn2yeas1teo2NMw95mhpFrA6p6gN/ +AKC6GL9gGcCb029z6vQJvkTXmlWwW4hGBBMRAgAGBQI9a3AcAAoJEHvShD8jdkfF +hM4An1/LXd8ueiZ1qsvlbFmqF8ujG4iLAJ9xPDJk4e56Zh8UUqUE8QIxQDd7T4hG +BBARAgAGBQI9a3H2AAoJELpEiomc6OesYQgAoKkTYQtlXEItVl6odJZ8KVhPof7J +AJwKpH96nnwsHbHNEVNW/UhF7PJCpYhGBBARAgAGBQI9a296AAoJELtVpH/JAcM+ +X8EAoNIynF8/DmMykFFNxgfrRHTG46tbAJoDikeU9qoiKwzd2OsQA65yGtO5aYhG +BBARAgAGBQI9a3epAAoJEGEkmiEwk5yl4YEAn0DiPf59GJgtVPIluvHxwDNbfp2H +AKCrFtPHZwYedtH6ZUvnI5vhjO4kcIhGBBARAgAGBQI9a3PnAAoJEFlRJ0yBj+NA +r/UAnR6tBDxnbWj1B8rivlaRFq3gmUdTAJ9Ye0cHujWzUZiCrcO6cI5WZmRi1ohG +BBMRAgAGBQI9a299AAoJEADTvn6Ubmdi+ssAn1nfAW14+7Nms+PNDQLPSW+crvmr +AKDAXK7U1ER0wz5cSJbjMJHnOb5pjYkAlQMFED1rc/sG69dbcMwPyQEBOcID/0du +dj1kEj0FiuLYYI59PqEHtIaiwlhEZn/Oqw3mb9mjNR/nJYxS9dwn57FbqE8o3ANO +mK83U+AGt2oYiiEe5BJms4BeTEg43ArqdGR31QMnP5xuGfIWPyUe/jSf3aUdDC6C +LErxwzeQnmLYcJYcgnCxj0dK0Ji0bCVAFwCYXdjRiEYEExECAAYFAj1tXFsACgkQ +F8Iu1zN5WiyNNgCaAjAO7q+bB03g1l5MZ/HbKbjl+QYAn3ohw1P1uoLir2+bYVTl +NQLJfK5CiEYEEBECAAYFAj1rgP4ACgkQvsXr+iuy1UqqRQCeMNr+rBFzUulQGE9O +uLKfWsm05icAoN2761aB9DcAk9OFE79XAF3zenNSiEYEEBECAAYFAj1rchIACgkQ +wFSBhlBjoJakTwCgnRbrhoMl2cux9jCSSkbMfUWhKCMAniJNajmV3p2Ughf+Fq1p +/i1g+oGjiEYEEBECAAYFAj1rcf4ACgkQ72KcVAmwbhB03wCeL3Z7nN8EvHBVaIMT +3P+3i/+5yokAoJXmOdxxAfTZivAKmjKHy5u+V4f2iIYEExECAEYFAj1rhIA/Gmh0 +dHA6Ly93d3cubWF0aGVtYXRpay51bmktYmllbGVmZWxkLmRlL35tbXV0ei9zaWdu +LXBvbGljeS5odG1sAAoJEN6Fg/i9v+g4048AoJZAGhbldZyPyCkEPD6a5Mwr+VWu +AKDaix8MpVSg98Gm3zh8iz2/jWbo6IhGBBMRAgAGBQI9a4EsAAoJEPrVrRO1Py4j +1ZUAnio8F4957jNuFHZ0NLge9Wj9w48xAJ9HpJ9Cvo1AC1y9pL/f9lQHyBH/m4hG +BBMRAgAGBQI+NqieAAoJEBFKgXkHzgOCN8gAn1AMbkVipa7iKcuxuFtkl3Hsm54o +AJ9EIxikiApGr+p6mwrzKW7jsvNKmIhGBBMRAgAGBQI/vBv4AAoJEIvumtYLLjd3 +RVMAn0hljY4vx0kftBvzstfoBJHcjKZlAJ9J04F6OXzEcviXAlVT5aIHS267NYhG +BBMRAgAGBQJAPH9bAAoJEGDxewcRlpQbwmoAnjUVtEfEK9xQOGASXdkPJYsWmPGu +AJkBpSHkylT5BBvyqtckbSUbpHviG4hGBBMRAgAGBQJAPIDVAAoJEGDxewcRlpQb +/TsAniLmUUyuKuWysxwn18QgXzLt3TTgAJ9cO1DhSwfzWSa9W2rAU+dIWrAD+rQr +QmVybmhhcmQgUm9zZW5rcmFlbnplciAoR05VKSA8YmVyb0BnbnUub3JnPohfBBMR +AgAXBQI9aj5fBQsHCgMEAxUDAgMWAgECF4AAEgkQ0XW9mKfjQ1wHZUdQRwABAVXw +AJwJcQtVkBxGldnM/ppGXA2+JF6LQgCdGq4Biq48EFcpZM7+gHwmhUkwy92IRgQT +EQIABgUCPWtwHgAKCRB70oQ/I3ZHxQ6mAJ41WzgEvv/2qvS8lNvm2xVW7XRU9gCb +BtWShpM99X1FkZqtXOsILJRtfGmIRgQQEQIABgUCPWtx+gAKCRC6RIqJnOjnrNrp +AJ9lBrd3uqSQAFkZw3QHwbHgSCf8EwCeP2lQpbdcVcxY7OeAtvVIt8Q2T2+IRgQQ +EQIABgUCPWt3qwAKCRBhJJohMJOcpXqAAKCsOOScIIRQXSi5HkAgHQUtXmNbJgCg +o4WDq267ZdZ6spXuJ+XyZuGRCgWIRgQQEQIABgUCPWtz6gAKCRBZUSdMgY/jQI9b +AKCHN0J7ALxgfJ1ukkoTcNNNgeJbrACgpmiYmHB+D3wCjZep0byfqIa3O9GIRgQQ +EQIABgUCPWt6BAAKCRC7VaR/yQHDPnSHAJ9ygCytHd2cAFhkb7d6RQgsNvCi+gCg +qZXm2JWN2YMmykUp+VR6kmb4F6KJAJUDBRA9a3P/BuvXW3DMD8kBAU3wA/46pZnR +z6+4uC7pQOsRfEPKV8mQbDlSlw8N357MFcOGFLEEbOSAl/47tjC3jweM8pgAIFPM +ZTLCPBiieRLnAgh7ISwbO/VrIabC2YbdkGeifnNPT9Z/8j42IK0ieqo2+v2WhJ1S +ccmTXMC26W+SmZuYMYKyOlM4yJfPsXgsamKxHohGBBMRAgAGBQI9bVxgAAoJEBfC +LtczeVosM1oAoItJDOnKgaL3Bfx5AFCXtNX7KfF3AJ9YWaA/atPfhXgLpTC2uVhL +mMQDN4hGBBARAgAGBQI9a4EAAAoJEL7F6/orstVKd/YAoIYMya6j796SQxecwdej +fs2pPneMAKCr/lBiHiuzUV34QzxxppMGc6PpRohGBBARAgAGBQI9a3H+AAoJEO9i +nFQJsG4QyGoAmwTZuLmz+CpgaPjf/o6gCzcAi0+EAJ4uWoPMLmEWuaFrxCWM9sg+ +jRfLf4hGBBMRAgAGBQI9a4E5AAoJEPrVrRO1Py4jPwUAoIBciFSmpIvSn+VeX5SD +dU7o0Xj2AKCiz6hX0gOk3ckkLzgS9lWpoRMzr4hGBBMRAgAGBQI+NqimAAoJEBFK +gXkHzgOCLW4AoLYOi8byK5C+nO/CGTK4w3HYRF3nAKCDVTsGm+kbGA/JQ05/6uBI +sqCNN4hGBBMRAgAGBQI/vBv4AAoJEIvumtYLLjd3G04AniQCN2TL7B10X/uDTG/I +2IvQZ0DGAJ9xYER8O3gKEUFX4/9NvC9odYoN2ohGBBMRAgAGBQJAPH9bAAoJEGDx +ewcRlpQbTeQAn3+eiUuot8I19ApTO1XoKYJ44ictAJ9DL9Erq4POPThFxPSkfZCY +9FEcjYhGBBMRAgAGBQJAPIDVAAoJEGDxewcRlpQbsGMAn0R8RGKWoX222jnIYOf5 +5TvaV79PAJ4la87Udyw0Ajt1ws7ufkLmBi0PRLQrQmVybmhhcmQgUm9zZW5rcmFl +bnplciAoS0RFKSA8YmVyb0BrZGUub3JnPohfBBMRAgAXBQI9aj52BQsHCgMEAxUD +AgMWAgECF4AAEgkQ0XW9mKfjQ1wHZUdQRwABAaUtAKCSWQs3UjQpYugZ4N3Rcpa9 +onzY2ACeIooHg1all0ARYR0XnRC3ua0u57GIRgQTEQIABgUCPWtwHgAKCRB70oQ/ +I3ZHxfKUAJ4tc6tTH9bOd1cJUioU7uC+IMRRAgCffsYA9YlwbXtsq4ARPbHikye1 +WhqIRgQQEQIABgUCPWtx+gAKCRC6RIqJnOjnrMCbAJ0UF6y1P2zz4121fjsOrib7 +pia/cgCfXxpKpsVQdXqa6fAeHvpyAf6VCx2IRgQQEQIABgUCPWt3qwAKCRBhJJoh +MJOcpZiAAKCXKVENdEuxlEddoB+FqxXbAV4iMwCfbcxDHSjcxojVK+nw93VknCwm +1EqIRgQQEQIABgUCPWtz6gAKCRBZUSdMgY/jQLttAKDB0Bl4Izj5sUmfKLJWUHpY +SLAWiwCgneESLi71Nm7lsqSZg2D4H+o3yquIRgQQEQIABgUCPWt6BQAKCRC7VaR/ +yQHDPvATAJwKS3uVnPDMd8cW6HSzuV+5ZerW9ACg4AuBNBHjKJxg3zfzEctHlhGN +SM+JAJUDBRA9a3P/BuvXW3DMD8kBARjKA/9BztyBR6A4AMP2rLbpFm+zF93MFD7Z +4wTVXXB6vWpd1I7QKBiHlXFT0t1qVxFCCcITX82zUUyZBHdR3DU6bH9Fkd8VxyOv +UUCx77ixzmvP2O1+diuIaTfVJJnbXUsEXY9MT4TynBZjfEtWciC+ILW4j8thkuvh +Zm9KVIhKmU/vTIhGBBMRAgAGBQI9bVxgAAoJEBfCLtczeVosCW8An09rA70AehLt +f4Brx9VKmq3618sYAJ9oEdyEtnpVQpH723OrCSzmEYIDN4hGBBARAgAGBQI9a4EA +AAoJEL7F6/orstVKZ2UAoKceNZLp02ocZouPgsugJAbwgn5kAJ4pzEztGvr0bYMT +r3L5pLMyhNAJ84hGBBARAgAGBQI9a3H+AAoJEO9inFQJsG4QiqsAn3wlLpFu1qqh +XkuIoGRjtjHTEe1XAKCYarh94OPrgktWlWCh64I+16J2OIiGBBMRAgBGBQI9a4SA +PxpodHRwOi8vd3d3Lm1hdGhlbWF0aWsudW5pLWJpZWxlZmVsZC5kZS9+bW11dHov +c2lnbi1wb2xpY3kuaHRtbAAKCRDehYP4vb/oOA9FAJ9D6q4bim16kcnbIdSKzSc0 +M4bNkQCeJYgfL+QyGjtoLkeOrAWfvsyJxzSIRgQTEQIABgUCPWuBOQAKCRD61a0T +tT8uI1eRAKDGRdqI13H6Z8N27hUEvifUZmiOhACfQJzKmzdesQiZBcr+tb50luzh +AmOIRgQTEQIABgUCPjaopgAKCRARSoF5B84Dgj2dAJ9n1D86MnKh7cfHUnA1Q8f7 +Go4Y1QCghqn35DgmT8fdT9+Hm4brjWaikBOIRgQTEQIABgUCP7wb+AAKCRCL7prW +Cy43dwMrAJ9bnxueh9N0F3bG3f7mezgtBBPjBQCfZiJo1iUWR40xOlwrkp0ayUEu +YEOIRgQTEQIABgUCQDx/WwAKCRBg8XsHEZaUG5mPAJ9BvkZogQwR0+lh2ae+sQag +bjjfuQCfbH+7579wTeHheAJ7eRjtPZL1QWuIRgQTEQIABgUCQDyA1QAKCRBg8XsH +EZaUG1aAAJ9iRFQjBUvTNPFc8QINLeADb7RiOACdH74aIbsq/kcmvs7HcCHGz/ky +NmG0K0Jlcm5oYXJkIFJvc2Vua3JhZW56ZXIgPGJlcm9AYmVyb2xpbnV4Lm9yZz6I +XwQTEQIAFwUCPZBjlAULBwoDBAMVAwIDFgIBAheAABIJENF1vZin40NcB2VHUEcA +AQFPqwCbBNZD5v9AwRD4ySmf6wzPu5I3iTMAniN0HZ6hSGlHRdgk+tfZcYFU6eKd +iEYEExECAAYFAj42qKYACgkQEUqBeQfOA4L0hwCbBOmXXQ59ZGxlAdtnTKAFwCZI +LkkAoKxsjUSE43n4Kf8Nt8+LUuBC0Vc4iEYEExECAAYFAj+8G/gACgkQi+6a1gsu +N3eiYwCdH93OM6e6agko+GoQLZSvPRp55TkAniEOijUCvOkDXNapzFbWYqUJEQzw +iEYEExECAAYFAkA8f1sACgkQYPF7BxGWlBvbKwCfZqi1nSztThR6BalzgHEyF5Q/ +/lwAnjuoC11iA8OUoVKrVGEpYXLUNpEDiEYEExECAAYFAkA8gNUACgkQYPF7BxGW +lBtI5QCfZT04raTwotMTUXrCXGxvh47qvzwAn3tm4IYUoSlVwiME7ZKQIJyOPQdX +tCtCZXJuaGFyZCBSb3NlbmtyYWVuemVyIDxiZXJvQGJlcm9saW51eC5jb20+iF8E +ExECABcFAj2QY7AFCwcKAwQDFQMCAxYCAQIXgAASCRDRdb2Yp+NDXAdlR1BHAAEB +DFMAoM90WM4rLCCIaGTKOuv1RCrFJh2TAKC2ddmqit57CTo6j5XB9Tfu0NVGXIhG +BBMRAgAGBQI+NqimAAoJEBFKgXkHzgOC5YAAoKrxy7pHPSPOzkp+QTvfJr/wMfv9 +AJ9mYOxKjn9BuBn06H/4RqPxxeMrbIhGBBMRAgAGBQI/vBv1AAoJEIvumtYLLjd3 +p7wAmgPH3XjMoKSDGYsliMz30tBW2IEYAJ95LNRO8nSWdl1LS2ZUZ0TiLk0t8IhG +BBMRAgAGBQJAPH9bAAoJEGDxewcRlpQbeBkAn2EO5dUM/uDc/WtFInppLI+0K7iB +AJ9uV75l1usCSzhJzSt23SAFl5H4TYhGBBMRAgAGBQJAPIDVAAoJEGDxewcRlpQb +1B0An1pstl41SnnyhgoNvL550k6n1rT0AJ9ixMKTixk0mvxmVNp0SmO3nwP57LRH +QmVybmhhcmQgUm9zZW5rcmFlbnplciAoQXJrIExpbnV4IHRlc3Qgc2VydmVyKSA8 +YmVyb0B0ZXN0LmFya2xpbnV4Lm9yZz6IXAQTEQIAHAUCP/BcxwIbAwQLBwMCAxUC +AwMWAgECHgECF4AACgkQ0XW9mKfjQ1wVxwCfde8DyWH3CeVNDB63f2x0qr1jgUcA +mwZHQ4omjd78RgQhCLzdYS2S4LgTiEYEExECAAYFAkA8f1sACgkQYPF7BxGWlBuJ +yACfdJIaU+QunugJay4CQ4OPzicvDZwAmwesfP+BRme8cuyAScP+xCPp9wn4iEYE +ExECAAYFAkA8gNQACgkQYPF7BxGWlBs32gCbBQT/+RpqiQtg+n6T3wqdUABVqsAA +n26TO/duKcPJS3lUBMgvZcR3mJDhuQINBD1oqpIQCADjI3E8XD7guh7OUaFnkPun +jvd+CkeuWi2Hz5GYuVkreJDZ0B9n0vOLz8sAvmYmvSqm8W3Um81Kp/afV+OHnpka +VPFP5F+cHvU5gsUUDyRimmcQ8Su3tgMpaAOh2eYv10e8+kVYZwZJcO4h5Nq88L2i +SKcbdgq1MygljnPOKJo15tdLsB4SnNs58345eYqjwNlrBv/WzOTnhX7MBHUx6IT0 +mFUTR4t4p52B3pUtNbqbzGWdUV9IucCEA+KwCoVzy7IKkrUSLOupLvOE3SslrFmb +gnQ1gCDj6H+6sDWSv2siIOUBppNOh+76zN5Ex2civmE0xCDioh3Uo0J/9UU5OR1b +AAMFB/48nHJBH5ikGv29gU0rswySrZWd4IkGsKdm/gt1j2n7pI7Pygp0Nw8ykem+ +XyNIT0Mkjb6r3b6jpAOoM4muxFwAUwIa+PoNtNoHx4au77t3JvttPbafk0+lPM1+ +sIIc68Lyknu6lWcjAAZo1LV+n1NB5IdPUJhkDTjwRPCRTwL+UlsdC9Nkf9DLThmj +THlBzjoR4Xc3FwrhNMoLYn4zDbQ5+fOK4utHoVh1oPbjm3llMgsmenop2OcB8TQr +hWdM8P8UfMTbmvTno30YgCcFUg1edNnG2+NE4V+60Tdza9TPNKVO514vPOJDnXRB +1NLmTGCGiI89AiM6gyjRKqa+2FnZiE4EGBECAAYFAj1oqpIAEgkQ0XW9mKfjQ1wH +ZUdQRwABAf9pAJ9qPKv3o1kC7as7DSOVhTRT90qZjwCglz0ioDqcQ+QoC3cAoMzg +eKnfZt0= +=pTiC +-----END PGP PUBLIC KEY BLOCK----- + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v2.0.16 (GNU/Linux) + +mQINBEwWvdkBEACyOXTiLBZ5MFNM6jmm83ui3MqW0/eD8TcAI4gt0gwOvd/jXerI +ros8dRVook7FBoNiFSiJSMVOiNPUMfv5h5wZm0bje33qTJPL7IanSKXtk/I7Za1G +EJfEnfgZI/d4EIV8wrl0WI1lPEteTgRJbo76zfLIUOHpynVC2Wm5gALJ4oeJIS0A +hYSzbFmHD9dFI7m3sO/HmbhxTiMISy0FbmoqE/cpo8ZX6eahND2UrS2oGNC0Ok8/ +nN8XLPPsikx35FKx6bDTfoAK/svx6PK1sSPfAdoZFZ5Jy6Ti4zubebUD+5I8+bOn +6R9I7P0HerCTqMBLnf9LJHTPhTk8fHEwlAeH+WfpEmN9/4YORb84WY97tFbVK4f/ +icEjnYBc0Ozl4qMGI1g/1R5Q9Z8qxLGsW9tNWyIfAf+2BhLA08RfA0wxmEf2Gnfp +J379s5c0U8xLZegOGRF1tOAEIC+5wRKFN/qU9zpLbUZIGrB+ysVeTlDuCDnTnyUe +WBQeRnfItl4taEN0/axNGB/NuHvxShyzxez/flbyqKwsxc35/a2OCbwmADeUh+ct +sYUGZya/GuXfejWbCuaqZLLkP6Ed9k4+LY+ww6jA7uNPRXpCYoXFo2WN9OaIqfb/ +RDk6zW708qbxvcWKe6j9f8R0lPMYdtUzZhyxZxeZ0/2BdDyXAj1Wvnw1UwARAQAB +tB9KaW0gTWV5ZXJpbmcgPGppbUBtZXllcmluZy5uZXQ+iQI6BBMBCAAkAhsvBQsJ +CAcDBRUKCQgLBRYCAwEAAh4BAheABQJMF3RUAhkBAAoJEH/Z/MsAC+7uoX0P/ieV +RRnnuK+SRdzPiJgsy5oncEZOwIdhrmtV7/DLx9OZEsVBl6fN2txd2YKOtLEc0Oev +RAY4Qrth3sM96d531oGKp5CrgiDoYO6Ku3YqxGhWrXUx4De7bgAiNputJ3HYEGvU +td7ZphMuNO4mamECTbSxQ3v6+hXH+nAxZ44iLFXZNVj8sN4C7P4I4IfjJskEbaLV +CwBxT0rqtb9knRN7pmopZRh/YEn6GlPD1HZykYMmjhwO5gtBB3YB5PBbXvuWbaWw +J1iS+yJWcObpem6+Kt0cv+VC/Rm20f5mvQDAGBLeNjTISy52jh24lQu4sjakqFbK +C2PFRVqax8Xd8Xvlrc3RDEi6nepb5ghfQfiALC770GmrNr/hbTirgw0XFjBZv7pc +j8WuXsEmm4Af8Ya9Z9ikTgSbshl7iAQs49l07dpgo37OmjFewjqC4g6FQ63N0ozO +0iFL53YHpkO3QhplhACbERx1NSlu1x98nGItsGohTy9eoU2lBotLIyEedDjjG8wP +yQcFI9a6HCuTjNUW3WZOL7tRkMGbgwRrFby+nnIlzxRFqyTW3amgmIkilRgcj1VF +ICwuqj3FWHswjnHSU6wWnvWPpnvAeCvITQFN7f3xpThcbfCmuXWqDyx28sPRFqPU +DVhB5UzoaoQd8NOGCQcK8XiNO7kZtFIarn00X7VBiEYEEBEIAAYFAkwXdLcACgkQ +/dLerNMzy6HSJgCgoVIEcnCSvJ3KXZLiKF5C4IMKB0wAoKyjquTDktD/Bzao0YYb +cWctvZoiiEYEEBECAAYFAkwX6lEACgkQ2ijCOnn/RHTCswCfSqXSmv7ryDA1MMsH +EcjTCrkId/EAoMVbrzFmqTqAcZ9ZLNIG7GUoOugBiEYEEBEIAAYFAkwabbgACgkQ +C7UUpdBu1p94EQCgq6oMLaBPBkpTSGdl7f9tH4FLFe4AoIHcvV7aHqHAD0byJhDc +RBc3i9fkiQEcBBABCAAGBQJMF+7gAAoJEKeha0olJ0Nqnw0H/RUCMuKKFxM85r3o +dAKdHrls1iUTBL66HWcWszsuE6n1xKI0D0G6QVNYt0SxESYNjwH6tkVqY9NImlLI +QCA0S3Bn4C/zUeOa268hBO3tcBIoiJkO3YSCkBeJ7Z+hQ4mvdV/hAGkJKGxuDboN +MKu6PgiJg+vuSjOdungAWGuQmtSrmPIel/IBh5kMZMHHFMaKdpxmIgRITlgvXzJn +3pzh9hGrXnKw9xAwfPvyL5UQRE7uwESI6/dJMA9x5XGEwOYTyhg3tUMRnhTlHSIA +zPwpZkrxMzKVOOVyO8MEIhHqguqZYBlngJ3t/amcQzkFooNU+YOH1AqO0+JUSZIq +C5saVCGIRgQQEQIABgUCTB9wggAKCRBUFGa+sS3Bm4VfAJ9e5QCa8gO799TkKBsL +4Fk0Wceg4QCfSD7A23oY1NUS4OuI1h5Z6Dxy+4qIRQQQEQIABgUCTCINqAAKCRAN +3KoyeNUmTphVAJ46rlIwm4+tzzUe8c7BfUP3sspk9wCXXSfTfn4KmliS3JdKDVhT +sZHkkIhGBBARAgAGBQJMIhKEAAoJEDhZwDsuI25HDY4AnjNqg0Ma2y3p6OqevM8t +eA8a2XhFAJ9aHUoxSFkwHvjElPkFKzWe8jaf+IhGBBARAgAGBQJMM0BUAAoJEPHS +zMhJehdtokoAoJQW9Sv6WG3SCkW3A893E1wDQypdAKCBEFSHxnOssEqYRtbzvka/ +gWQYAIhGBBARAgAGBQJMM0EuAAoJEHfdleLqUuz0J48An0G+LdQoT7/G/+IKB6pA +wTVZqMtAAJ9rUSEnlHccZwRULHSOgymjt8+8d4hGBBARAgAGBQJMNP2bAAoJEDZs +8J8uUUr8t5kAn3xFYhPOa+bzmHCYxZbz1FGN7ZqlAJ457QdugGUrnRiVfUZ1skdU +birmvIkCHAQTAQIABgUCTDTs7gAKCRC825W3CqO/Dp39D/94iYs359d7O2IAavBf +Svqg8XuRW3RMAsKTaleRGVso6OVeLdG/J+M4dgO72lCMyXCAOW0aqFvTdL5LNxRq +jt4t5i5C+FujQVYOafkrLHDnKPwBBSt3pGYqh35lYPCXNzHzz4zXhkm9sPtJBmNx +Ssh8zDF9c63psovVjSxbf+qW7oCYzcJOvyDvyq8AhYvXd9Rn0Z8mMrQy32Togfqn +B0m6K8dXoppiOIIN1X9lQT01eZ/0Myvj0FyqSQalfwbkjY74nvu6IgTrPpvt4NLf +kEYXu7L4j0M6q808UnskFAimDSklQMg4E89RMaKKVxczwu01it49CUuB/sB5h/JF +XUybMHEO7ypacSEKKaaLP2HC+IXq8yVScb4cYLK27S09vzIEaAHCFuOJ5Ip5yKjd +pIMXB5vLVsqAakV9uK7191lyi2bCUN1d3Xw/wfmsnRjc/eOdpvJP1vZiL2++Ou6y +KTDqEtXJlr47PMkU+39LtMzqhfLXDa4cEP9jR6/7BATKZAvifSVNJ8j3SmIfKdKv +WV/XIx/HL2VfA48VUurTE1qJEEFvAPowXKgKWUmEQYFZ0KZTpee5K3cR+E6qhuPs +kG8S645KoiLk/4uyXwiIAQ6uQ9PaLwKTj7v93vkwIk6ioBo8wemrE+i7rU0p1NQK +W0B7C/5eANb2FMTsJa8dTmjeZYhGBBMRAgAGBQJMNP8mAAoJEDZs8J8uUUr8nfMA +n2WHqAcIHmipoHsLVPY7Yst6BYj8AKCiPkZk71AmxPLQGu96aEfl/3KO/oheBBER +CgAGBQJMNQ2/AAoJEDWpO3ToLkIJPOYA/idZro92G/iohwppQwH3vfNdkn4/VNYU +sAGncsBGC8g9AP42I2gegFGj3fa/jvTBfDz0II2Gq+kN+KD2HBL/wtGDQIhGBBAR +AgAGBQJMNdVnAAoJEHJZXrGBcEuT3CIAoNk2s76bOGKXL7BfdnvQlf/xmRjdAKDM +SxyCe2GEYm2rTRPCI/Uo/f60IohGBBMRAgAGBQJMNgdyAAoJEHlVn2eBNdsangQA +oMHXbV/hgvLDaPXxWEimryZ2KsDQAKC3SP+dm1MfqJxJlcOEHO3zpZjCN4kCHAQQ +AQIABgUCTDYj1wAKCRB2tTSy6ZAH4Gr8EACvM0xiNLjEezzSDoaZWghCEZiK1d/Y +Tk7/zor8oFSPYyxVFM+g9WVUd7gL36azmijr158D7tsoqWaMCHeYehJ5LghMCPd+ +q1zWF4lAwD6NqBIG0hc8xnQ2LkdnIRBQdEv31sKueKfaP1zPu+MI/3BZubAsSD8H +q3B4pOBWODhJVKvpR/K66IcbPNWchhXUzwj9prGgcX6HTz90FKbqDlRRJPn70Mrn +ObJYyHRWkrYSyAN7yaiX8RNAs/g/XlNGYUbL4VT65G/PcoqMKlReGiqrAfRATPLj +ICWCXFsIuW4SnbvtuTFx9bE72K6YuSmq1V/gDTYyJ+WGWWa7Bo8wnDfu4UAsKRO6 +i5NWWBGEmSwm9lsm7InYOne+LXiNlsnzTLkgqzAPl7DHuX+lwbp40qQHbRVRuNGw +xbHZZ8DJ6IkO/0yYQJFGmBNkYSXnG5rnBNvZs5wfGllF4y3ExUWUygh2P4ha3IXl +EjHBy6gk5nmzTjDXbMLFUvgapvMKEy2ARlBLwbeXwGWs3jwQBfNBqP7BLU73uVoH +B6hMqD9MmfR2onRqzOOoCJdeXJqx2Am/5FTWozcxdgdIKqEGOUmfD8jwLsKb0SAL +WdWEMCj2/uT3eadZNo+T14KiT59jVRqR1uois61jeS0GaEfXNa5voq0aTNiAp+Oh +v4Y3waO4P2X7dIheBBERCAAGBQJMN0/3AAoJEPfVyb92XGHjZbIBAIJ3L8lmGSgC +7ILho4C4FHHURkiHcjdlYVMljke1XInZAQCSl0puTTMPjUR4tG5hD5KV4aR/e51Y +cDDfRg0gT5cGPIhGBBARAgAGBQJMO1JoAAoJEJ35m9oRaREwtlkAnR0ku9rYOXlm +kZ7dX3jBonmoJ7VTAKCGBW1AsmRGAi3xDGkIv+c+qIc3PIhGBBARAgAGBQJMOg1/ +AAoJECi19N2Uj2RssNkAn29BYMBwmlF0SgItbNV6qSDt/v7gAJ4nf1ddSalZky4k +CP5zQ+n46v6Ny4hGBBIRAgAGBQJMPFNMAAoJEOoFMOYVvp+lUbYAn2Tciawo0781 +8u72oc4lbGf5iToRAJ4rsRBXyLgLJrohG8LVxxv3tWPmU4hGBBIRAgAGBQJMPFWR +AAoJEOoFMOYVvp+la5sAoK6m4UVtRJ2kadUeO4c0kmKiuOqHAJwOzEuUkWnZMJhr +//VKJ4Zn8iHWb4kCHAQQAQIABgUCTDdpgQAKCRDvgfcsKanW723WEACWbHdKZUEK +MRnG7Af9OOIL4gf971SWP57IfPAodgl/VvfW2jQ9LV+HbMejTNdW5nYdGd3iy3yi +3J+cd4L9eJcgjwOzitz2dbSb7BzAzaHD4ge0CtdnY2jeLOXA2VdczI9XbUhXSrcF +YsOSj9j1UGW9UTMBNKyMvaaMB+VNFk8DQfHk5bcWg6wkag8DY1mYIff844XiLNAZ +6ohiYVYuMcVXijU0HDL/74q1DJwiMBMDIrWTDxiib1YpN/jv/NJDxaUUVMK1LIjJ +mykFvj7Y4MZpPGgJ7F2YD8ZFRWQPcZQKqXunVNVVVDkq5bWoST+XSMInPiI3euaL +m0srUOh8XTBocS8/fNZFmPD0DIC9kiZomrp1xa/3W9jbSERHHfjju2odJjWz/DGm +2P0gszlix1aibRhK+PnrSGR3Ql3VH0JEZw9UK0joxiODSQKH5paq0XBDJBisUR3M +SP8oEUjbdmPuYE/oMmfJMGLWPbJK/7BBeL3dD2rv9hxSnoTSEImCoGCFOMZC0HG4 +iY75doo627XUbTaoL4nuUiRF/5fK/3oiTS/rBhGQOBSrKDUpZ6iuQKImIwhNGvtt +aiORTtmQkBzEvoHz6IvniL/SJh7SAEhrVFAR7HztEr3ODNIgRWn3F9hGeAEuev6B +SKfkUhu6AFmm0ZU5fvBZMlUjpbxhd6BORohGBBARAgAGBQJMPYt+AAoJEF7Cp382 +7MUjJ1cAn3Z5DYcwm2szm5xR8I9vIH+lMPi9AJkBCB0z17qkazk8Ggk4MW1awj4H +uYhGBBARCgAGBQJMPyTUAAoJEA6nVrUUSEP1YuwAnRxjLDKxdo7mYxPzmjisN19X +0e/QAKCna03y9yE0TItLDNYlTDNMiKWdJokCHAQQAQoABgUCTD8k6QAKCRDTDezS +WZMi/B84D/sHnY8Cz6vq5EMT8HwUX6/HKmCoMqX65UYFBKFxdbE7gdVOZs0qrJjH +OEe+xVwZb4qZQD97Wh2ReVzssKUZwibyXQDZWocN3p25A414VoyWS4tZ+l9ZGAP6 +ut6110o0O8K/dU9EgowupD89F3yTRwcGCN+u1gpI2Wwu88baJ8/f/2ZmKLI0SvHX +Q3rQiAlMxmnKYD+KV451to5SmZ0E2QilDlNTfVYFUH6ITkbmzLCzb+6NOiQAsjMe +jY4Pp2hmPbpf1hLPvn13vaYsnyVFU3oay5MI0IC0Sjna6y8A5HUPc0jwVyTNPB/L +jf3ezO1AwOmQc96tQL/oGJvMwslDq8pcp9eJu9b7MwRaIUz9FbAeEyqyg7EC5i4W +X+1h26tVsNBEVMEcXhOUXfRa1TPyRzNZ9a4aZwRx12Ho7LyyOZ0UiJOVcvzhyQO2 +fY+3Y/2rFVNZOAPdO90kOQjEXFmHD7JZsImDUcczu4mY+M0unn0xjALbUZFhm6Sl +RgVo3t5zmym9ByiYnjB9NNRfSFH/bZQGuszITVISrSFRfgHasxGyxcFdGlDew553 +6FJWXP17u2Q3bQmzGnozK8h9Yme2dnsn30f3Bcaxo4Hjom/4gGciye8gzDwlS6Lk +M1B/eLBRBSp3EdVAFsTKntRxfv53X4d3hjlWKBqd1vQ4+XY5mKK5+4kCHAQQAQgA +BgUCTGIaDAAKCRDlYr2UvwNEXjA+EAC9lh2HPZViXSWbiPKz0rKIvM9y+FwXhvKN +C96RdmykXW70U7L6pRY/pLQJGdKmiYjUKFhaYYjlP34oTl+kcnjC8KnRDGs20kyb +Nw6cX3vrwBkf4aBiKFLK7wteTOkSdZnJWjAg4ix0Q/Zsv2xXIVKZswLMe4s+zZUZ +fYmrwXIXJmpoQY/ikAlJKtyJiHAroolsagKRuYEDdwDFZIrmXOB3AaFg3U7tXinB +DNigIVcM8kzhhLoPOT1WERfKpurwQc7vWXcOjbR6/fZcIdXW+6Or66lPIrd6CrmK +ehE6KCld9V2WphdKIeOyadCUxCfCIRKG2LRHQYPvi4a7E8bkpaKeIAFg6P+XBojr +SEqz/KlvJZofFfzdeY1L2jUxVRSOezDPAWGagq1vHjfNKYg7OwFLAUXpz2fQs8D3 +F/OXkZRsKkl2q36UX8yFHDi07ipT5Lyxn1eqGo00oZMeZ6p0r/DZzrnqBIcfH8AM +TnkVUAMK/I6f2VdwhfVyhaUPMsldfG7YgsLFAZk2POcUgKx5fxSkCbuR8JuACKzS +9VLRYpApI+sitMT+zoAaKEZYNRSWNvEvxGlmYklL/FpN8o/SjQoxg3yYMB6LGRiG +2+yr6cOsoYbCdkYHfbMKC003YDQc0x7JwoJqtcWgA99k6mToJuNjY3IuynvIH/WD +u4ci1tp2GIhGBBARAgAGBQJMNm3EAAoJEBBVNce8HC5gnCEAnjl5+RP/sJr6sEV+ +xenaqhA7x1G9AJ9aSVu+IlQuYocl6Kt+ZEIjT5nmGokCHAQQAQIABgUCTD2XbgAK +CRDsbnDffAimYoqPD/0UV4K/9ENdyc084RcDZ4OoUWfbwfNKUmOoNm6cFUr0m+lR ++NL1STRCACTblTuBRdGILYvAAOk/QSjJchtV+VwgJrnmcxJawVZqieb96cIr70rL +blLhU3ONoAe7HvLhNkfJr8TFWzOw8oEOFIMCiIOjkbzeTmaXcf0q6s3nCVXnhNUz +1VrTP2en5puzxTfjVmAF20hVOICsuVgFnVwO2DOAkel50eA3/19Lc0P4TYuOp5ql +lcl65y8yPSsX+DPJC9k5Wf3JuN6aXF1seo7soqXfabF8njqnpo0uZUNZM+HTfOr1 +gAaLiKYtDzdOsEsrfX0/JmJP44e7tqor+tP8etuYqfzIS9m78wfJv+RG9lR4kOhh +IGbf+MxjznmVX4Wf2yf8GEK/hxo0Td90OXlWQUR9JBZb9k2vcb26T5A9RMs0rSbx +JKj2NRJW9nTHAnhZgENXv4nO/wnWISVVjdcQIZJzJCNZzves/Tbw98GFHQwMjiFH +w2FET7J+ImFVnI/ooDApWsytdqqiXlhL4qzA3OvFDvHOpaqikf0XouwX834CN/8O +ukVByOWra0xlItjYePvCqocKNVtBRdDVIkPqf3FKKbPWRJPgY800Jt9hRk3BNSjB +u0TZUBCkIlL+X2KI/M0x/yIHnCKCrtwPA4zeCSav3KSUMA+bAEI1B9ymCm3rPbQi +SmltIE1leWVyaW5nIDxtZXllcmluZ0ByZWRoYXQuY29tPokCNwQTAQgAIQUCTBdx +PQIbLwULCQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRB/2fzLAAvu7kNcD/9WFW3z +QWqHf5mpbGQpLKGu3xSAEznbpzE+9igObP0UOxhE1F/cyZnUJ3j4NI2m6bQpxYuH +qc7JbgFQNgxrfh/QKjeYB5SNgyug5TaL6ZkkRuPu4XsAiqtmsX6uxs2PoLEoe5qM +UFoKy1ZZ8zueq1zh+T1hkG9Dzo9HSLY+mX023qx/yN91rbOu1rvwWsYEI6cNnOZm +cPQO7+TyoCR5v1t2F2+Ymw8hq0Am9fif9o2SNlbUMaWbk+ZPHfjWEgsPNF9F/aSy +/oxUJAKaJff2FaAXu8m0NhG8xO6L8LtmE30Q3Q5a+BDm4YIEMDKXJNeiHf8q0Xvh +C3eGsrrk+PxFb64fd/qzMnUVmAC2ciwnEMnFrcY6NLXLzK/iQuuOJ5Um8od3Vj6p +XzZth5+9FDB6aP1wk94SaZa0/LF8kFwN1oBU528mrzX9BtXv0db5459YqkUfXgaQ +vMpEMmPE7bmM/MBt55k0Kh42TMBo4e4LBTcuOoXIOKH1/g6aDbss6K9LyDasYRFO +23ZuLLP3hP9hv3GJOMIvKGJVL+LVMNsD+YIJIgsWo/JOgm9dx+skJgbo+clUAExU +BN5/7sSvZ4z1ouEIHuiUXfYIsTjfogmnhaM6b1HdssDvApxjzij+mMD3KiROI9QJ +UCyxL07E+YaAVSAbpQydd4qLWLeaiIQJYQEibIhGBBARCAAGBQJMF3S3AAoJEP3S +3qzTM8uhazUAnjUtO9j0xGFZaZmhL+5tvJjh90keAJ9O5MjqCTJOsOXUni84qlSn +QuOF6ohGBBARAgAGBQJMF+pRAAoJENoowjp5/0R0QekAniKsE8Zg3TiU+cufI6V6 +hgOeMXgXAJ4or+GsALUDn/f9fI143dPUA2Fu9ohGBBARCAAGBQJMGm2+AAoJEAu1 +FKXQbtaf1z0An38jBCqqbWPsvWLp7KeUCGcAqAxLAJ9p51qwLkIYqXlaHe1eRmXH +5n35sIkBHAQQAQgABgUCTBfu6AAKCRCnoWtKJSdDauF2B/9kAt7wxL8CSC0Fc7mp +9yMZrUSQuTZPRTvQ0qUfKgQ9GUWaATrzdrFJH4opIcJgWyBGsyvDCxRjsFLGoUeM ++aGb/MUw2wpJjwu6oKm5X8/l4jcYaLx7htZOfjCxtABZItWdxn1tHA9LjS2xywvh +AlISpHj0qXOtvgew5PCdbl33uoGGlVz0ygTIRRk8LpjatPcR/EpOR1aO9N7Yxw7F +999Qzzr6lHeBkcmcShaqDRnPa21kJ6tHRbZMW2AzTdP7TATywL3G6hFF71twpDOX +JSewtB/SsZIBdreQi5gUevEJVthaC0pWmfVyVx7O5XXuVybTmAcSZbzfskEeUVyB +bLCBiEYEEBECAAYFAkwfcIwACgkQVBRmvrEtwZskbgCg3FJeIH1HIhBf1FtHD2PK +suyGNRwAoIlpbX2YkJP8iKIHXTy1KoZc22C5iEYEEBECAAYFAkwiDagACgkQDdyq +MnjVJk6iTQCeLzug9kUWTT6P4MiB6xai7nsXmRsAnRCOmi6VItP4McHvOl+oFgDj +GqZUiEYEEBECAAYFAkwiEoQACgkQOFnAOy4jbkclEQCfapcNwr14LpBKNhaKamtc +kCfCy2oAnigrBj2IUzjagXR81qNvrMxdbKxtiEYEEBECAAYFAkwzQFQACgkQ8dLM +yEl6F21RdACgiiAR+820XdPOmRi7tvQvyH/1NsEAnjUjXb51B/Yw7CLH2Uhzs4HE +bIaCiEYEEBECAAYFAkwzQT0ACgkQd92V4upS7PRAeACeJcDlzSYERNeh5R0fKWjJ +c2PfFcgAoIGmgQMh86bmPj/z3TGTkl/xJQytiEYEEBECAAYFAkw0/ZsACgkQNmzw +ny5RSvxiBQCgkSH9Y+5rWhimuBp0oFevx+tZgUEAn2NaIk0JfJM/T4bTj3Wyj94k +jCxViQIcBBMBAgAGBQJMNOz6AAoJELzblbcKo78OO2oP/ipe9Ty3IBNZv36yJn6D +09D53eS6ZfJId/AUngImxapdzSU4lCmeYxmvcmP9gzvNHDZeBUtHYRaUzSsvBF9o +xBfIT5WAXYQToiKEsfdWLN58WlAQcKgsRzqBnVXtSPaScBmx3vJuZuyNE0lNB+Jk +eLPOCaFRAJfb98ycCp+MqL7qKW+GmDGetXhwYSXQrRpmw4yKq81G8S/5Y1W+Tl8G +yRWhXVimZLMOQ8HNmYGQUFDIyYmu75cLv5m4/18qIRe18+pFr9pYdLzsGx/oPsbT +UC5r+fWTBm/qVJzLQSUgfjTTmolLlIff50wHD+Mxk0mQQiBN1WWY/+5vg9MaqH1g +ujIPzGioZaPXKBfU85NIkiJ/jrgbnM8ty2FsN1pirwH+3AR37nHOMHVsvT5irJpW +MZg8H+VHOjYyMKikMp37VO+H1qyZotZuv+8AMmqw4GgFF90Bm0pVCzwyPaWaW0fe +/FwiWSXQZz3rvQy7dKbs+/4tM7WJXm3I2CxApxLQAlTKWR0ozZxFd+EJ5xOpnnM3 +N1Aw9+GlkyWsZTIKmIlY9aw4naySCGMNoUFb5F9LDet0lGmVI8JKyNqsBnXm2qT5 +yKuqIWeTSsZ78mTbEn18T9teJp1r+pIvisiiUgm8UR4NCFmEZuSzdPqZqCfe3koQ +DMfXQMTXhv8oRCh/Cf37E9E8iEYEExECAAYFAkw0/0EACgkQNmzwny5RSvwuPwCg +l0lfrLz8n1p8JwxFSsf2aAC8ymsAoM/d8O2NN0AdJAzL+5XelKikrddWiF4EEREK +AAYFAkw1DcQACgkQNak7dOguQgl62AD+LfblUSSDzeRFDTE7QhEo8k6UuYxxMiNH +e+4CXug9C6wA/iwoljL6T99eM3PkGs1YrEJeDj1bbdojzku5kZuyMfRGiEYEEBEC +AAYFAkw11WcACgkQcllesYFwS5NvPQCgxmZqA5hilAxmObSBZkHXcgPg91EAn0Xz +ncIQvQTZzQzlNrtjUJWmxnnriEYEExECAAYFAkw2B3wACgkQeVWfZ4E12xpaCQCf +WGp+RSwIoxRWKoA0jLmJz2biWPkAoKV3grmuSogrg/tfpdwdgLP+ScH2iQIcBBAB +AgAGBQJMNiQXAAoJEHa1NLLpkAfgDa0QAIMO0FP72pMy+LNB58MFKfRwyEPcySGQ +9Rcc1ZR3p0m66J8MQmqttELSu10uffjDOas+J1cC9eHGWQBvPrNqVztwvL7E3wMW ++tQZ4TrPNTinw6t/nq+Ct0vFELMlnUlMdG4koUIwJphs8w+F3PwkxJpN9GWaqBQ9 +7wic6ENlxUaC83m3JK0nTpo7K+9LONSomwPDIhhWYj69jKU9ngN5QOmtvOYzHp7x +446ZeyMlYamYPnxitjAg5mG8XFdwzMXhKg9WqpP3qq+f0Je/TnZgwbv27SvnClOI +jhr4dHbnVrUHRjYrMg6T4gqYvZpUvL04i3c8Qiszvy+38i4Q6Ob2a/3CMNx/cBd6 +330Cj/XbuprYzP1w2g0DMdCb6oKDCGyqsa5PoryKjI3c6+lp6rDL3te2TNtQvWXI +mFhkedurjr9/OKa8pozM/sdHj0wMkYqESKY14hMfyK5rMTuKnZ4J/kG7aFbwiIW2 +0j1KD41DXzMd7BiWRbS3QltF1CxRMA8JxkXRPbab0fY2+2uq/WyhZl0rg7+x+NeG +NnESYcP6o6PSGKQgwbnoLbqGLEV+q96onw46W6EsYj6mN+ee0Xvn4GsJ8G1tz56N +QvD/vAlYoDdfTSXMupT42mU7OTm1aGPbTUR0TiyF7y6SSdzjxh6v4vPdPkq/Dlcg +NCi18OL4QKlLiEYEEBECAAYFAkw2bcQACgkQEFU1x7wcLmB92wCdErVgU3ioBQdO +p9jmZ+gTJXGQGkMAnAuT1nUzg/Sdebbyp6lUCAAsewUziF4EEREIAAYFAkw3T/oA +CgkQ99XJv3ZcYeMP7gEAqC4UPJuBpbc2wPQ1OV8b03NArPjMrbDvidckNC1DXhkA +/1wygwTLyW+V/W1lEjz8OOYnxz2W7LpvNlj4I/bykxFziEYEEBECAAYFAkw6DX8A +CgkQKLX03ZSPZGzBWgCfX8eLIY/1esIQuPl8CkZ2eHww4fkAnibYhO2G4oHBL78Y +W70AN9ihA/DLiEYEEBECAAYFAkw7UmgACgkQnfmb2hFpETAiiQCdFEqbo2PNZ68z +UqTx4tvq1nrIABcAnj6bSHaYblqd+Mt6UokxNAXs3voiiEYEEhECAAYFAkw8VZMA +CgkQ6gUw5hW+n6XBXwCfVIZJnazMDnm7uqYx+Fdy2QRQfEwAn2+fdxrNfp/68kz9 +3KXWA+nYDuMBiQEcBBABAgAGBQJMOt48AAoJEF+lQSiM1NWaZ88H/0yB4bH5Wjce +h0NQ6zOjUzkKykW4pTFzcAKr1kEPhDnm2+Mx2KhFKlLQ2IB6TtI8/LRB1f0guv6F +P9QHuclmHi1ZaQnU117SFtOeUBHmdmEXyjkDEnPBvNGaDn8/Tbyng9Zyr2pGGaCz +aqg8GtJ1UvzMAexUkLIii0/gz8z6poVL5bl+ndPEtOKbkRQwydSHWqkouDbv7oPp +ikLpC74o7LFMTPAA2ro9vm1yIB3G7lw4Lwgverz5X2D74irvqZL2g4FA3L2t0qY/ +EvOoO2dssviIOxhWHWBEpoOfbRbarPTZQoWyPq5rZWyNZdYUC8+Vz9YKwzF9BDKg +RvmMlvMnJQqJAhwEEAECAAYFAkw3aYEACgkQ74H3LCmp1u/q8xAAiCmVLnoRDfMJ +Fo4FrQoMk/B6L3IgniSOcx37eutGnImyxFy4d+6dv15+83WhAhqY1xfW3zWuDKES +edJqDEfh/CO07lNMB2Z1X/t3U35OSgF413A8O0/zD8UuVstBrdFgBOSbksT5bJrI +CCe99aYMrl2/VoF5TH2/BPIWzIMo704xXidFModXhUu06Mo8iujhLcUd5Q0LoVdH +A4snbw53mUK/YRoNCyG9fKO07ztSxv0lIdpHY5+SGHMJQwJtXGQ5JemKC7eCRfaz +7L3+/hXq8+7vRseLzpuLrUFAf/qdp9RWhPbuTrHMn/CizqRjVhCpPmM5CX8P6+3y +YVjyWOrNq8VcY09p25sHufkmYSvEbGbvVhdPf69EdG4aaRAMdzzAy7GUjx1EZy9b +9oh1vAk5iVmnAou6cfcsgU7J7q+TyOkWfK0+9/8aT+PDLQQcsn0I90xfePeCaOqk +Io+giDC9NlEaXzFPoF0yirpTAzbOJbGFpBxa2k2YSxIFLTqrlmpcj/PMUNEP1acg +vaJhrabWWFKz6m1Aro/xwX5zwP7IcJIk+2JAxIbVnNIq8F7slMxl3uwrqEqyJ1OC +tqmXWkLzoGV60M915EdHWF4CEAFp3Jkf8zIcvKJ4L2nKMMfGEtUO5SKjcsW3yqZP +t5sF7uu1CKMYSz4IipPMxDfltNtCGTmIRgQQEQIABgUCTD2LfgAKCRBewqd/NuzF +I8VDAJ9pJfya8KHvEPcj1lpnyh/zByDH1wCeJRLKGNWfVJ+42M179/7U5+NgKbaI +RgQQEQoABgUCTD8k1AAKCRAOp1a1FEhD9RcyAJsFKQTaYy7fYtPPmrbolI4JsvB+ +UgCgiTxB2FgsqO/aQ56s/o3IS/fmxiaJAhwEEAEKAAYFAkw/JOkACgkQ0w3s0lmT +IvwM4w//QxVY+Z+U0N/y42eyiWMIm9geLfh+BSgX9EezmeFCY2EqcRDdMuYAUOeb +BM+H2CkIAAnCiHAIqfSO3DLjsGNmBYnkPLbKX+yGjxCO35wEkH9wyC6bNLW9xKHV +15+00mGwKLUw9WmC4BwlNJ3fgkqlxjqGsOlMFs+DXnSlBhWzQffXQ/kNZ0CSIj6k +kiN26BnT+B1856v1RqMH0xfe5hhRywyMx5lZiNYEg5JmnJBjV2UCOzL1+bbE1YCH +iG6lHkKDB+9QW66B1JWWtm1wZyVxtN4u5T5ZEs+xUvWXqUfH+A8LZbzlX2bUG8YQ +1/t3sLG6HIRFBGa0bMWaefVvR9FyQUwh8ALoCNh6DRtmdOZwtFFWkXyDufBmSx3A +3seitvl7cM2fH2LkVis56kuSp6NR517ZWMlHefRcy4XPk5/1VXdT8UNHhbKMQ8jA +3ss7CFkkMZQ7gvd87914z64LnM2QU4sskAiKSojYAGQExgHLwgnNGdFyuiyug8iV +C4QC+K481MKEIxptLdmXbCFQhi2P0C9byd6ZYmToViQHYP0Zq38KDv1L9ILIv+ex +ffkc79A3uZEhjQ8qW2nlt2hZm97gkfDL/i8ulkE8gnJoyAT84RPCZKsSJoDdLqI2 +MYNLft2Ge5D9rm/5+AdFVLQHuwCQJzJkfaRZkKsKxtKQFDpl8FaJAhwEEAEIAAYF +AkxiGgwACgkQ5WK9lL8DRF7YQQ/+NpmCPCTH8gUhMJJv+F8XePMzz9flGC2ykVZb +cZ49Q6GNLNPrMHlvx9qFKTKvdr6/VRUIe1r6pBD8cawNxo8AuVxZ0b+dypnqPLGa +YUKXQZcHwLEYkHONfVBlZQCrZQ42j2d9Cog7B9Cvif5vOPDltqMeZXKpHk4NHWff +RIwqEDWMb+tQQeiqeQZcPq+Tca+zz20upmXyiKvvQypyualirwfxtTaKgJrUOCQj +mRQTH6Fb03TVN9xcbWrvYIfjOiHM1EgHkcZtz7oCRsFX3SgXl3iz2st4RvHLhalS +IOyCmrSux+ndq4qz6fzTojmS00hVeithAJSzvJ+si6kraVtf5jZQNK5uKVcEISGz +kdi9+QyixmnSHO8rIciQkYONmPHLQH7bf58wXAD/vbW6o6u+ONVX8/nxAi9aitTE +232E2Nf4CXJf1fkm7iAVrc4HrYk50VhxnXncqDHB0kGxaNRLi9IslF2Y7lttoLlG +h3+vVkPM68nm+R44cZQZA42hvKBRgFkQgPvB1VwjwsEtf5tVOo4cQA05tQlziDVO +wrzf5f7EAlcoYUXrl03/wmZtJ2hMzfBnC6xVIeeZTeR92liBnMr6huNyjzQkTT7i +pAg8Kd8jKD+1IRxxHAruOgyVGf/ML2J1Ib/jRz6yXRTx3GJhBR/2nCdz0EIucHg8 +5mX+8w2JAhwEEAECAAYFAkw9l3wACgkQ7G5w33wIpmKoTA/+I3mfvRxZHgVjSfcB +pK9hXea1qKKx+Sf87bspZCNJ2tVqBcKgp1GYBFkEWzVAEMesuYNDtS0fw78b1A5M +7vsFe8OyT3OF/v1nefKHXwnxLjH6ZYy6ob32Tq7qGws3j5ITtVnTaELzxR9w29JJ +JkeVd9yuHOvA8i7X59QZMa4+xVI6Pnz2xDn8YzUN7kxZRd18Khx4tC7VstkCDF5v +NwgjuSWVIVaymkBM+RhfqtcyxDpeAynVZ5j1EiMKj/0Mh5AbBxiyOsJ1RqHmV7xw +gwvzE3IET9Q+Etm8vm8c4DYm+jnNsciGdE2UPXTnJ1vSbO4Ak/HHF2KFOAaok5GU +L/amea5cPor0pPUu389O1AGngYBT84p9IgXY3l7W/ORBVSyJ3l18TUUg/nbIDUVj +akU0K7BNJqbcic4a+9+EBUsxgMNOssEPMAz+RjA5NaBDrbY5cxfW8lHNOsfp4VVR +evr+R6UImLFTJXxGKI+a8oIZLnERxCvZzIm8K7FezVaCead2PJp99koS0A+/mgcE +uNA7a0zKu1dKsKYUvyxTaK03XgjurchrBZ9AhuNTrZ2r51/qDN0HG53df7KBM+kN +v9yZ4y4nUakqmBYLYXLQL13vW/2239WKoc1RdI56zwVy6W+3qHmKa5EJD7YjGytW +bjcgsermH99JDMUggKu/uv9/ePO0H0ppbSBNZXllcmluZyA8bWV5ZXJpbmdAZ251 +Lm9yZz6JAjcEEwEIACEFAkwXc5MCGy8FCwkIBwMFFQoJCAsFFgIDAQACHgECF4AA +CgkQf9n8ywAL7u7dXg//TD0dsvwMl5gGSJspUHz08vwcM9zp2fldabi1GMC0q73n +YnoUH9wHLVcPJ77CRqh+9lyvd230hnHPPbMksg/L6YetnVAo0NUz8pxx1hZBw8fJ +Dvl4NxTgs8FbwtxL/ZnAs/RHzEEiECbWWnxaEWYuZAGD4S8u6fnzNfPCYbf/dCEd +O4O+FIumPoJCJF9orHd3rvtB+P41YKaY1+K8lM02BoY3fXRwbCvX1Rn965/BtIJi +UDJLxEXUk2Gq6pZ9zPcHKQjHcGs+2zS/Z6wmhuTEhFmpCw0jIt9rzMs5i5JOB0eq +LtKD9C6tURA1KK1eXUvE4X8F7kaXkfPXhLzdLZskTt0kbNr+YU5AZtEDWplaw71t +376JKOyn7yLqYLJLR0KMmn1DpU4kFSMK+zufLGo0gmp0054hwBqM0q8V69AhfJQB +/AV9MnpJ4h23N1kIRxfYMThZr29PBFR0xkq6hOW7sfbZmQDL8j6NaMKWVJx7cFDz +MkXXGozuBltjFGa+q0Vf9QpDGiMPXIUz9elRZQ/pPP6ha6pycpElp9LJ9DumBAtG +2bimhhlEXNP0L7H5TQefDCgmfVY2DuyxbPP5knAmvEW4pEXd+UZ+epsRve5mu8yA +Hp+vznGM+SuBp1sGUL5VmkFtNnpXhW6hco2s3egz7hZOlsH+L8BbAmw5E+tGfP6I +RgQQEQgABgUCTBd0twAKCRD90t6s0zPLoTREAJ955TZVF9yGQHg7FdFDknY8tnPn +MACeMygmnbSY4+gePm8nodkRsE8FEJ+IRgQQEQIABgUCTBfqUQAKCRDaKMI6ef9E +dFNKAJ46T11pbgFx54odsIazJ3N4/WnydQCdF19aQQVKm7+1oo7v+tGiB+MN1niI +RgQQEQgABgUCTBptvgAKCRALtRSl0G7Wn3yVAJ9jrfarvo+izVqVAneZ8IoTUbg1 +5ACeJY9J72jjQLvTLUhUIzEkj9hiCxGJARwEEAEIAAYFAkwX7ugACgkQp6FrSiUn +Q2pWFwf+IeRbgJ/xvh39wy+VFkbcfkZr9ejfIubrQr08Kd7wd3gxt3Skd7xqgkI9 +iF/iFvoAnB3uJt6+k+PDUAPneGoqtnzwUfCzkuEA/7lnv/A1WiZA5iwZKe7/mvXF +ZR4+TmKH1J/CPWQXWOWZ5+szRosAeWIwHDMdHAGDE/xPIDNsOiH2lW+awQYC32to +Ye1Ocs+hSgDxHiwHvL5rEHa5pxuR/05l46OUw1h349Oeck+FQZiQUYuwJWdLiGJC +DjxL/k9Y6c2anHdAcR2dNzfSNi5Sx6+9lESOqnOlHEyp78c0BoY2nMeCd8Nfr4pa +lvnlIvGQKXb4f67UGn1E01PFQCIfP4hGBBARAgAGBQJMH3CMAAoJEFQUZr6xLcGb +iJ8AnA3zWLxof7rtaWjuDTo4WWAoqeJmAKDDY5gHguwZxIVfBU04NvOXx07R5ohG +BBARAgAGBQJMIg2oAAoJEA3cqjJ41SZOmlQAnA1QfkU07RUFZ8T+X4O4J6Ovbk49 +AJ0TFi1pFNdl2gNr1ZFgOk4DSCY7e4hGBBARAgAGBQJMIhKEAAoJEDhZwDsuI25H +eo8An3JqUU6wHgJHieN4SZd5kRg5zEyTAKDIAaDTXfrYu4RfLeMvIkE7xRyPPohG +BBARAgAGBQJMM0BUAAoJEPHSzMhJehdtaJgAnj35G3QSydUyPmShnRe4dgJL4b4T +AJ9lhYBAjBLPTegatr2hQQ+vAySxIIhGBBARAgAGBQJMM0E9AAoJEHfdleLqUuz0 +wLQAnjoLLqtv6Pb7IL65ZRVMYQ+tbcqNAJ9tuca4QamQFBN0HyikGKueDa6JN4hG +BBARAgAGBQJMNP2bAAoJEDZs8J8uUUr8PzUAoOfFHxOKeVeqUnpbIorBMchhd+zt +AKDl5yf0WNWKXaJTxDvsoWToh1dqf4heBBERCgAGBQJMNQ3CAAoJEDWpO3ToLkIJ +Z4oBAIItrGqmd1X0PuVqGPM6/ieqgYH8wuD5sPCvsn5GxvQYAP9wZTQl5J04pPH0 +CRuj6neZRQwek4987JBj/PgisquxYIkCHAQTAQIABgUCTDTs9gAKCRC825W3CqO/ +Dml0D/9khYl6WvXJqPt/3vKloDaeTUML0d3/73DTqQqBfSpX68ey6yYJ1CR9EIru +v8FQ+1daPuzBzgMYMTjSUn6/WizCNCidBSHm2DYCRpxnthNzM+uvTUuTyc8LdrdA +f8IK0zDA34BfU8AAZ8AfisiWAtXi0wkiO9WAR3tljb5sRxzUunAB1BcTJJA8yziV +YriK29itCRFHjQQwSG8R9B4tK+Xfabu7v7ZvIbJfZySj6OUcvemFZ8wp8tdVESBT +jMWg996NlbvH+kXDR65X3PeJFOLsRqAVZUU9AAh53JRHxIUNhNh9W4N6FcalaTlv +jRrv4cE8we1/rmgTlZELRg+rjOSTqVAFMXmnJCH8bIp1B0hZ80tHPRDWB7VPR8Q8 +7CX0pXAs5rXJP/nvqaDFJwfuVJnKZUxRYNjVXGVhswI5poGhRQ49LyaPI+M50mf7 +xvanqQB4yH7GmYHjA4127yi4utzKn4/o76CwSoNO4bBfW4CSIykCaAd+xuHfd78I +DSb4u1JLxYJFbixr5l3gNQuQ7jRqUKHWzGgVeuBqI2FrAi7mC/3FPjAyuXMckWUu +xAbOdfn3auY3HIfIJurf3euN3Ow1ahVtWTx3lF174WfGzfpzC+hzprSJ5X38efSP +iwjkWPCsDU3M/UYckmTdZpVwN/lGz7SKW+aonqHMOcMCbIVfVIhGBBMRAgAGBQJM +NP81AAoJEDZs8J8uUUr8xu4AoMtNvpHoT5SjVacGmyS2BKZ3RvcmAJ9MqCe/OMsM +DfXr8Wr+cmaWl47Jt4hGBBMRAgAGBQJMNgd2AAoJEHlVn2eBNdsaFAgAnizWK7G6 +ew9td9V6/c5ltGFhem9HAKC7M9E9RRfEBIvI658BJR+OgWTYwIkCHAQQAQIABgUC +TDYkBgAKCRB2tTSy6ZAH4HK8D/93W9znlCk/9g/47PVokPMH6S1OBUhlMFfxNp14 +Q3AHZxN0UnFCHudqO9VETaS1+OwK07wm61ZEqh2MuhvbU5JESu8yZAoRi6AZuFlw +4xVT768gf5qV2RMk7yEgKWo2yesqoik0Lm5L9XYQgJ7Aw3dmEiwSaTtSo9x9Ybj+ +mP7hidlDGJChOpf+jOjWtZFCOi2k/i0wFKtHHJXQzprWmNZZfRLsJ7medl06D+Zs +85tDDSzQG9qsbnDrDHrHZOZSykGWHAv9dU5tUctdenx8bEKY0jToRGWofv695R1i +Fig2QK2sfS55l3GyygPqcw8LvxVfUROu8pYRUINaQOjOubNA2Cl8srMsYVVAoUOB +Ih7rpKKAEx4eqOB8poUmYmQ3yXuNoBBxTK8zw/SsQ7sxOhxe0RXzRBWuL3V2KY+G +1BSTVfTBTIk2HITZQ7atsj1K011tyMycfWnOy+8x+eN3+kk1ul3MTBQPwMS4mDxQ +8cpSMY/p87I8goCKc9lvi3GGoOL2uNcaSvPsPxKZTTyVYQ/nAzkTjDsMQaY4aI7W +vCffLSokKFDVk4CW8gbl345RQGQpXFHHoEJL9ApsjeCk1g/TtPPjTUCV7PkpT2L9 +Rry7PDICjmStSZtrHaOVEwmA4DBonmfgoostnSNPamn2I2wicWx7ZQ8saFbTe6NB +XJ0wfIhGBBARAgAGBQJMNdVnAAoJEHJZXrGBcEuTNB0An3TGlrkaY2DZsww07w4D +ttxTZE4vAJ9MDG//IXuvdG+qqX3LRtRIpOqTI4hGBBARAgAGBQJMNm3EAAoJEBBV +Nce8HC5gkS4An02WqiMoNtuUONNy9wrqrXTdL7nzAJ4s2A6PbICoqI16jI1eocBn +R/2bUIheBBERCAAGBQJMN0/4AAoJEPfVyb92XGHjeVkA/RBAkrDdh8HJvnEY3yDe +9IsGPVbON0+c8ZKnJ0CnLj1sAQCodZyhrNPnCyJ6dm9vpsev3r1pfJViVl9LM6p3 +wcCqd4hGBBARAgAGBQJMOg1/AAoJECi19N2Uj2Rs1s4AnRq5Ql/VCD2KagJ5roz1 +iTPOR2CHAJ9naBNevp3awRt8xfyjiXkzsf08b4hGBBARAgAGBQJMO1JoAAoJEJ35 +m9oRaREwX6UAniI/SfuN8ii8g3QbEduuzC2ubeN/AJ9iFa8yhkxcqhOQk15hYxFb +V6pl54kBHAQQAQIABgUCTDrePAAKCRBfpUEojNTVmsDFB/9s71u74Pg2wF4pqzlM +wj+01LftYcFcfZAnvRDuMjAcGfmu60tFzFvg4M8o06Mx6fNjx7PZOmqowp7rdHfW +HpJ6j6Ygd4H0yDCUYXvFoKuYS6IzxxK5iAruDSviswNPMjQmKzeaSluvCDGwMOUt +Vxy6rirZXAEdB6NzORJ0kniksPcyWrda7geR+Zs9ZRxhd7Py4uGKtKEyy9dGQWSX +6Nc65U/RBJYCwgWGIH/QfiSs6m+brujLRgBdO0dHza35PQj6mtvCrq6GmWY/q1GQ +G3WcesqEwzR1j3P7WMO/rxhkvFDfVg1RKIilGG0Mwonq7nY2GEMTsB16qc3Z1v8g +D7dgiQIcBBABAgAGBQJMN2mBAAoJEO+B9ywpqdbvWuQP/jHxyFHXBpMTqwYIKlvC +YnJF8MvTVgQmPwV2p7Wo+Rd9sGyxYI/aSnaJ4BiimKdpMWIeB/bucOUcYMdCrWiz +x+S8Dgx4X7IAxT3nVot5YyGIQFnIs2P0gSMf3oiNcL4nzWmdys+PBKAtApKEOvXU +iHsulAkk3gGORSBJl6hiFYviKMyObLF+csKnLfPXvZpi4rfl+vzO4vjzy6x1p8p+ +E/IpRpwH6nggmI8No71ZF2IzpEmhneEVTaKv0RWxV3qrmCabdMA+7BJNbBCpJ8Im +mwjqpB1F3dLkzG7OrpTN70pw+d1zPlBnVIXKRUra8MOEr+ResAvMuIH7et9P39Gw +dMwkO4+Wp2f4hBp3k9jiFNcvDOsdCmkNUjI2FgxfT6dhPYs681Sk9PPKc7fVm44m +PFk4DzjTFKX5hPoMxamhjyOMDHqljSgOQTOpQchM+ttNU8vZc06SEMbesikQpJX8 +X5259dw7YpHHm97V24xQwVRcM0LFcjbbph6kGrH+kgXxAKqum+qdTJFAWv2rxr0Y +ZC2KADxlaAZf2CeFiA6YV0eKjIkeHpJBsq+idfCYWlO6Z8nWKnJJaDYBf9ybKsow +keD2Qjh6c7edY+pRJLenmh5m1mGHwZj0hfZT0btGP7vBg1SZXBvKrY9jjeN3pVmy +DprSa179itYIrh76s7qEngoMiEYEEhECAAYFAkw8VZIACgkQ6gUw5hW+n6UeUQCa +Amj/LQ9PrJKF5MiItGeMMLW/6MYAoJ2q9Za55Xb0TsIUi81wApAvvhLfiEYEEBEC +AAYFAkw9i34ACgkQXsKnfzbsxSNu3ACbBX1PMJm3mSvr76FM8MhKKxmw3k0An3DY +IWMo1YttFtklOPihvlCDjCboiEYEEBEKAAYFAkw/JNQACgkQDqdWtRRIQ/XxqQCe +JWi+L7UcaZc2UjR9H93Np9JRZ+cAn1FZGaVWM59cCBCMTrrtGWBH2Fo4iQIcBBAB +CgAGBQJMPyTpAAoJENMN7NJZkyL8lokP/ivLHIv7ozmQ87hsXJLvIETq4iRCzXv0 +hUG5UBY2IR88qSXNeeozjqgUlo3Y4xMkH6la7m6ce8gmDpQa04MCnxebP2tSOzIT +Skr1bNj4898gwg/iR5Ks/Sg+mKvzKRCRL6Uv/tfA3fDm/rRTTYyAIHChJyu+SiaG +lFzKzOQW5/qSaAQsyoegXfEcLkxMSUo71ZhaS8mZeAmtY1GFviTCBgh4lnf5Tr37 +qnIVlZbtqro1Grm7SZC+TDmVZweMJGS7iEDEZEP034PYc9xHwLp2AWia9qScX5MD +133GSDwiKF4Ma3BBQwh10DPRj9CX59lgKq3kmz79li9e/khFjDOAT8zw25vwarT/ +DVFuXbGGrGIHWuSGSQ3GXEJT1i98rpMM4h9ahq7evmKqGVOvrDV2/yeAyIA8OgbN +3v1XyqrGEo7oCLFM/Ayc2AKwdPVjMZsI2eSdyjJc7TyyB4oBcb7cuJ6grLWZKkbE +1YCaK/W7p6MJyJIW7OT/vmxX/4HYhuqWMAg6SKJLa4MvN+zLUYbO2CyvEHwn753/ +G3pYvuyheFDiMPDG12T9j3eTmKE9KeZF8ywmMhrJOYveMtZRCwFqp5Pg9tCK83un +fIDRit/LK21UC7otNXWEDvn9wZ8CHWBhuEuzqHz2GwpgwhwQzAgDQctJDKVPSTM/ +BuBC62ySNE6JiQIcBBABAgAGBQJMPZd8AAoJEOxucN98CKZiWRMP/jFc+eZz4Ckn +YUT/ZSxVzxDbsPbtfVLFhcE6c23541XSZqh/MRvuL5tDmcmDLlBxBBi8FSsE+x7e +DdGwmXFgzxcoLRCQEZuhB9PRL/3ZpHUnfK17tJIX32Xk7H7/vZlE5spUDKEVWiMG +aTkfEbDbgF2g8ftOefy6fA1JwXzHpICelT11hGdN7FzQMaxY/jZvEgymmKi0p4jw +QScgdxYukQY0aO80jak2tgPj1xSyylV/LgdWwOyQsCIu/25HCr++Ucnu55hJsBGn +JZps18iOVyYu/wxwKrWqN+TKMpSOIojRR/JI1H/r7xf6kWMHNtngvvjvRiHWs4+5 +GaeiZ/LFBA0pbUMILPKrmISWJ9nYHp1WjOlGRsKfXTg/beOwfGUxzf1TrwVDHpHp +jHqEKiUIpS2EI6Pf1aQrV2sebMJBjqMJDL2Ri1Y/Kl7OaZL1fVHjAv+YsrWbEJwY +k/IVhHOOnHpzWX4l9nLb4fdhJRm2OPgSUwZ4BzFPHTpuTD5gAoUsO/+kr+82efqH +AfCzS1F3zCL+g+IUlejaKm6vxUQWDy/4ONNzgmi/9Nibifn4RGIW86/3yAao08ap +8NhvPyJMW3UqwlQOAC6jtQExBOhOI5+tnWAuNRlqAUG8U39gGKLiRFfqTdFQIJjr +L7lK987RIZayL0odb+oCJv+R9I5fu9Tt +=+qse +-----END PGP PUBLIC KEY BLOCK----- +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.2.3 (GNU/Linux) + +mQGiBEB1KrERBADU1IBijt9vm6mEvIBr09HsO9v9cjBpl2Ot04LsUeuWTjpWuqCd +ZxREWyhSS0cRLWIlZhgjJetmXvrwdfwolj/qMWi+WiXyZ21XKMeRKIXGv1y+JQLB +GP1MMk1wJflKrS299xa4hrBD9p6ZCF64FgKfL9i26EO3LADhUtr16Np+owCg67nV +WGUkGzOrzClYZklrEVx13NsD/02jqGkTF0kF3koatXw6yy7HIN12PZI3AeRDYKSX +d3Xdf6NYVkGL3Nl+V7JHqnqUtz/NrI/26BDCDJzcU2yB2vVaXdrlJgZmLWwCmUdD ++7R+JKKWFOJ92t89GOcxwwq1kE3CHPbV++Ky8BzYkW0zgJL54PzSEKVRJHgMlvld +LKQ4A/9ew+dBhN8X0it80amysIw1L+kFBndXfYeTUWZfielbwMTtRsbwf8qRX3K3 +7I9z0xA9RqOhAcYFlj5G+EigS6WPrU/3P5gFwb4A/C8kkn5mv8+Q0TJDGe35u5JP +DcPQXU4ll3Wz6K4F/RyXOKOLQKvmPLhbiCKOEEUsL5GAxk5NIrQbU3RlcGFuIEth +c2FsIDxrYXNhbEB1Y3cuY3o+iF4EExECAB4FAkB1KrECGwMGCwkIBwMCAxUCAwMW +AgECHgECF4AACgkQDBe8uQWQm4jlQwCeNrPraM9QUzQx1aQFlS+WQ0EoGkcAn1fE +fNxP2i1ut8tLO1/suRPtK/vzuQENBEB1KrIQBACYhNKV63mpCAWwUewIYnHZHBus +UFgsVjx8/fk/sgML1fUJDYNjEqWuyR2HK31+weFfQ3MomtP2NANflXVVi7dDA/4d +CwGmoPYqDGYQnTb2l7Kpowix2tLyss6+zd6Phpl6OccKrz/EC7P24Tl5wik5cZC9 +rHtb1PmNhCxvGYCHlwADBQP+Iu5+FGqilE4V9CmAVXKAgqNqscc02mXtqAOohcgP +Rv0HrP0Yc9D7gTz4TZaU15/m9ah5Tl1lGsVvuFy/E5O+ISv9jU+Armo9NaMEMZZU +LAF8iDhHvEysbIlH03M7HUFB0//g5kFWjIbBIrHj6aRL2bOgxO1tVJfUCAV07dvS +YbeISQQYEQIACQUCQHUqsgIbDAAKCRAMF7y5BZCbiL39AJ0YPZiWgKRF/tbHW0d8 +TXO1rAMObwCgxLu3MlxSxL8WW5qt+hUGvNt+514= +=Ala3 +-----END PGP PUBLIC KEY BLOCK----- + + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.4.10 (GNU/Linux) + +mQINBEyAcmQBEADAAyH2xoTu7ppG5D3a8FMZEon74dCvc4+q1XA2J2tBy2pwaTqf +hpxxdGA9Jj50UJ3PD4bSUEgN8tLZ0san47l5XTAFLi2456ciSl5m8sKaHlGdt9Xm +AAtmXqeZVIYX/UFS96fDzf4xhEmm/y7LbYEPQdUdxu47xA5KhTYp5bltF3WYDz1Y +gd7gx07Auwp7iw7eNvnoDTAlKAl8KYDZzbDNCQGEbpY3efZIvPdeI+FWQN4W+kgh +y+P6au6PrIIhYraeua7XDdb2LS1en3SsmE3QjqfRqI/A2ue8JMwsvXe/WK38Ezs6 +x74iTaqI3AFH6ilAhDqpMnd/msSESNFt76DiO1ZKQMr9amVPknjfPmJISqdhgB1D +lEdw34sROf6V8mZw0xfqT6PKE46LcFefzs0kbg4GORf8vjG2Sf1tk5eU8MBiyN/b +Z03bKNjNYMpODDQQwuP84kYLkX2wBxxMAhBxwbDVZudzxDZJ1C2VXujCOJVxq2kl +jBM9ETYuUGqd75AW2LXrLw6+MuIsHFAYAgRr7+KcwDgBAfwhPBYX34nSSiHlmLC+ +KaHLeCLF5ZI2vKm3HEeCTtlOg7xZEONgwzL+fdKo+D6SoC8RRxJKs8a3sVfI4t6C +nrQzvJbBn6gxdgCu5i29J1QCYrCYvql2UyFPAK+do99/1jOXT4m2836j1wARAQAB +tCBQYXVsIEVnZ2VydCA8ZWdnZXJ0QGNzLnVjbGEuZWR1PokCPgQTAQIAKAUCTIBy +ZAIbAwUJEswDAAYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ7ZfpDmKqfjRR +Gw/+Ij03dhYfYl/gXVRiuzV1gGrbHk+tnfrI/C7fAeoFzQ5tVgVinShaPkZo0HTP +f18x6IDEdAiO8Mqo1yp0CtHmzGMCJ50o4Grgfjlr6g/+vtEOKbhleszN2XpJvpwM +2QgGvn/laTLUu8PH9aRWTs7qJJZKKKAb4sxYc92FehPu6FOD0dDiyhlDAq4lOV2m +dBpzQbiojoZzQLMQwjpgCTK2572eK9EOEQySUThXrSIz6ASenp4NYTFHs9tuJQvX +k9gZDdPSl3bp+47dGxlxEWLpBIM7zIONw4ks4azgT8nvDZxA5IZHtvqBlJLBObYY +0Le61Wp0y3TlBDh2qdK8eYL426W4scEMSuig5gb8OAtQiBW6k2sGUxxeiv8ovWu8 +YAZgKJfuoWI+uRnMEddruY8JsoM54KaKvZikkKs2bg1ndtLVzHpJ6qFZC7QVjeHU +h6/BmgvdjWPZYFTtN+KA9CWX3GQKKgN3uu988yznD7LnB98T4EUH1HA/GnfBqMV1 +gpzTvPc4qVQinCmIkEFp83zl+G5fCjJJ3W7ivzCnYo4KhKLpFUm97okTKR2LW3xZ +zEW4cLSWO387MTK3CzDOx5qe6s4a91ZuZM/j/TQdTLDaqNn83kA4Hq48UHXYxcIh ++Nd8k/3w6lFuoK0wrOFiywjLx+0ur5jmmbecBGHc1xdhAFG5Ag0ETIByZAEQAKaF +678T9wyH4wjTrV1Pz3cDEoSnV/0ZUrOT37p1dcGyj/IXq1x670HRVahAmk0sZpYc +25PF9D5GPYHFWlNjuPU96rDndXB3hedmBRhLdC4bAXjI4DV+bmdVe+q/IMnlZRaV +lm9EiMCVAR6w13sReu7qXkW9r3RwY2AzXskp/tAe4BRKr1Zmbvi2nbnQ6epEC42r +Rbx0B1EhjbIQZ5JHGk24iPT7LdBgnNmos5wYjzwNlkMQD5T0Ydzhk7J+UxwA5m46 +mOhRDC2rFV/A0gm5TLy8DXjv/Esc4gYnYai6SQqnUEVh5LuV8YCJBnijs+Tiw71x +1icmn6xGI45EugJOgec+rLypYgpVp4x0HI5T88qBRYCkxH3Kg8Qo+EWNA9A4LRQ9 +DX8njona0gf0s03tocK8kBN66UoqqPtHBnc4eMgBymCflK12eKfd2YYxnyg9cZaz +WA5VslvTxpm76hbg5oiAEH/Vg/8MxHyAnPhfrgwyPrmJEcVBafdspJnYQxBYNco2 +LFPIhlOvWh8r4at+s+M3Lb26oUTczlgdW1Sf3SDA77BMRnF0FQyE+7AzV79MBN4y +kiqaezQxtaF1Fy/tvkhffSo8u+dwG0EgJh+te38gTcISVr0GIPplLz6YhjrbHrPR +F1CN5UuL9DBGjxuN35RLNVEfta6RUFlR6NctTjvrABEBAAGJAiUEGAECAA8FAkyA +cmQCGwwFCRLMAwAACgkQ7ZfpDmKqfjSrHA/+KzAKvTxRhA9MWNLxIyJ7S5uJ16gs +T3oCjZrBKGEhKMOGX4O0GA6VOEryO7QRCCYah3oxSG38IAnNeiwJXgU9Bzkk85UG +bPEd7HGF/VSeHCQwWou6jqUDTSDvn9YhNTdG0KXPM74aC+xr2Zow1O2mhXihgWKD +0Dw+0LYPnUOsQ0KOFxHXXYHmRrS1OZPU59BLvc+TRhIhafSHKLwbXK+6ckkxBx6h +8z5ccpG0Qs4bFhdFYnFrEieDLoGmnE2YLhdV6swJ9VNCS6pLiEohT3fm7aXm15tZ +OIyzMZhHRSAPblXxQ0ZSWjq8oRrcYNFxc4W1URpAkBCOYJoXvQfD5L3lqAl8TCqD +UzYxhH/tJhbDdHrqHH767jaDaTB1+Talp/2AMKwcXNOdiklGxbmHVG6YGl6g8Lrb +su9NZEI4yLlHzuikthJWgz+3vZhVGyNlt+HNIoF6CjDL2omu5cEq4RDHM44QqPk6 +l7O0pUvN1mT4B+S1b08RKpqm/ff015E37HNV/piIvJlxGAYz8PSfuGCB1thMYqlm +gdhd9/BabGFbGGYHA6U4/T5zqU+f6xHy1SsAQZ1MSKlLwekBIT+4/cLRGqCHjnV0 +q5H/T6a7t5mPkbzSrOLSo4puj+IToNjYyYIDBWzhlA19avOa+rvUjmHtD3sFN7cX +WtkGoi8buNcby4U= +=AL6o +-----END PGP PUBLIC KEY BLOCK----- + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.4.2.2 (Darwin) + +mQGiBEcsAVQRBACvCz/Y7op6RCGw/1DtcIaLOv7ydAntm3tOUITlqPezNbXphwhw +C+ulhFzBjNYEsY73k5bk5FvGXUBcD40cSdDVjDLQizZZP/pIQoCv3YGVjPGlDmqr +IMzRXJqnYfSyAJ6T2OwqyAqVurOCiHnhXUZ6yLC7qGpDFJWPIJqQ67m8TwCgn9tQ +JgidJD9uB+kqoYnm6BUlcl0D/i+tjKakl2gHRk3ZHFV1T6hGFklY4EzacySa2duj +dXXeQsuDEgRd8BI0uitLd98w4yVBLPw9kgO8KK++ng6IcPvBk9XiF2vkg8m4uIim +mAVYaHW+RQNS8nrW+JUkEor3FMFCgXsgiOwDzMiugTeB6Z1THpN9TOMPRimAAuAt +EnQrBACrk3y1JTOXBp47Dm8Mh+q8jiOjMMrqmuSQJU0lcSOasi62v7MfvJFdUkKd +eeq+x7BDmG66+EDCiUl07d4w7t8dCG/kn+soHYgQbPGuRWMIdp7tRsEurnohZr8/ +9owWLcnOPrCPj09gYBFSXbTFSocb7Dphzu4j2YGJpfgOs4SAZLQfVG9ueSBBYm91 +LUFzc2FsZWggPHRhYUBhY20ub3JnPohgBBMRAgAgBQJHLAFUAhsDBgsJCAcDAgQV +AggDBBYCAwECHgECF4AACgkQA8eUpJ91nuzjlACfX5HOJCAnr3EBVlmw5ATwJaes +ylsAn3Gcsknu3pn8TT/SmAALGkURGW/JuQINBEcsAWQQCAC1jleIwq7AyOP71XjI +uiSzK2gVZwwq20vkXDass6FrnxMk4X1sfsqdn2bHkV4bd76rkuU+Tupk8JgUB6s2 +od8slntmgcx7rSPFY2c5WioocGo39JFZD3r9JvfTdhbpBlDHLXVNpzGAB2cp/Ucj +7idiCpD3/DMHE9EVyiEuh81YCQG+ELqPBewMiXzgecJS7FFqMosCmPnErmHfjoJ5 +lUAv8cQFsnDW6CzS3NpCA8P0mu0u5qKI6Yx4aHszAED3FO4e8G+Bni5eZhZAHQqj +4//0hU2ccSHoJ9T5/aJJOwe8AwII9wPZwu1hERVKDk5ND3feERlQuPIJP+tjICuk +NcjHAAQNB/9XWwbAKqAPDe3iYY4SCsoqjtUqRVbU/AbQmq43ujoZQeQiDNOugrsI +OuTgARyVx15t+qZWrEBZr33oes3MfAZEvKRfQr3Qeu/A9k9bQvZ0le/RSOCMCnTN +JnsT0vtZNN0i8YE/Kb8LMf0hJeIsJnDo+7Vo4LFE/os4WcCpxXAPdPe7iQUV5mph +BQyzUnwwD6OUcfmLRsbBU4+M6jMtNFKHnNUSyHBI8Jlj7EUkUS/unAPXa9ToY8mn +xPLO5HCsQr3on/nTViwxx94y3T1HBGHKvQ3h271kh0xe2r4bgI6oRUKPzZi6D46u +IXko6rsrRfrR7XhG324CATVmlRtTHLLWiEkEGBECAAkFAkcsAWQCGwwACgkQA8eU +pJ91nuyPnACdGKaHS7jzYJTEjP2aX53cxEww2fMAnRoR6CqNAiY0jW5OiljPG+He +43F4 +=lCmU +-----END PGP PUBLIC KEY BLOCK----- + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.4.10 (GNU/Linux) +Comment: Public key at http://people.redhat.com/eblake/eblake.gpg + +mQGiBEHEwRMRBACm9AFr7XGQ9pFLX4wcuWh+mW6UxFARa47ewVNwW8gxr5nsC7TE +skokjSnlcPuuLGO/UQMmjO8HhCHsq4JkZy5u9QNlno+nQDwCr4mJydoa2YGZ6nPU +aVTdSZ3CYXCrsYiHmtVvjqMMyLrLT8cq/vNQhhOZ1EftbQ6lBHMJ2Kn8SwCg2ccu +zM0E/3bPCMhxgcTWgOA2NP8D/RNUWxKKqc3G8rVea7hi01fSqrqX1ppuK/hnLn8e +spzXC6Qlp38k/ibKpRXrzuMNJu+SjUBevm5ZpBHer/1FDWfh8NGgRrKkCmvk1zH7 +dTBOvq+VN82QnvuyDFsvFfsoDHn+YPCHP/4gCDeKAqvBdCBp6LZXX/FQTVKZp6RK +lmi0A/9mN0aAIpHeu7BBKPxRh+ePzDtrmj3MeQlUna39ExKd0b55poHgeuyXRWsF +F9d8DMkLDuzZJ1OHkI3l3xNyEHWzizYQGkvDg9Atikn3JRIv/So5BK4ZJXRNGgni +zcXyu+xJdrerPbArzCIRHnKcGzyninNzubrMYot1PkNr4szuRrQeRXJpYyBCbGFr +ZSA8ZWJsYWtlQHJlZGhhdC5jb20+iGQEExECACQCGwMCHgECF4ACGQEFAkvHx2oF +CwkIBwMFFQoJCAsFFgIDAQAACgkQ84KuGfSFAYBGmQCgnNA3IpPx4Qg220aPzejj +4c7izRYAoLChcJ6/B68OjpiJKgrCkR9tbFR5iQEcBBABCAAGBQJLx8vDAAoJEKeh +a0olJ0NqvzsH/03u0mScWEJcIddK/ZsgxDhSJE8jwz/XfDaBTZzk3/BQl2aLTPpG +ja+izujJ+eZzTANExjIQU0EqIcN+F1kTEEOO+COb2CvBgwpVJ76k+Lm6TN6Kq1LG +vEVlEtJTbITzDWXquGZ05xjXdgaIqHaMONcKlP60Iwmm5YdcUpXfck6KT09Nn3Jt +Corl7ruVZHAMUyd42ei0k1vajDuiG9XmM8ylxVgxyeahOATxuFi81k9LMqjlyFQf +oyPOfWG/9bS/pzomos+ImMSKx8eZlzNkUf4tVnIhjEQKWKC9ZKB41UfKUBknzD5D +yYoRDzYRlpxDEyk+aVK2TjQr8K9r1RriAL60NEVyaWMgQmxha2UgKGZyZWUgc29m +dHdhcmUgcHJvZ3JhbW1lcikgPGViYjlAYnl1Lm5ldD6IYQQTEQIAIQIbAwIeAQIX +gAUCS8fHcQULCQgHAwUVCgkICwUWAgMBAAAKCRDzgq4Z9IUBgMSBAJ91r/hZGGnh +2tNywUkG4kObgRLjfACg06z8bIPYK9bwTIZL05cYvfwQs/eIRgQSEQIABgUCSXk3 +eAAKCRDp1n4q3kFyFriCAKC2P+pdTGDxzCWpcfKCZBaj8dmwywCfTkELJzEf3Xyj +ZaMhQQcyzjr8iKuIRgQQEQgABgUCS3lcdgAKCRD90t6s0zPLoa5WAKCO+kfvJK6Q +FVEvPwpm2cTUcLLahQCdHir4KiMVq5JDJ57APA9SuKjFYiKIXgQTEQIAHgUCQcTB +EwIbAwYLCQgHAwIDFQIDAxYCAQIeAQIXgAAKCRDzgq4Z9IUBgBBjAJ4pryQ6lfyg +AP/A+ALRYS0GbLqllACfbo5spXIP0juZJzLf+5ybojZvDxWJARwEEAEIAAYFAkvH +y8MACgkQp6FrSiUnQ2rYbwf8CrFH3nGxo3gDYGPzD6fvBrM8V7fLTH1dFiJqxc1J +Su0pm51ebaieSHg8mf18zHCWq9q2VbRWHX3MNWx6/+KYg5BVc4nMvGDQLiFA3Ofs +61AeGfzKztP587wUlKYO+J8eTrwYRGFKjURyZOxdMzKBw1LOt9JC87tO2+Fmp7v0 +VN2he87tZdgvSk4VhTKXvyMO9Yb/Dhbzz/0T/sRPcOLcUBh0Wt4K4pu4k9h8EJHN +tgvw4Tu6H3jBeXqv0O8st5zvQixI5YxQhtwEaok3CdeXrqz9Bkt85nQ8xnIlkWvV +fVj53hJem27ItdIT+4ZomC/4U/zZgT3wW874bBquKm7ra7kBDQRBxMEbEAQAhJ5F +6B/9bPxiVdshRiouAWc+FbvlvnzEaudFIUHzxGz3olbMnsKgzVsm4yVbieP9R0Rt +E3orYxt132pqjSfW6MFjTMAiMhwoc12vyDzZKuxsgYvmNxaKdj3B1rV7rCJlLQYy +a69qoWaDMqxphmDiip0cndy+jKNvH1DJPY3iZCcAAwUD/2fjAwgEZ6ROpsYacJ2Y +6y33A58CswWQB2PyhzJJiG0W8pQdCAgUFqI9XMjUBAp0at9+uObSwMUKeB3y4ksD +d7x1TIkBKmAMYiTSxd3JewSyRbDq624BJ1almvY3X2ID0mMmfe9P5Se3eeT12KRK +ne2ZYb8heW6M1ze3QU967SaHiE8EGBECAA8CGwwFAkuCo/8FCQm/NFQACgkQ84Ku +GfSFAYCyCwCfZcKAbjpX5zBFhgi8iC0Mo12LG+gAn2a/bQIsofmXOKtwSmUlx9NA +7VxiuQQNBEuCoRYQEACrYaSSlYEgZJoxltoR07R8quoDkIrR7WnWB5ogrevzEM38 ++NIXYsPI41Wbp7sIURQTbt6b9KBJEyh6KNS1AjmhwGehmkmngLXNqmVeEppEbOX+ +Snj4R+GdxlHfCnBF0TjcfOZBKeI/diQgSSuycLKCRIkzezNDPhX1npOfh8U7c90T +1y1fgrl8rYd105WIWWV/RgC15TqjekalzBbw97Cqn05Wfe7ohIl5zUbliItSW1HJ +fAUxTFk+ZRElQ1ENZc2ns19tuCRVegYeM3a1FognQEMbzyVSNwzBTvS7Q5/1ZVEL +ZKRIxvaB1BZbScMOtgBYkrhpJyClE98r9YH9FW4EpRO8If8Y1A/WPSgT8z0ShZ5T +HVMSHoBi0uD1qd9bgqb3p661BNcnoWPR1OFs4YubwfTB62rNNWt18IliHCnFjDB4 +O9QCJhkKaHF+6EGK95j96KKuxt2ro9FmEbii6BtXFUN3lSdukE5no3d+Fa0LtlrQ +BiAguAc1+VJzJ4Ay6LOmj+gaFd8jKJt/dcjUBKB88XJByVRXtYMKSlQNbp0NszIc +OpcT0PeOkMa4pML+JrEYcm74vJDVs33dccpu7AMzYWOPzC7pO8JyUZGVyrbYD6df +MBwOflO51wGqxTUKukSyqZbtQ1AweH3aLi6EUe9QhfukOs92DcdcyY92608QmwAD +BQ//QqQ+4KO6gR/xMk6oARwLaNmmJzGFq4BfwdUeg8BFXtx5qwAnBi1+72BQuo4L +PcUpF1JwDj72Tj+cL/t0G/1dw868cIgNGUuCrKS1TjSV1GZUatXtVCL5Nu8VtHJ7 +o2fm+OFxXK2615a+wohbFhUGf65/9oFgetcLBZm+93Ha77X2pvTVMyex+eWGI2AA +572xZBE8b/F3cXE4lmZthrHgXXgI5IghpuLgyCA2jU5CgrW8p8kb7dpA7apHHBrB +FBlP4yWwy6dmfVUrO02OOQJouxP8ht4ehhrUOgU919K6edrzCWHshx14qVzE8Xlj +pRDn8Xf2fw/fCHbJwtgJ6BVpu3HfpLJSffakJ2HmsxmK3aZ1rscckyPPCaKE1yjL +L+tbWWHAChuyD9DfvH8bmrMWpTU53fytpfCDCkRg82wBwnOo64e9MsrdH4+9JFFH +bdBPnXnlzBTrlSeU9VpdbHVi0KZqAIuZ8ah8Wrn0Hb8MnjR9USNlOTA2Se5bq9Ec +rp/1FiIIefUmsM1HNQ8S7ayyCTBb2gIPjqjIT7B0qq6YJj3VJvnM6sxPLFhe0HcU +yODiBoJg9/RTphAHjoYYSr5EGD8B1J3hzYOqerlieDSlwOFRCaZbAA+WdCRQnP6T +XJFKAkuYfBUic/XU0IxuZ0tLrdrnobdcqYbngsD0CcGK9d2ISQQYEQIACQUCS4Kh +FgIbDAAKCRDzgq4Z9IUBgNIcAKDNXKZpZ1Wi50/47SiMGTLdLCpOsACgpEUd28qs +7uxYuJ6v1GM4HgANNFSZAQ0ES8fJbAEIALDsPCxAiHSQBtRfKqF+IoAo5NW7o6Iw +Z9/DbD3QaCunht1UqYJoReWtUtTGmEEzyZv7CwWRT6mr1hHrbVZej1ERhUiXQXEp +5Cj13JAFn9e+ZQyRrg06Ye0WDvie+SkkUINNQ3Oap9yN0qF8VXR3s/+LEpB5mvZY +/XExyOYBBjli9DaVSgc/jebxO2kHUuSPJgEKh134uRUaYLHYGinUtJuVu9us6bZs +qll0E+OdxE2hvvd5OkhcS628RocfvYvOnOSx9woz4zXxzJEf6c+wB33zEhtWObcm +biTh3mhDITYfA66v62uTYRzFOB2nXtBqm5Y/Ax+Fo2reu6dpfvHfjOEAEQEAAbQe +RXJpYyBCbGFrZSA8ZWJsYWtlQHJlZGhhdC5jb20+iQE6BBMBCAAkAhsDBQsJCAcD +BRUKCQgLBRYCAwEAAh4BAheABQJLx8v1AhkBAAoJEKeha0olJ0NqEEcIAJuX/kUa +RSonz0YCN5dGOkB4m10qG6OKvSJLgIxIieDt8KIZnR80kKkvlGlWJKjTdDuXfuyz +42j50kjwq0CnogP48zPBMl7kSC2/8oZQpIO84tgn1Yght+0Q5t6Q/4YGlY/b4puk +AOxzsSw13vSxjETEPeWLBUliotxHDuyjU8QgWn42L0DUOsFHk1okGeejY8fMc9NL +2eZlVib/gjfaqQtc5x1fRcSU7xU8OhWhsbqAQt/i/+8giZ2bEuH/DlZy1SkGFZYh +9AO9I5bZVkM6KGbunOFCh2vdA/8YMt+krrAjt7F67c+l8+2rBrTqzWlp7dp3XeZk +bOQF00qzUcSbzHqIRgQQEQgABgUCS8fLXwAKCRDzgq4Z9IUBgNl3AKCk3CkPlJnC +JtAhYmimwJ8hilKz5wCg1NApn2traDJlUGhJrVGyChksJpm0NEVyaWMgQmxha2Ug +KEZyZWUgU29mdHdhcmUgUHJvZ3JhbW1lcikgPGViYjlAYnl1Lm5ldD6JATcEEwEI +ACEFAkvHylYCGwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQp6FrSiUnQ2oK +5wf9GyVdcjI2OY0yRi5WsLb9qgUFQPEd5mWq5VZfLWegknT8nTMFZLCSLHw5WLH4 +yvtAgrtPeugovYYUi9NEMq/WrTWtIKG1DLx8C1V3h8NXmuOPxvCJOi2Ucqq8mrqs +CR93v2NvghS+sJh8DVbXLsTTOkgYSKgxidfsvdJUVa7Ah/V5xZEGeShOGdr2nRCh +4angL4KHFnKA8BCwypJwx0sc+1mIm74ejfF9YhoNfunY88eybTQaIa8BcCMVa5cd +Pbc6ExEIvbdbrlrs/m/Sr8TvRVMqh1URYSCJ6JzLYA2+gJ7+QKUjiK56y0LcrH58 +Xbmu9pbUnFc05sXprO74mS3FGohGBBARCAAGBQJLx8tfAAoJEPOCrhn0hQGACmEA +oNbpsjWyjPq0xSzk7VKrnjVnteLUAJ98iUuupMrW9OxQNMGKO2aeB2D/+NHaLdor +ARAAAQEAAAAAAAAAAAAAAAD/2P/gABBKRklGAAEBAQBIAEgAAP/bAEMACwgICggH +CwoJCg0MCw0RHBIRDw8RIhkaFBwpJCsqKCQnJy0yQDctMD0wJyc4TDk9Q0VISUgr +Nk9VTkZUQEdIRf/bAEMBDA0NEQ8RIRISIUUuJy5FRUVFRUVFRUVFRUVFRUVFRUVF +RUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRf/AABEIAQUA8AMBIgACEQED +EQH/xAAbAAABBQEBAAAAAAAAAAAAAAADAAECBAUGB//EAD8QAAEEAQIDBQQIBQIG +AwAAAAEAAgMRBBIhBTFBEyJRYXEGFDJCM1JicoGRkrEjJEOhwVNzBzSC0fDxRFTh +/8QAGQEAAwEBAQAAAAAAAAAAAAAAAQIDAAQF/8QAJREBAQACAwEAAQQCAwAAAAAA +AAECEQMhMRJBEyIyYQRRQmJx/9oADAMBAAIRAxEAPwDFycuf3yYdvJ9I75z4oYy8 +gj6eX9ZSyh/Nzf7jv3QgdvJcO1NDNysj/Xk/WVIZWR/9iX9RVcbm1IEdVmWBlZH+ +vL+spe9ZF/TyfqKCnB8UKOh/esgf/Ik/WVL3qcH6eX9RQf28Eh5obYcZc9X20n6y +pDJn6TS/qKr8gnL2taS40B1R3WWRlzn+vJ+opOzJo2an5EgaPtlYObxyGG2w99/j +0XP5mdlZbjredHQDkqY8dyC11s/tOyJ1NnlfX2iq7/ayQ1okeP8AqK44v8EhI4ci +q/pRvqO0Z7VZOrYyEfeKsN9pZzyLwfN5XC9vIBQeQmM0h+d35pf0f7H7n+nqODxh +uU3TLkyMd1710teTDy+y7TFyHTx/YduvG4pJmuDmvf8Amus4JxviOJToMgamig0u +5qGfHlh3KpLMvw6x02SwnXJJ52SkMqU/13/qRYs1/F4S6a8eYt71cnrOhycftiwy +gG6q0mOe2uGvFsZMzf60n6inOVON+1kPnqRW4wLdbRqb4+CHpgL9Mmph+sOQTTMn +yb3qb/Vkv7x2UTlzV9NJ+pDyYnQPokEHkRyKDqH/AIE07DSz71OeUz/1FN73MP6r +/wBRVbURzTarRoLHvU537aT9SiMmf/Wf+pAJHU7KJde37rRlk5U1/TSH/qUDlTn+ +tJ+Diq4OnlaYOA2RLVLL2yp/9x37oTf/AAomT/zk333fuhgVyS+HOpc7FKNUnWbS +Y3qwkK/NMACnAWFIJ/JRAoKGRkNx4y934LSdt5EMrOjw47e7veC5bP4pPmSEai1l +7NCjxHKdkTOc48+QVFdOGEidy2lq0/Ddp3TOcKOwQ0RsL3N1VTfEqpQ0k7qvZMsx +JJJLMIJXjkaTtmkDgQ42EJODRvmhqDuuj4X7R5eM5jHN7VgOwJ3Cu5EUfEXveyN0 +UpGqidly8Mxif2jW0r8fEpDJrMh0xi9J+Zc2fF3vF0Y5LeB7QcU4RMS2YvHLQ7cF +ddwv2l4fx2o5mNxcroej1wGaytTon6mj4gPlKpRyaHA7j0TXimc2X6kr1fIidD3X +Du+Kpat1hcE9p5NAx8s628gSVuupwDxu13IhQmNxuqNmzagfxS1EpjsOf4KJNpyJ +XXNRux1UdVlMTSxT6k2vdMDajY9FmBy698n/ANx37oQ5BEyj/OTbf1HfuhjYLHiX +I+qdordNQu06DHG6kmab6KVrCYubGwudsAuc4hmdvLsb+r4DzWhxXJpnYR7vdzro +s7GxbOmxQ+kP+Ffjw/KedZ/uz5LeQfU9UKaPQ7SAt+SGodTaA6IMOLrIcGW0b6j4 +q2k/pnMxo8dofkDU7mGBV8jIdO6yA1o5NHRaGVA57zq2/wAqjNCGk2Q0eHVFpVZJ +OR4ckyAkknolFZjSP5BYZLQUqVyPBkkPcFjxRTw1+m6/NDZphVSGQxPBG48D1RJJ +WPJc1mk+R2CL7k9g3CE6Ijml62rMLoDWbJBO6iiGNDIpNEbLPUmPLHWF2PAuKOli +ED9/BcWtng8tGgacDaly49bPhd9Ove5urlRTFwUGS9pGCfW0r2UYNiWpIkKFgdEr +sUmKkarYKJNhPabmfJDbC5Ubfe5rbZ1u/dC93aeiuZI/mpfHW791KOFpFlamih7s +LsOIS91d0cCrzoqcn7OuizRR7CQDYWPJQcHRi3AhaIYqHE3kaY28yjjju6DK9MKS +S3veK1E0p45ZEwN2JJtyBkSxwucNqYNvNZbs1wJr02XX5NI+t9xZKRqOmMf3Qszi +kMTA2ADSOiwJMuaYBrnGhyARsTGdO8DS5yP1oZhsR0080vc1ElSbw5xBdM6338I3 +XQQ8IeyMVHpvkK5rVxPZ1zmgzD8E3d9H5jjTw58u3hyAVrG9nnyVbTuu8h4PjxfI +CjMx2R3TaR+RjkYvZhoALm/gjHgjA8RN+EfEf8Lp5ALqvRBdGGNPnzKFkPusccNh +ibTByVV+O1wPdpaz9ifNU5nsaCL3SmjKlgY0G1lzY+p2lo38P+62pC6Ruw0jxVcw +BjTpH5qVUjIkx6FfuqUsRDtlsTN21DoqUga6Unok8GzcZnJWsGURzC+SDO3TIQos +NOVLPqOaftydthTdrGO8rTuaxOCz6otBK19S5ZNdKVIkDwTWo3vuldJiHDhzUrv1 +QwUmuulgauRtlS/fP7pRuLeinOwnKl++f3SERPqgc7XaijNjDmn0QtFJ22wc6Qow +7Gj4VhcdnbjZLpHG6Zst0ClxXtjIRxBkYNN0WQqcX8iZ+MafKdLZPzOJVdkbpDTQ +pRxOke0AEgrp8Pghi4ZLI9v8QsPPoV0elkZ/CODPzA0gEukO1dAu54b7Pw4YjOiy +3c7cyj8C4U3Bw4tTe/pFreiY0C63VccZ+TX/AEqQYLRJrcLP7K1oANUjhoB5KDmg +DZUhFZ8YpCfGD0R5DXPkhaibsIDNqlN1Uhyhv5dUd4Djsq8mx3CSmilKGkAoL4mu +bYViVoQi6h6dEujs6ZtEjTsqj222wr85v/Kpv29Emjs+bfalR7M6HOWjkR6tggys +0sqlKwWRnNt9gKlyK18tnd5fKslwpyfFDOdtXg02iZrfE0um5DmuQ4XvmsB5XyXX +6XVy3Us5rIfwRdf/AOprTEnqE2qkuintNdc0if8A0mJW0DpJWgZUv3z+6k1hKnMw +nJl++VNpLWc9vFJaoHVP0p3QXaK1ocbpE5DdKKjoorz/ANqXF/G5GnpQH5L0Z1Od +svPfakBnHnmtqH7K3H6XJe4Lw+OfsmkX2e/4rtG4TXwRx9NQtct7MmxRXbwigOS6 +sITtYYwNGyIAOiTBTfJK9KrBEaKUHmlLkEKSxQHVNsNIPbq67IEgoKw4ah+6G8AN +8kGvSlffoppRYUnDvqL7AobpBUZNrCqvPc53SvSNB581VkZpYeSWqYqEo3tVX7FX +pAfBUZUlOAWjoeSrSCwVZeKKDJRBSWMz5hqYQsmRtOefBbzmWKWVlsId2YG7nJcb +2TKbgvAomyZ7NRquWy6+qWRwHCZG4PNGQDfyW24JLl9UlmgC2lFwRtJcaCaWPQdP +90dgr6RdKJaB8KKRvumLUwOkllrIlH2z+6gZNfoqOPwyScSS+8ytc6R/X7RRhwvM +Z8GZf3mqN+d+qaq82YAbBMZS7ZVPc+Js+aF/9k9cRZ8WKx33XIdMtabC4L2wbXGL ++yF2fveSz6TBlHmN1ge0sbcyJswilY9vxamVsqYdVgfZh2qURtPmu8hB0BcH7KQG +LiW533FL0Fg7u3iuvAosZJBF7Kdb+qHGyijtq1QKQFqEkdope0cz+SbVY33R0G1Y +gt5qtIT1tW5ias0q8jaFrCru2cmqhYPNM69SINOkWsyq5oPXdBkjVx4F7KrIQLSW +GlZ87QNis+ZgN+C0Jnc9lUNczukuJvpnyd0oBN7K1NXiqrq6KdmjSoMFLM4nGW50 +enmapajBXVElxmT5WOXD4RZ/wo2/N21m17h0DY9WnfxPmrjhuliMDMVobW9kkDmp +uHghh1O08vUGlTcO1AF8kzGgFEI71go7KqSRljqKhVrpsiCN0LO42vBZ0vDYj8Nt +QnJPyHy1cZumOvtH90dreqZjdNiuRRQFzrwwDbpFa3/0gSRML7I3UhCBVF4/FCis +hgO6DnYnvOI6ItB1kAp2seOUjvxU7maC4SB1eIQkFyMzI+H+0Jc0Bsb5NJPQLp2/ +D5LlPaoOZjCWqa6Vmo+Ctx8TlZEzH1CXU3U2Txb4r1uOakQy6bUvEGRjY2ht4zGw +1d2sGftN3ao69SVly5UtkNkaTy+FVR3b47dvFcd7fjAPmpDOjPJ4IXnEkfEJTqa+ +Nt+LqQ9HFYndyWN3kHpg+nprslhG5DkJ84fyXAwcW4jjbTQO9Wbrd4bxaLLkEZcW +yfUdsVv7NttyPAPkomUclF4fuS0/iqGRO6JnWkorck4ZfeAWdLnMF24LEzuOmy2I +Oe7lsFjyjiGWbjiLR60sFrfyuLwjuh+/WisuXi9OoX6qjHwnLfJ33NDz0L1YbwGe +U958A08wXla4ZX8E/Vxn5DfmufIXO1NHiExklDu66wVHIYzFcI+1ikI51exTtje8 +cmOHqo5xbHJYilJ3dzCLHPJO57tNaAA3/ugMgPzDTfJSwHl+Rm6TqjY1qhlirjXU +YcbjhxV9W1J3O1PhzT7lCfsqeTprzSeUuX8lXmmLzRCclQJ28k+iOkB14Ubh9UFA +cKU8N2vhsf3VF3JctnZp40XipH/eKTdkpBUz/vFO3cpVTSC3t9QrQ5KpI4CQWaFh +HZIw8nN/NAVgBDk7rH+ifVyoppd43oCx+LcNj4jAcWWwx1Gx5bqticKBysmHuDs2 +sDdLNIArwW5mN09g7qU73Bjo5BttpK9Thz+sdockcvncJlumk6fJc3Jw7NOZ2cdx +Mvn1Xo8z9X4rJysYSOsjdVpJ/bjeIez88De2ilfM0jveIPooYHDZTKZZg5rG9CKs ++i6aWCYfDJyHVVHRSk2ZPyV5nNJXj73tSLWucWkkDxKhkMdAyJ8e8msdket2rbWa +X6juq+XivyOI4VOIc6QAADoClv8As003pp+OaKOHAKH1lmZ2RxZuM/tMaAN08wu2 +ySOy3G4XMccJMDw01Y3U8sv6NMNuFizZJGCPvOa3k1W8LKcJBbHUOe6x2RSxOLm3 +bTRV7EmErqkbuOqbDLYXBq8Qj97qbHl0vrdpVfHZLjkvnmvwAKO2KORoLXOFeCHJ +i+f90+XLYTHhxrInxRJk6ozuTddFqY0AbW6eLF0vs7kq6yGlyV0dTwHNiLsUiN1O +BGn1tS4Zjy4vCsyLQxzpHN3DdwfX8Ubs7YS5tj0Wlwph93mdtzU+S9Gx6ux4P4cM +bT8rQEp3h7hQSKG5TLe0DsFHSTyTnYosTTRPRG9Fa/DCXcPA8LCmRQQeEOuCRvg5 +Hrdc+Xpp4uyH+NJ94pDZNKP40g+0U9+CWqFoDzuE4gaUmm0VqBkRjt6HdS7JzYnN +G6I3dFZshawGY3Vih31SlEwSx6Xb2EeVuqB7fsqvjmmhdv8Ai3rRczS4b2tPZuvy +KzJRNG46o79FuB9bFQexrmmhuu3qpfLn5JA/myj5hVJIA4jw6rbEetzg5gFHoiR4 +rOehGFuFc+MS3Dax4BaOHw8B/vErac3Zg8FqSQtYO60BQIBYGgpbRxxPMdUO/Nc3 +xXdrl0cjO6PGlg8UYXMukmW9K449uLlga2RxrZ3NM3h2s62GnK1NQcdXK1YwmAnu +mwkwrZ4/kCKKaMUWfiEYsc7otZmLdbfgj+5NA3AVbtKRhsiJPe5I1hp3Wm7HaBsN +wqWRFXRJejzECV9s0jl0V7hIccaWh13WUXDla2eEOEWM4n5iocl6HzpN26g4qbzv +shuvdTlJQ3JmzOY2q2TuQneqYGvwOftHTtArkVfIp9eaxeBGsyVp+Zv+Vtu+IqHJ +6OPizIbmk+8U5BI22UJTU0lfWKm1ySqoD3kWKY5OH5A5xtP4pNcRId/wR2u2Woot +mmHOD+6mzKcTT4XN9U90me62j1SitXYVJh0ir5bUrNqo62zPA8bXV/i3WWi5eLUd +k7q2ANFHms9rj0tFExDbXpQiT2tahiZrOZVbIyqG5Wcct0s3ZsF78kS1o5OT2o0t +6poGE81ExmFgkeOm6lj5kT3bHryU7DS9LMsREW6xc+MujK6J72SRgLIzwwMcbCNn +QTLtw2dBchaAo8PLoJtJ68ldypYzMSfyQQGvksbAKWM7UuW424ZWmrKua2ub5LAZ +OYzfRXYcku2BVvUVqQAWfBZ2TR3ViWTbmqEziUmUPKqPbqeAtfGbpx27rNA079fN +akY0xNHkuTP0bTu3CG7elZbFrbaFNFobYO6WUmldyEUR390FxsJitHhVMzGVzLSF +sv8AjXMcPkLOIwfepdM8kvUeQ2I8h/jSb/Mf3Ts3UJHfzEn3ik0qdViTT/E9UYGy +qzPjcUYOQ0IoNqJ20eqV0ExNaPVYVgFV5W1Lq+sihyhLuz0VOLL5ylDKbhAFqFNN +oHoiRvA2Qc9mqM6ea9WOZm5GQ55oKxgRthbqI75VTHx5C7VIbN8grjpmxUH931TB +ctrjsjV3Rv5Kq9rRY5b8vBOzQ892Qc75pSteWctR8kD/AFro0uXIyLu9Fi5/EJJI +y3qrWRiTyd0FyhNwl3Z3YJW/Bbe3OOBLtzukJCB5q9kYZjdsqWTJBjM1TSNF9FPW +lPrZ2SOKIwvabB3WbBxD3mcQ4cTnXze5buPjaeY1FNCZFFI6VtFvJQkYWkrVx8bs +2OcQLKzc5w10NglybHsCIa5Gt891pk/3UOFcOkyY3yxjvXTR4o00E0Dqkjc31C5M +7qnPDJp7pKjO9tEXzQCoOKWQEHHYoTj6fgpuPNCJ2TFNG/s8mJ3g8Lq3ndcg/Y6l +1odqY0+ItT5Rx9GmdWRJ94pgd1GZ38xJ94pNPNSsWibDZJRQ6gq8Z5+qMNkKKZOy +RNOYFHVQS1XIxYRwU7ioWiRRSTvDY2Fx8lpLb025IBpLXagDXipE3suimxYMThHZ +SgaiLJ81zjXdGr1uOWYzbjmcyyukIoqlNjZFkxI5mGORocCpM8VMG/8Aun2fTieK +ezOTBmCfDme0g3pvYrYwcvHMTm5rHwy+Nlbr2iRu/NV3wNO7mNcE0ayZehCDHfA2 +SLiBbYvS6iqb9L4C6TiDWtBPw0iT8Px3vvTpVV/D8dvykoj+n/2YOTxDFZqaO0lc +TQcd1jOwMri0jXzBrI27CgurysXHaGmKMX6KuG6edBSyh/jGdg8N4dFhRnQ3fxWr +CwEtQYmhwsggI8cgb15LJ3tay5GsgpvOlzWZMGMfI7fSCVpZuV2ndCwOIuuCRoN7 +FTzpsZ+HReyXE/fcIONB7HbgLrHSWOQLT4rzn/h68mbJj6bFd8x4b3UvNx/UmSWG +WsrClwsSfd8DQfLZUMjgkcguB+kjo5aOrx5hPr62uf4sP9OXyuF5UAJMWpv1m7rO +ftsRS7oO3QMjAxMz6eIX9ZuxW3Y3/jhpdwunxn68OF1/KFGf2VY+/d8j/peP8qxD +w7IxsRkbm6iwV3TaXOywZ6eYXky/eKQI0bJpzc8u/wAx/dLYN3UVYlEe7+KIOfNB +jNhW4MPIyXfwo3O8+iaY23pt6Q5okcUk8zWxtLj5LZxPZ7cOyHavshbmPhxQMDY2 +BvorY8F/5JZcsjFw+BOfTsh1DwC2oMaLHAZEwNViqCiPiJPgujHDHHxy58uWTmfa +bO7MlvysbZXC8K4hkyZ75Hu/hyH4PqhbvtZkES5HTali8GiBfqXVepo3FOtujjfv +5Iu3Nu3qqDXkOKtQvDhz3CR0Y0Ugud5Ji8gclOrFJiAQjBsVJhIeQCqyiRoHdtaD +h4k0gSv1CuaIfNZs0ZLfXyVIw6n78loTE3V7IEZ1yafNA0haQyJU5ZgBY5q5nSBg +DfzWNI8vfz2SUPDPk89ys3NA7B4vor9XzP5LN4g7TC/0SWbHHrtr/wDDmDbKmr5g +0Lr3nvlZPsVh+6cBY8inS99a7RZJXRcf2yOK391qQOoeaRJCk1tEbKZYNPJL+m32 +gDfVSDr5dU4j3pLsz0CS8RpyJB2yI2SkIDxCkCPyUrxQ05GVN/zMv3ireDwyfO+j +bTfrHkr/AA/gpnyXzZAIj1Gm+O66iDGbGwNa0Nb4BSw4d95K58uvGVhez+Pjgdpc +r/PkthkDWAAADyCJpAFBOBa6JJPHNlyWk1oCkkKT3sgQxCbx9FKtlH5vwWZ5l7YA +xzyA/M4KvwZg7K+qv+3MdTB32gqnAqMYtdOXbo4/4LrmaTyTEFrtTTuP7qzNHtYQ +OSGj72swTgt3Ri3VazXHQdQ2R4cxtCzv5IaPKO7Ybqm9tkkKw6YHmVVklGva0dG2 +rzxECyqjB2Ly7wV2WUabO5WPm5QLtLNktjfQOZkGZ5VRo5pbu3UgKFUlkL6g41ss +6eB2bmwYbLuVw1eQWhIA1urkAtL2O4acnLl4jK3b4Y78E3Hhul5MvnF1UULcbCjh +btQpOxlNU5e9JQ5BTaxW9ri2g1tOCLoTtZu1GbHsjIW0AM3S7OuSPo80iKrdYAtJ +9VHswTypEITcil+YO3URxgOKOGqIq1NctpyApJOmQY6SVJLCcjZDJ/iBEJ2Qn7EH +wWgVxHt3BqZqHqsLgj6FFdl7X45lxdXTkuC4Y/s36Sd+S6p3Irx3qx1TwHNtVHXa +sQPD40OSOijo0oThY3VGVhabbYKvH8kGRl7n+yU6gciVooglD96e02SQizQknuml +VfA7q4lAdhT5L3tpuyq6C4b2bVz3fZTZj9Sl021Jsbr3CmYtO9LQEFBVZz2MJL3W +UdDtnSQOzcmLChHfldR8l6Ji4cfDeHxwxgDS2gsn2O4EWB/FMptOf9ED0atnKeZJ +duQVceo5eXL6uoExpdurEcdpo41dig8k0RtV3Np7Qphloz47yPQJ3M6dVgArdQIR +yGs6qs5+t3dWZB259UzW7ojYXVaK2OufNbQOkPM+qmkkuFUxT8wkksxugSpJJFvy +kQhyckkkIbJmcfjEnDnAry8js+ISNHLVaSS6cP4H4vXQ4ryGBWntsc0kk56qu5qD +xaSSxorPFWhadykklvrG0AkhHZE0gJJIF/JnsAsdFV4fhs4nxyHGmJ7K7IHWkklo +pfK7/OrHxxHGA1oFCllRN1GyUkk+PjgXoIxQV6NgASSWyBXr+YkKeTusukkkWZzn +GSTSTQtWWQNaPNJJMXIRzQKACYAeCSSDP//ZiQE3BBMBCAAhBQJLx9gdAhsDBQsJ +CAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJEKeha0olJ0NqedoH/2McrxGkPgq988QQ +rBbST5Pz5WjsvNpRksocimHaRDvzop1tzvyTRQt1QHlHmIt3FEgzioNmfT0yovC0 +F/VXjZrMczWnYjCCFATJWhQMgoH/fTUTJVTLMjnlsXOOr+33JGzD0nsQIn3jCCsX +fe7VIMyOiwX/ngron1YluGOvqiNZ0vEeJXuB3mimCe9wEwlLVgmu5PO7hitg31eK +N8PJZuExGqv3VyYYYuwAOydDw8JbEZB59fE2W3EcOaFcMz2GlPEz+VyGfARaGrQD +VDQyr7kQ1kX4OA+yAx2dWmzM8enEw/OjgWDiSkpm6hhIW7q+E1Ip2rTiU9lWHY1B +9P/e/pu5AQ0ES8fJbAEIAMaQwXMWOabKoASfkP4y3g/M907w1q2wPDxCK3dGbO76 +RTKDHJhvPnZk7jRZS7sSBDmQNM55E+dM53trBYNByXWAYFeCuRGkCVDSXRF47ntD +R6CUXJ0syLluTBiF9j5PAM8yHdo4/moFeSbiohhKzFvwD6LTQ/vYCoVv1DvfB4b9 ++XFI8CkthATmpYZJeM6Rcm/jY0ZLqjqB3hGYPoCnl7wAKjWVIw99OkbNeW3hpGQF ++9s0J82xCKQtnMVgMttCAoEDfcEN5Xq80n0KPRKAQY6RjJ53gjoBtTSQjLWEcCbW +vr6wCcR0gqNweLfFYf9Q+tlbl+UzwqqjXg5MOQj0S2UAEQEAAYkBHwQYAQgACQUC +S8fJbAIbDAAKCRCnoWtKJSdDarTfCACZEUYN5fNznw1fQ2sOKNS7TPHcuez+pn1W +uRJZs1kEWOlYpp4vV91V4ThMMaYjmZFEixK2NDNzZH1v7ZUFSGUCpjWcCIEO/RCe +371wuK4QgJ5TCXKXjZh3CmZjQQtzLn67rDOYr+PGtg6nNcoPAurmThf6GYa5I1ZY +A3eAeImqYlk+SEU9QijNlQJ4RzvqlL8hQ3vY1+mtmYUOnr9AOMMW19Lf1sdJZcpV +lRupow+qWP/PpSCTTbv/cZSMcevxaR4vV7NZ6lgNjtZKhfB+gAvZRdiwwCv+5Sdx +IqV+O8CuGx6PRLjNuqKbZljpLxpFbD3gndtK8lH43BuzfgY9MPg+ +=FC1k +-----END PGP PUBLIC KEY BLOCK----- + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.4.5 (GNU/Linux) + +mQENBE/Xfl8BCACfn5680mdbi33bAoPmsuOiKguiQ8/q/mMhk6GjuM28F/ahp72P +baGZP2hv6D/DTYeJVlbZPeACkbFQe758AOhoEs8pqDq4JMC4jzNPUSGYH7joaZjc +mMCUUqzG6qDfajW4M2iRI+US/Dozd++shQ18kKJKNY4ZrFEFXUsiHLDHQk/rmrj3 +lAcrcf7zLwJSKKXLmAvz+vu+i9F5/Xt7TSasszrG6AqqSl3aZn5RGmU4DSiAFh3x +U4t21t6KbiQ4gUS0VkbyqrDVhUs64H/fzcFOVVT4dq51nQAAb5mxTFCpyAMuJDQ0 +lh32iKNWM5iKDk1Wdmg2EsnJho7EAbqcEOI7ABEBAAG0IUthcmwgQmVycnkgPGth +cmxAZnJlZWZyaWVuZHMub3JnPokBOAQTAQIAIgUCT9d+XwIbAwYLCQgHAwIGFQgC +CQoLBBYCAwECHgECF4AACgkQBxZ0ijDRVa2xQgf/T1SWK9wbMn44uYIqyPzSAQ7E +m6Xqno07CMJH8DD5T7CidxfH3V1DX7OCRqkljc34QzIdZ0HR5HUSpvfwBYHTXzgH +yiZPVysIb2mx6X//fO16jxi5wj2+mkslGXwrgwzop5InFu6Zl/Q4HDTItthaCYAR +WZvImf0L/1vySWegonoZp/9eUeRld+6Bc/z5kvt6K9hHZt1G11c3+3zlrFydJHL/ +vuXPLXr8w2nkuX+VsXKIT4VgjVn4LvDF55BphfGteaYqSofYPczynoEh1QtU2Qyh +4IXt8lgaEPQADa7wUL7HqhzyJMxHTHG/WLzBRJMfNrr2ow6KiCOfIuBkEa7FnohG +BBARAgAGBQJP14N2AAoJEJ3rRsDWefbPKfIAmgONqRipIzLSUC/FrjSZyV4CO7xu +AJ9qaqLVib0v9xMWU+8UpHcF5jwbBbkBDQRP135fAQgA+Uhd1N4R9nqhfDLQXuKD +IhTals5RMhOXy+fG7uDUSaV9HD/XY4JHfli0r5r/WcG0MGm67T3j0p6YhLCqhkai +x+cZpUwtokw39l5ztT2Smi//WW7wZPIAe4XLUV1TvpoVeoDeoGY9onAdJMEBw+oq +dMoPVyIRmjw7ID3uF2DfU3QnTSYt64AbsHSPp7imeD4gW3aY7r4OmI1vqz4y5pQm +cItwc8rudS9s3uiiGCia34M0yRM64ewwAY3eTAK9fA4FOamVgt8YvNdCZBXvcHAh +amR2BUrt+01+8iqcuX6VEn39srHEutGg8GXcC+7tMncUmlWPUfpy0vTdor/HkxpX +lQARAQABiQEfBBgBAgAJBQJP135fAhsMAAoJEAcWdIow0VWt9RAH/i+Kxkr/R2xJ +WcOvWvn6NVLUo0cChc0SaMjuWAk4KlqOQJT0i5xTkMWVQ8PQonUVkzloLkCqRs61 +9rLoB3mNFzGqP5Jm3dSoqvTFCTMGeQEsX0e6kjnsydgtgkeYNT6yO5hrakfzlKvG +i1KJ7Kwh+8zQtubHQI8/A1IlNyp9WJrWP2Xj1rS3f7SN3QillOhoh8HNkpN4MHZ3 +7moelhQ3XJ+UOUTHv+bNZHVilofbrX5S5LXcPeE/p+DaNNp+oGwPJppGAzKWKQy9 +hA8rKE+HnaSHr/0k0i9Uxmf2c4nLCCeZuxz+TUUZq06Ohco7ullX6MshUhCX+21P +KLEPtgs1HkI= +=5dqZ +-----END PGP PUBLIC KEY BLOCK----- + + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1 + +mQINBFdggy0BEADFA8M0PxYhQdI9LlkkP3jfkDDsKmyofklaJouGHc3h+IjoXkdJ +A1C/UaEjaVLxb4aBm7znZrk44Je88MxidwCTeZwgJje2R397IKW3WtRtIfUz5sH3 +uEoO1AWB9U/SzbO/V7CueXO8S+UT9/kOWFAtRGceDzBEzXdnMobuBlUbKzs86QW4 +0kJEWc8I6dzdiLojabFYXWVYD+5VeiIsY0P4g7RZQ0pkurb2+py8XgsXTyuoljah +bHTp5Q7Ioyxeb25fIQ0rea9kCWbm9DNtyoFlmNj04+NPgYiHAtHnLrQSWWu87Oy9 +saVmKd+dJqvY48h15rYnm+A5llbqgZlq+dNsj6V6MPgToGBYcQtWJ2BjpGwJ7gfe +hgi1rAFNhDF/TbtlMBhumxW3YD/INVaI213u+21mMkOgRz5Q/iB9I+JtxO7SNWg0 +es0+7vTGWb6S5BAlWuMq0t8Zfx+s0qdPeeMhm4Qsgw62LoFlWeSN22/m5fWhtQOU +KhBt17q9XdI68Ixx+NqPxJefG6PVR2bobnYWpHBn5CTu8R3cfFvPHl5MDbcJVAOE +CYYaEq6ltGJ+k+Rytb9HEudBSdzDxad0udTk7FUMcnJXbgfOO+6FcgY9pwvcktqZ +uBCmkIOxUQGkmtYN5o+qO0ybkIXigZdCCmT1oIcC6n2c/RrhJhwimTZBuwARAQAB +tBtCb2IgUHJvdWx4IDxib2JAcHJvdWx4LmNvbT6JAj0EEwEIACcFAldggy0CGwMF +CQWjmoAFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AACgkQQhr6Jjh/mo7sPg/+IuRM +95QhspYO1MooPAJ7NjfLXuqYJe7VZ7GweHN842KVhO5nfY9HhKATP7jT8e49oUf5 +1l2b5sy+sinKhgnBusGbmPvgfXQbGppgdsb4bD9hFPpxyRWsjqfm7kkCHqZNxpyL +9GxXKx8Ni5rnYDWDj4VffgeWjz5Eo20TGH4ctXh5TQTMDdHDhHRq721s78MbBDMq +zDGdgtHJVernUZVyjRMVYAL4hNCgsesu3e7WyRGMUQ67GV+haSemkPht1ZviyOjN +xo0IDfaE4M5zun6hf0w5wXxZcHmRC/9YUe9nSyHpr1xndGxlNQVIkQ38M738Zh58 +bLzfDah2Em+CYo6S1r5DGevBB9O+SxIBj57KR5OE4nf5Umiu0r8XE9D7FCpbKUTZ +PUcJZ1rVib3be/o+sb5mYfj5iEJkah1Jss3jBy9EmqjF58ZF/K/3ANhh4Or2uZ/A +513TWLejumhd1IQoJEL8iMSXwFSUSTf8us5GIhbEUwdTmMhk2B3DA6u3NE4aijuL +b5YfcSnKAtV92Lk6usNtRe2IlgfaFbI3Xa/WcfaI8kngsqnPoixt5mF3XkBCP6fY +fy9TwsInaSLviAozjOcb1RPZ7nOvN+zwuzEf1/lztWS7E/XSf7DwBFvz6xgTMyvE +SVK5siptqY9VWUhSphssTJ98AkDXkUMflAVST+u5Ag0EV2CDLQEQAJ3M1t/ikz3g +jNELKT/qU7O51jnXtmKL6EpF5cOzRipiFHALtZVxsjgJFckKDdlm8ZMI9ijmZe3H +QtvXHsYw/m1/zK1t8BMQ2TtDtkeD8CcFbIEDgPGMNww9B0oEDp1uGZoVrB9FVlbL +H7BlGVUnONf9hwnRfkv2Z7ngap6OAGdbf2XIQewuY41tluwLewB6qmKwxmBDTqNf +7ZKFLNUNO+TKFZY+QBNFp12waF6bmUpZI54gveXNLCGVyJ0P2xpSEFtmycWukFUp +UrwbYNzBZ4itCDi7Vy9J4/ro6NW8fXSSF/A7czltkweNbTaNt/DzAHwB3ej0Z63E +ZuWc4bswzB2k1j+VtwncimQgCwQ+m1Go0b7bpXwBBIAMOTmIma+/MzL+7e40mvFN +W1zLabax5Gh4XWgAwky3ey4pjJoEE00qqcptBJ38rjivfW8Hr8rjl5ymhmjZkVFX +l4LBO45QzKdXSnYCrwBCWQrIPB+7N1mZTKqKhhfL9nOqqSmkEjpuyJNTgKl1LyUd +Y87ughA7O8uVavCO0TnzTQ0HDgATuD34jGAU9l1sVZoaTIAv+QLrNYyURE6iA06I +MexaYxmtJdUAYm1U44uWTEj+jSMEUo0rmEOpXNXlL3FFNqRlVRxDsF53vn9vPwyc +rc0UQ4owe/Hfa8i2x39yFcrleNTSDamxABEBAAGJAiUEGAEIAA8FAldggy0CGwwF +CQWjmoAACgkQQhr6Jjh/mo5nXw/+OGZG1BykvP0vOPecnbkqrl3XJ9XqwloNcsrd +BrhTRm5GYyMjFM9I2vz2IIrfU7L4YiSNfM9WSBWJ6/dZNgHWV2QaS6iqW6DSY3ky +Mf3HE4xiy5np7jEDeMWlXnKxOCbGtl2ButcCOGL2lFGLwHpSITaDzBg9jyKN0UoN +n9Sg52n6dPuSJOlBhD01jnDEFXdVrxwQcH8e3yUYH6dO12ofAcvg4YxahftPMSPm +VVtG5yGYCUn9wg5Uf8ttTcBnvN2uWEEySEZgh1b8gNID5Q8ZpPQkty7fDdRlcyLf +aDQKWkgSSfIbPH8VpepixAyICNbIUa9YiOR5JelYjyiuC6dFeDKIbv2LsgREP7Bw +xz+iXhWRVfopmZnbQ2SxaqUJWEtFgJTutdlpfA+NrWOlY5cuCuQOHS6cJsFT1H3/ +wHzS/SxeGIv5XkWbwDEF0gSDR1kwHNO++UNyIzdVeHP4dzd5Wo66HOh+5w+3RumK +8gu5yObqrR3rPCrn5x0zYM3Sp7OViRYsovjXonbTBF1mveMaKXVtbDtr+fs8gFCF +Yzof3++neIfm6yF1gAsunwtu1Zo/6lIuoOB8ZqeJehIcy/oGh2+18kl5gWjCH/Vw +Z4mp2Ofui21i8Z7rLeYmxCVuPy2QH5wyIewforFkXD95KPwSNHaMW5SuTzdThDes +W1qcD8s= +=eykL +-----END PGP PUBLIC KEY BLOCK----- + + + + diff --git a/grep.spec b/grep.spec new file mode 100644 index 0000000..f2bf75d --- /dev/null +++ b/grep.spec @@ -0,0 +1,91 @@ +# +# spec file for package grep +# +# Copyright (c) 2022-2023 ZhuningOS +# + + +Name: grep +Version: 3.1 +Release: 150000.4.6.1 +Summary: Print lines matching a pattern +License: GPL-3.0+ +Group: Productivity/Text/Utilities +Url: https://www.gnu.org/software/grep/ +Source0: https://ftp.gnu.org/gnu/%{name}/%{name}-%{version}.tar.xz +Source2: https://ftp.gnu.org/gnu/%{name}/%{name}-%{version}.tar.xz.sig +Source3: https://savannah.gnu.org/project/memberlist-gpgkeys.php?group=grep&download=1#/%{name}.keyring +Source4: profile.sh +Patch0: testsuite.patch +BuildRequires: fdupes +BuildRequires: makeinfo +BuildRequires: pcre-devel +Requires(pre): %{install_info_prereq} +Requires(preun): %{install_info_prereq} +Recommends: %{name}-lang +Provides: base:%{_bindir}/grep + +%description +The grep command searches one or more input files for lines containing a +match to a specified pattern. By default, grep prints the matching lines. + +%lang_package + +%prep +%setup -q +%patch0 -p1 + +%build +%configure \ + --disable-silent-rules \ + --without-included-regex +%if %{do_profiling} + make %{?_smp_mflags} CFLAGS="%{optflags} %{cflags_profile_generate}" + setarch `arch` -R sh %{SOURCE4} # profiling run + make clean + make %{?_smp_mflags} CFLAGS="%{optflags} %{cflags_profile_feedback}" +%else + make %{?_smp_mflags} CFLAGS="%{optflags}" +%endif + +%check +make %{?_smp_mflags} check + +%install +%make_install +#UsrMerge +install -d %{buildroot}/bin +ln -sf %{_bindir}/egrep %{buildroot}/bin/egrep +ln -sf %{_bindir}/fgrep %{buildroot}/bin/fgrep +ln -sf %{_bindir}/grep %{buildroot}/bin/grep +#EndUsrMerge +%fdupes -s %{buildroot} +%find_lang %{name} + +%post +%install_info --info-dir=%{_infodir} %{_infodir}/grep.info%{ext_info} + +%preun +%install_info_delete --info-dir=%{_infodir} %{_infodir}/grep.info%{ext_info} + +%files +%defattr(-,root,root) +%license COPYING +%doc README AUTHORS NEWS THANKS TODO ChangeLog* +#UsrMerge +/bin/egrep +/bin/fgrep +/bin/grep +#EndUsrMerge +%{_bindir}/egrep +%{_bindir}/fgrep +%{_bindir}/grep +%{_mandir}/man1/egrep.1%{ext_man} +%{_mandir}/man1/fgrep.1%{ext_man} +%{_mandir}/man1/grep.1%{ext_man} +%{_infodir}/grep.info%{ext_info} + +%files lang -f %{name}.lang +%defattr(-,root,root) + +%changelog diff --git a/profile.sh b/profile.sh new file mode 100644 index 0000000..4923c25 --- /dev/null +++ b/profile.sh @@ -0,0 +1,14 @@ +#!/bin/sh +# profiling script for profile-guided-optimizations (PGO) +# must be fully deterministic in what it does for reproducible builds +# should cover most code for good PGO optimization benefit +# See https://github.com/bmwiedemann/theunreproduciblepackage/tree/master/pgo +# for background information on PGO reproducibility + +grep=src/grep +t=COPYING +exec > /dev/null +for param in "" -v -i -h -H -l -L -q -n -Z -E -F -P -e -w -c -o; do + $grep $param "GNU" $t + $grep $param "G.*U" $t +done diff --git a/testsuite.patch b/testsuite.patch new file mode 100644 index 0000000..5279446 --- /dev/null +++ b/testsuite.patch @@ -0,0 +1,26 @@ +Index: grep-3.1/tests/Makefile.am +=================================================================== +--- grep-3.1.orig/tests/Makefile.am ++++ grep-3.1/tests/Makefile.am +@@ -58,7 +58,7 @@ XFAIL_TESTS += equiv-classes + else + # The backslash-alt test fails for glibc, which needs to be fixed. + # FIXME-2015: Remove this once the glibc bug is fixed. +-XFAIL_TESTS += backref-alt ++XFAIL_TESTS += # backref-alt + endif + + TESTS = \ +Index: grep-3.1/tests/Makefile.in +=================================================================== +--- grep-3.1.orig/tests/Makefile.in ++++ grep-3.1/tests/Makefile.in +@@ -110,7 +110,7 @@ check_PROGRAMS = get-mb-cur-max$(EXEEXT) + @USE_INCLUDED_REGEX_TRUE@am__append_1 = equiv-classes + # The backslash-alt test fails for glibc, which needs to be fixed. + # FIXME-2015: Remove this once the glibc bug is fixed. +-@USE_INCLUDED_REGEX_FALSE@am__append_2 = backref-alt ++@USE_INCLUDED_REGEX_FALSE@am__append_2 = # backref-alt + subdir = tests + ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 + am__aclocal_m4_deps = $(top_srcdir)/m4/00gnulib.m4 \