From da41d3ce6ee0a7c399e6438525caf651b761080b Mon Sep 17 00:00:00 2001 From: obrien Date: Thu, 21 Jun 2001 18:37:17 +0000 Subject: [PATCH] Virgin import (trimmed) of Bzip2 version 1.0.1. --- contrib/bzip2/CHANGES | 167 ++ contrib/bzip2/LICENSE | 39 + contrib/bzip2/Makefile | 141 ++ contrib/bzip2/Makefile-libbz2_so | 43 + contrib/bzip2/README | 166 ++ contrib/bzip2/README.COMPILATION.PROBLEMS | 130 ++ contrib/bzip2/Y2K_INFO | 34 + contrib/bzip2/blocksort.c | 1134 +++++++++++ contrib/bzip2/bzip2.1 | 439 ++++ contrib/bzip2/bzip2.c | 2044 +++++++++++++++++++ contrib/bzip2/bzip2recover.c | 435 ++++ contrib/bzip2/bzlib.c | 1564 +++++++++++++++ contrib/bzip2/bzlib.h | 319 +++ contrib/bzip2/bzlib_private.h | 530 +++++ contrib/bzip2/compress.c | 714 +++++++ contrib/bzip2/crctable.c | 144 ++ contrib/bzip2/decompress.c | 660 ++++++ contrib/bzip2/dlltest.c | 176 ++ contrib/bzip2/huffman.c | 228 +++ contrib/bzip2/libbz2.def | 27 + contrib/bzip2/makefile.msc | 63 + contrib/bzip2/manual.texi | 2215 +++++++++++++++++++++ contrib/bzip2/randtable.c | 124 ++ contrib/bzip2/sample1.bz2.uu | 722 +++++++ contrib/bzip2/sample1.ref.gz.uu | 848 ++++++++ contrib/bzip2/sample2.bz2.uu | 1642 +++++++++++++++ contrib/bzip2/sample2.ref.gz.uu | 1933 ++++++++++++++++++ contrib/bzip2/sample3.bz2.uu | 9 + contrib/bzip2/sample3.ref.gz.uu | 11 + contrib/bzip2/spewG.c | 39 + contrib/bzip2/unzcrash.c | 126 ++ contrib/bzip2/words0 | 5 + contrib/bzip2/words1 | 4 + contrib/bzip2/words2 | 5 + contrib/bzip2/words3 | 23 + 35 files changed, 16903 insertions(+) create mode 100644 contrib/bzip2/CHANGES create mode 100644 contrib/bzip2/LICENSE create mode 100644 contrib/bzip2/Makefile create mode 100644 contrib/bzip2/Makefile-libbz2_so create mode 100644 contrib/bzip2/README create mode 100644 contrib/bzip2/README.COMPILATION.PROBLEMS create mode 100644 contrib/bzip2/Y2K_INFO create mode 100644 contrib/bzip2/blocksort.c create mode 100644 contrib/bzip2/bzip2.1 create mode 100644 contrib/bzip2/bzip2.c create mode 100644 contrib/bzip2/bzip2recover.c create mode 100644 contrib/bzip2/bzlib.c create mode 100644 contrib/bzip2/bzlib.h create mode 100644 contrib/bzip2/bzlib_private.h create mode 100644 contrib/bzip2/compress.c create mode 100644 contrib/bzip2/crctable.c create mode 100644 contrib/bzip2/decompress.c create mode 100644 contrib/bzip2/dlltest.c create mode 100644 contrib/bzip2/huffman.c create mode 100644 contrib/bzip2/libbz2.def create mode 100644 contrib/bzip2/makefile.msc create mode 100644 contrib/bzip2/manual.texi create mode 100644 contrib/bzip2/randtable.c create mode 100644 contrib/bzip2/sample1.bz2.uu create mode 100644 contrib/bzip2/sample1.ref.gz.uu create mode 100644 contrib/bzip2/sample2.bz2.uu create mode 100644 contrib/bzip2/sample2.ref.gz.uu create mode 100644 contrib/bzip2/sample3.bz2.uu create mode 100644 contrib/bzip2/sample3.ref.gz.uu create mode 100644 contrib/bzip2/spewG.c create mode 100644 contrib/bzip2/unzcrash.c create mode 100644 contrib/bzip2/words0 create mode 100644 contrib/bzip2/words1 create mode 100644 contrib/bzip2/words2 create mode 100644 contrib/bzip2/words3 diff --git a/contrib/bzip2/CHANGES b/contrib/bzip2/CHANGES new file mode 100644 index 000000000000..ecaf4170ef88 --- /dev/null +++ b/contrib/bzip2/CHANGES @@ -0,0 +1,167 @@ + + +0.9.0 +~~~~~ +First version. + + +0.9.0a +~~~~~~ +Removed 'ranlib' from Makefile, since most modern Unix-es +don't need it, or even know about it. + + +0.9.0b +~~~~~~ +Fixed a problem with error reporting in bzip2.c. This does not effect +the library in any way. Problem is: versions 0.9.0 and 0.9.0a (of the +program proper) compress and decompress correctly, but give misleading +error messages (internal panics) when an I/O error occurs, instead of +reporting the problem correctly. This shouldn't give any data loss +(as far as I can see), but is confusing. + +Made the inline declarations disappear for non-GCC compilers. + + +0.9.0c +~~~~~~ +Fixed some problems in the library pertaining to some boundary cases. +This makes the library behave more correctly in those situations. The +fixes apply only to features (calls and parameters) not used by +bzip2.c, so the non-fixedness of them in previous versions has no +effect on reliability of bzip2.c. + +In bzlib.c: + * made zero-length BZ_FLUSH work correctly in bzCompress(). + * fixed bzWrite/bzRead to ignore zero-length requests. + * fixed bzread to correctly handle read requests after EOF. + * wrong parameter order in call to bzDecompressInit in + bzBuffToBuffDecompress. Fixed. + +In compress.c: + * changed setting of nGroups in sendMTFValues() so as to + do a bit better on small files. This _does_ effect + bzip2.c. + + +0.9.5a +~~~~~~ +Major change: add a fallback sorting algorithm (blocksort.c) +to give reasonable behaviour even for very repetitive inputs. +Nuked --repetitive-best and --repetitive-fast since they are +no longer useful. + +Minor changes: mostly a whole bunch of small changes/ +bugfixes in the driver (bzip2.c). Changes pertaining to the +user interface are: + + allow decompression of symlink'd files to stdout + decompress/test files even without .bz2 extension + give more accurate error messages for I/O errors + when compressing/decompressing to stdout, don't catch control-C + read flags from BZIP2 and BZIP environment variables + decline to break hard links to a file unless forced with -f + allow -c flag even with no filenames + preserve file ownerships as far as possible + make -s -1 give the expected block size (100k) + add a flag -q --quiet to suppress nonessential warnings + stop decoding flags after --, so files beginning in - can be handled + resolved inconsistent naming: bzcat or bz2cat ? + bzip2 --help now returns 0 + +Programming-level changes are: + + fixed syntax error in GET_LL4 for Borland C++ 5.02 + let bzBuffToBuffDecompress return BZ_DATA_ERROR{_MAGIC} + fix overshoot of mode-string end in bzopen_or_bzdopen + wrapped bzlib.h in #ifdef __cplusplus ... extern "C" { ... } + close file handles under all error conditions + added minor mods so it compiles with DJGPP out of the box + fixed Makefile so it doesn't give problems with BSD make + fix uninitialised memory reads in dlltest.c + +0.9.5b +~~~~~~ +Open stdin/stdout in binary mode for DJGPP. + +0.9.5c +~~~~~~ +Changed BZ_N_OVERSHOOT to be ... + 2 instead of ... + 1. The + 1 +version could cause the sorted order to be wrong in some extremely +obscure cases. Also changed setting of quadrant in blocksort.c. + +0.9.5d +~~~~~~ +The only functional change is to make bzlibVersion() in the library +return the correct string. This has no effect whatsoever on the +functioning of the bzip2 program or library. Added a couple of casts +so the library compiles without warnings at level 3 in MS Visual +Studio 6.0. Included a Y2K statement in the file Y2K_INFO. All other +changes are minor documentation changes. + +1.0 +~~~ +Several minor bugfixes and enhancements: + +* Large file support. The library uses 64-bit counters to + count the volume of data passing through it. bzip2.c + is now compiled with -D_FILE_OFFSET_BITS=64 to get large + file support from the C library. -v correctly prints out + file sizes greater than 4 gigabytes. All these changes have + been made without assuming a 64-bit platform or a C compiler + which supports 64-bit ints, so, except for the C library + aspect, they are fully portable. + +* Decompression robustness. The library/program should be + robust to any corruption of compressed data, detecting and + handling _all_ corruption, instead of merely relying on + the CRCs. What this means is that the program should + never crash, given corrupted data, and the library should + always return BZ_DATA_ERROR. + +* Fixed an obscure race-condition bug only ever observed on + Solaris, in which, if you were very unlucky and issued + control-C at exactly the wrong time, both input and output + files would be deleted. + +* Don't run out of file handles on test/decompression when + large numbers of files have invalid magic numbers. + +* Avoid library namespace pollution. Prefix all exported + symbols with BZ2_. + +* Minor sorting enhancements from my DCC2000 paper. + +* Advance the version number to 1.0, so as to counteract the + (false-in-this-case) impression some people have that programs + with version numbers less than 1.0 are in someway, experimental, + pre-release versions. + +* Create an initial Makefile-libbz2_so to build a shared library. + Yes, I know I should really use libtool et al ... + +* Make the program exit with 2 instead of 0 when decompression + fails due to a bad magic number (ie, an invalid bzip2 header). + Also exit with 1 (as the manual claims :-) whenever a diagnostic + message would have been printed AND the corresponding operation + is aborted, for example + bzip2: Output file xx already exists. + When a diagnostic message is printed but the operation is not + aborted, for example + bzip2: Can't guess original name for wurble -- using wurble.out + then the exit value 0 is returned, unless some other problem is + also detected. + + I think it corresponds more closely to what the manual claims now. + + +1.0.1 +~~~~~ +* Modified dlltest.c so it uses the new BZ2_ naming scheme. +* Modified makefile-msc to fix minor build probs on Win2k. +* Updated README.COMPILATION.PROBLEMS. + +There are no functionality changes or bug fixes relative to version +1.0.0. This is just a documentation update + a fix for minor Win32 +build problems. For almost everyone, upgrading from 1.0.0 to 1.0.1 is +utterly pointless. Don't bother. diff --git a/contrib/bzip2/LICENSE b/contrib/bzip2/LICENSE new file mode 100644 index 000000000000..88fa6d88a486 --- /dev/null +++ b/contrib/bzip2/LICENSE @@ -0,0 +1,39 @@ + +This program, "bzip2" and associated library "libbzip2", are +copyright (C) 1996-2000 Julian R Seward. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + +3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + +4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS +OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE +GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Julian Seward, Cambridge, UK. +jseward@acm.org +bzip2/libbzip2 version 1.0 of 21 March 2000 + diff --git a/contrib/bzip2/Makefile b/contrib/bzip2/Makefile new file mode 100644 index 000000000000..ab17f4979575 --- /dev/null +++ b/contrib/bzip2/Makefile @@ -0,0 +1,141 @@ + +SHELL=/bin/sh +CC=gcc +BIGFILES=-D_FILE_OFFSET_BITS=64 +CFLAGS=-Wall -Winline -O2 -fomit-frame-pointer -fno-strength-reduce $(BIGFILES) + +OBJS= blocksort.o \ + huffman.o \ + crctable.o \ + randtable.o \ + compress.o \ + decompress.o \ + bzlib.o + +all: libbz2.a bzip2 bzip2recover test + +bzip2: libbz2.a bzip2.o + $(CC) $(CFLAGS) -o bzip2 bzip2.o -L. -lbz2 + +bzip2recover: bzip2recover.o + $(CC) $(CFLAGS) -o bzip2recover bzip2recover.o + +libbz2.a: $(OBJS) + rm -f libbz2.a + ar cq libbz2.a $(OBJS) + @if ( test -f /usr/bin/ranlib -o -f /bin/ranlib -o \ + -f /usr/ccs/bin/ranlib ) ; then \ + echo ranlib libbz2.a ; \ + ranlib libbz2.a ; \ + fi + +test: bzip2 + @cat words1 + ./bzip2 -1 < sample1.ref > sample1.rb2 + ./bzip2 -2 < sample2.ref > sample2.rb2 + ./bzip2 -3 < sample3.ref > sample3.rb2 + ./bzip2 -d < sample1.bz2 > sample1.tst + ./bzip2 -d < sample2.bz2 > sample2.tst + ./bzip2 -ds < sample3.bz2 > sample3.tst + cmp sample1.bz2 sample1.rb2 + cmp sample2.bz2 sample2.rb2 + cmp sample3.bz2 sample3.rb2 + cmp sample1.tst sample1.ref + cmp sample2.tst sample2.ref + cmp sample3.tst sample3.ref + @cat words3 + +PREFIX=/usr + +install: bzip2 bzip2recover + if ( test ! -d $(PREFIX)/bin ) ; then mkdir $(PREFIX)/bin ; fi + if ( test ! -d $(PREFIX)/lib ) ; then mkdir $(PREFIX)/lib ; fi + if ( test ! -d $(PREFIX)/man ) ; then mkdir $(PREFIX)/man ; fi + if ( test ! -d $(PREFIX)/man/man1 ) ; then mkdir $(PREFIX)/man/man1 ; fi + if ( test ! -d $(PREFIX)/include ) ; then mkdir $(PREFIX)/include ; fi + cp -f bzip2 $(PREFIX)/bin/bzip2 + cp -f bzip2 $(PREFIX)/bin/bunzip2 + cp -f bzip2 $(PREFIX)/bin/bzcat + cp -f bzip2recover $(PREFIX)/bin/bzip2recover + chmod a+x $(PREFIX)/bin/bzip2 + chmod a+x $(PREFIX)/bin/bunzip2 + chmod a+x $(PREFIX)/bin/bzcat + chmod a+x $(PREFIX)/bin/bzip2recover + cp -f bzip2.1 $(PREFIX)/man/man1 + chmod a+r $(PREFIX)/man/man1/bzip2.1 + cp -f bzlib.h $(PREFIX)/include + chmod a+r $(PREFIX)/include/bzlib.h + cp -f libbz2.a $(PREFIX)/lib + chmod a+r $(PREFIX)/lib/libbz2.a + +clean: + rm -f *.o libbz2.a bzip2 bzip2recover \ + sample1.rb2 sample2.rb2 sample3.rb2 \ + sample1.tst sample2.tst sample3.tst + +blocksort.o: blocksort.c + @cat words0 + $(CC) $(CFLAGS) -c blocksort.c +huffman.o: huffman.c + $(CC) $(CFLAGS) -c huffman.c +crctable.o: crctable.c + $(CC) $(CFLAGS) -c crctable.c +randtable.o: randtable.c + $(CC) $(CFLAGS) -c randtable.c +compress.o: compress.c + $(CC) $(CFLAGS) -c compress.c +decompress.o: decompress.c + $(CC) $(CFLAGS) -c decompress.c +bzlib.o: bzlib.c + $(CC) $(CFLAGS) -c bzlib.c +bzip2.o: bzip2.c + $(CC) $(CFLAGS) -c bzip2.c +bzip2recover.o: bzip2recover.c + $(CC) $(CFLAGS) -c bzip2recover.c + +DISTNAME=bzip2-1.0.1 +tarfile: + rm -f $(DISTNAME) + ln -sf . $(DISTNAME) + tar cvf $(DISTNAME).tar \ + $(DISTNAME)/blocksort.c \ + $(DISTNAME)/huffman.c \ + $(DISTNAME)/crctable.c \ + $(DISTNAME)/randtable.c \ + $(DISTNAME)/compress.c \ + $(DISTNAME)/decompress.c \ + $(DISTNAME)/bzlib.c \ + $(DISTNAME)/bzip2.c \ + $(DISTNAME)/bzip2recover.c \ + $(DISTNAME)/bzlib.h \ + $(DISTNAME)/bzlib_private.h \ + $(DISTNAME)/Makefile \ + $(DISTNAME)/manual.texi \ + $(DISTNAME)/manual.ps \ + $(DISTNAME)/LICENSE \ + $(DISTNAME)/bzip2.1 \ + $(DISTNAME)/bzip2.1.preformatted \ + $(DISTNAME)/bzip2.txt \ + $(DISTNAME)/words0 \ + $(DISTNAME)/words1 \ + $(DISTNAME)/words2 \ + $(DISTNAME)/words3 \ + $(DISTNAME)/sample1.ref \ + $(DISTNAME)/sample2.ref \ + $(DISTNAME)/sample3.ref \ + $(DISTNAME)/sample1.bz2 \ + $(DISTNAME)/sample2.bz2 \ + $(DISTNAME)/sample3.bz2 \ + $(DISTNAME)/dlltest.c \ + $(DISTNAME)/*.html \ + $(DISTNAME)/README \ + $(DISTNAME)/README.COMPILATION.PROBLEMS \ + $(DISTNAME)/CHANGES \ + $(DISTNAME)/libbz2.def \ + $(DISTNAME)/libbz2.dsp \ + $(DISTNAME)/dlltest.dsp \ + $(DISTNAME)/makefile.msc \ + $(DISTNAME)/Y2K_INFO \ + $(DISTNAME)/unzcrash.c \ + $(DISTNAME)/spewG.c \ + $(DISTNAME)/Makefile-libbz2_so diff --git a/contrib/bzip2/Makefile-libbz2_so b/contrib/bzip2/Makefile-libbz2_so new file mode 100644 index 000000000000..a347c50e9b28 --- /dev/null +++ b/contrib/bzip2/Makefile-libbz2_so @@ -0,0 +1,43 @@ + +# This Makefile builds a shared version of the library, +# libbz2.so.1.0.1, with soname libbz2.so.1.0, +# at least on x86-Linux (RedHat 5.2), +# with gcc-2.7.2.3. Please see the README file for some +# important info about building the library like this. + +SHELL=/bin/sh +CC=gcc +BIGFILES=-D_FILE_OFFSET_BITS=64 +CFLAGS=-fpic -fPIC -Wall -Winline -O2 -fomit-frame-pointer -fno-strength-reduce $(BIGFILES) + +OBJS= blocksort.o \ + huffman.o \ + crctable.o \ + randtable.o \ + compress.o \ + decompress.o \ + bzlib.o + +all: $(OBJS) + $(CC) -shared -Wl,-soname -Wl,libbz2.so.1.0 -o libbz2.so.1.0.1 $(OBJS) + $(CC) $(CFLAGS) -o bzip2-shared bzip2.c libbz2.so.1.0.1 + rm -f libbz2.so.1.0 + ln -s libbz2.so.1.0.1 libbz2.so.1.0 + +clean: + rm -f $(OBJS) bzip2.o libbz2.so.1.0.1 libbz2.so.1.0 bzip2-shared + +blocksort.o: blocksort.c + $(CC) $(CFLAGS) -c blocksort.c +huffman.o: huffman.c + $(CC) $(CFLAGS) -c huffman.c +crctable.o: crctable.c + $(CC) $(CFLAGS) -c crctable.c +randtable.o: randtable.c + $(CC) $(CFLAGS) -c randtable.c +compress.o: compress.c + $(CC) $(CFLAGS) -c compress.c +decompress.o: decompress.c + $(CC) $(CFLAGS) -c decompress.c +bzlib.o: bzlib.c + $(CC) $(CFLAGS) -c bzlib.c diff --git a/contrib/bzip2/README b/contrib/bzip2/README new file mode 100644 index 000000000000..22945a256c78 --- /dev/null +++ b/contrib/bzip2/README @@ -0,0 +1,166 @@ + +This is the README for bzip2, a block-sorting file compressor, version +1.0. This version is fully compatible with the previous public +releases, bzip2-0.1pl2, bzip2-0.9.0 and bzip2-0.9.5. + +bzip2-1.0 is distributed under a BSD-style license. For details, +see the file LICENSE. + +Complete documentation is available in Postscript form (manual.ps) or +html (manual_toc.html). A plain-text version of the manual page is +available as bzip2.txt. A statement about Y2K issues is now included +in the file Y2K_INFO. + + +HOW TO BUILD -- UNIX + +Type `make'. This builds the library libbz2.a and then the +programs bzip2 and bzip2recover. Six self-tests are run. +If the self-tests complete ok, carry on to installation: + +To install in /usr/bin, /usr/lib, /usr/man and /usr/include, type + make install +To install somewhere else, eg, /xxx/yyy/{bin,lib,man,include}, type + make install PREFIX=/xxx/yyy +If you are (justifiably) paranoid and want to see what 'make install' +is going to do, you can first do + make -n install or + make -n install PREFIX=/xxx/yyy respectively. +The -n instructs make to show the commands it would execute, but +not actually execute them. + + +HOW TO BUILD -- UNIX, shared library libbz2.so. + +Do 'make -f Makefile-libbz2_so'. This Makefile seems to work for +Linux-ELF (RedHat 5.2 on an x86 box), with gcc. I make no claims +that it works for any other platform, though I suspect it probably +will work for most platforms employing both ELF and gcc. + +bzip2-shared, a client of the shared library, is also build, but +not self-tested. So I suggest you also build using the normal +Makefile, since that conducts a self-test. + +Important note for people upgrading .so's from 0.9.0/0.9.5 to +version 1.0. All the functions in the library have been renamed, +from (eg) bzCompress to BZ2_bzCompress, to avoid namespace pollution. +Unfortunately this means that the libbz2.so created by +Makefile-libbz2_so will not work with any program which used an +older version of the library. Sorry. I do encourage library +clients to make the effort to upgrade to use version 1.0, since +it is both faster and more robust than previous versions. + + +HOW TO BUILD -- Windows 95, NT, DOS, Mac, etc. + +It's difficult for me to support compilation on all these platforms. +My approach is to collect binaries for these platforms, and put them +on the master web page (http://sourceware.cygnus.com/bzip2). Look +there. However (FWIW), bzip2-1.0 is very standard ANSI C and should +compile unmodified with MS Visual C. For Win32, there is one +important caveat: in bzip2.c, you must set BZ_UNIX to 0 and +BZ_LCCWIN32 to 1 before building. If you have difficulties building, +you might want to read README.COMPILATION.PROBLEMS. + + +VALIDATION + +Correct operation, in the sense that a compressed file can always be +decompressed to reproduce the original, is obviously of paramount +importance. To validate bzip2, I used a modified version of Mark +Nelson's churn program. Churn is an automated test driver which +recursively traverses a directory structure, using bzip2 to compress +and then decompress each file it encounters, and checking that the +decompressed data is the same as the original. There are more details +in Section 4 of the user guide. + + + +Please read and be aware of the following: + +WARNING: + + This program (attempts to) compress data by performing several + non-trivial transformations on it. Unless you are 100% familiar + with *all* the algorithms contained herein, and with the + consequences of modifying them, you should NOT meddle with the + compression or decompression machinery. Incorrect changes can and + very likely *will* lead to disastrous loss of data. + + +DISCLAIMER: + + I TAKE NO RESPONSIBILITY FOR ANY LOSS OF DATA ARISING FROM THE + USE OF THIS PROGRAM, HOWSOEVER CAUSED. + + Every compression of a file implies an assumption that the + compressed file can be decompressed to reproduce the original. + Great efforts in design, coding and testing have been made to + ensure that this program works correctly. However, the complexity + of the algorithms, and, in particular, the presence of various + special cases in the code which occur with very low but non-zero + probability make it impossible to rule out the possibility of bugs + remaining in the program. DO NOT COMPRESS ANY DATA WITH THIS + PROGRAM UNLESS YOU ARE PREPARED TO ACCEPT THE POSSIBILITY, HOWEVER + SMALL, THAT THE DATA WILL NOT BE RECOVERABLE. + + That is not to say this program is inherently unreliable. Indeed, + I very much hope the opposite is true. bzip2 has been carefully + constructed and extensively tested. + + +PATENTS: + + To the best of my knowledge, bzip2 does not use any patented + algorithms. However, I do not have the resources available to + carry out a full patent search. Therefore I cannot give any + guarantee of the above statement. + +End of legalities. + + +WHAT'S NEW IN 0.9.0 (as compared to 0.1pl2) ? + + * Approx 10% faster compression, 30% faster decompression + * -t (test mode) is a lot quicker + * Can decompress concatenated compressed files + * Programming interface, so programs can directly read/write .bz2 files + * Less restrictive (BSD-style) licensing + * Flag handling more compatible with GNU gzip + * Much more documentation, i.e., a proper user manual + * Hopefully, improved portability (at least of the library) + +WHAT'S NEW IN 0.9.5 ? + + * Compression speed is much less sensitive to the input + data than in previous versions. Specifically, the very + slow performance caused by repetitive data is fixed. + * Many small improvements in file and flag handling. + * A Y2K statement. + +WHAT'S NEW IN 1.0 + + See the CHANGES file. + +I hope you find bzip2 useful. Feel free to contact me at + jseward@acm.org +if you have any suggestions or queries. Many people mailed me with +comments, suggestions and patches after the releases of bzip-0.15, +bzip-0.21, bzip2-0.1pl2 and bzip2-0.9.0, and the changes in bzip2 are +largely a result of this feedback. I thank you for your comments. + +At least for the time being, bzip2's "home" is (or can be reached via) +http://www.muraroa.demon.co.uk. + +Julian Seward +jseward@acm.org + +Cambridge, UK +18 July 1996 (version 0.15) +25 August 1996 (version 0.21) + 7 August 1997 (bzip2, version 0.1) +29 August 1997 (bzip2, version 0.1pl2) +23 August 1998 (bzip2, version 0.9.0) + 8 June 1999 (bzip2, version 0.9.5) + 4 Sept 1999 (bzip2, version 0.9.5d) + 5 May 2000 (bzip2, version 1.0pre8) diff --git a/contrib/bzip2/README.COMPILATION.PROBLEMS b/contrib/bzip2/README.COMPILATION.PROBLEMS new file mode 100644 index 000000000000..d621ad59756c --- /dev/null +++ b/contrib/bzip2/README.COMPILATION.PROBLEMS @@ -0,0 +1,130 @@ + +bzip2-1.0 should compile without problems on the vast majority of +platforms. Using the supplied Makefile, I've built and tested it +myself for x86-linux, sparc-solaris, alpha-linux, x86-cygwin32 and +alpha-tru64unix. With makefile.msc, Visual C++ 6.0 and nmake, you can +build a native Win32 version too. Large file support seems to work +correctly on at least alpha-tru64unix and x86-cygwin32 (on Windows +2000). + +When I say "large file" I mean a file of size 2,147,483,648 (2^31) +bytes or above. Many older OSs can't handle files above this size, +but many newer ones can. Large files are pretty huge -- most files +you'll encounter are not Large Files. + +Earlier versions of bzip2 (0.1, 0.9.0, 0.9.5) compiled on a wide +variety of platforms without difficulty, and I hope this version will +continue in that tradition. However, in order to support large files, +I've had to include the define -D_FILE_OFFSET_BITS=64 in the Makefile. +This can cause problems. + +The technique of adding -D_FILE_OFFSET_BITS=64 to get large file +support is, as far as I know, the Recommended Way to get correct large +file support. For more details, see the Large File Support +Specification, published by the Large File Summit, at + http://www.sas.com/standard/large.file/ + +As a general comment, if you get compilation errors which you think +are related to large file support, try removing the above define from +the Makefile, ie, delete the line + BIGFILES=-D_FILE_OFFSET_BITS=64 +from the Makefile, and do 'make clean ; make'. This will give you a +version of bzip2 without large file support, which, for most +applications, is probably not a problem. + +Alternatively, try some of the platform-specific hints listed below. + +You can use the spewG.c program to generate huge files to test bzip2's +large file support, if you are feeling paranoid. Be aware though that +any compilation problems which affect bzip2 will also affect spewG.c, +alas. + + +Known problems as of 1.0pre8: +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +* HP/UX 10.20 and 11.00, using gcc (2.7.2.3 and 2.95.2): A large + number of warnings appear, including the following: + + /usr/include/sys/resource.h: In function `getrlimit': + /usr/include/sys/resource.h:168: + warning: implicit declaration of function `__getrlimit64' + /usr/include/sys/resource.h: In function `setrlimit': + /usr/include/sys/resource.h:170: + warning: implicit declaration of function `__setrlimit64' + + This would appear to be a problem with large file support, header + files and gcc. gcc may or may not give up at this point. If it + fails, you might be able to improve matters by adding + -D__STDC_EXT__=1 + to the BIGFILES variable in the Makefile (ie, change its definition + to + BIGFILES=-D_FILE_OFFSET_BITS=64 -D__STDC_EXT__=1 + + Even if gcc does produce a binary which appears to work (ie passes + its self-tests), you might want to test it to see if it works properly + on large files. + + +* HP/UX 10.20 and 11.00, using HP's cc compiler. + + No specific problems for this combination, except that you'll need to + specify the -Ae flag, and zap the gcc-specific stuff + -Wall -Winline -O2 -fomit-frame-pointer -fno-strength-reduce. + You should retain -D_FILE_OFFSET_BITS=64 in order to get large + file support -- which is reported to work ok for this HP/UX + cc + combination. + + +* SunOS 4.1.X. + + Amazingly, there are still people out there using this venerable old + banger. I shouldn't be too rude -- I started life on SunOS, and + it was a pretty darn good OS, way back then. Anyway: + + SunOS doesn't seem to have strerror(), so you'll have to use + perror(), perhaps by doing adding this (warning: UNTESTED CODE): + + char* strerror ( int errnum ) + { + if (errnum < 0 || errnum >= sys_nerr) + return "Unknown error"; + else + return sys_errlist[errnum]; + } + + Or you could comment out the relevant calls to strerror; they're + not mission-critical. Or you could upgrade to Solaris. Ha ha ha! + (what?? you think I've got Bad Attitude?) + + +* Making a shared library on Solaris. (Not really a compilation + problem, but many people ask ...) + + Firstly, if you have Solaris 8, either you have libbz2.so already + on your system, or you can install it from the Solaris CD. + + Secondly, be aware that there are potential naming conflicts + between the .so file supplied with Solaris 8, and the .so file + which Makefile-libbz2_so will make. Makefile-libbz2_so creates + a .so which has the names which I intend to be "official" as + of version 1.0.0 and onwards. Unfortunately, the .so in + Solaris 8 appeared before I decided on the final names, so + the two libraries are incompatible. We have since communicated + and I hope that the problems will have been solved in the next + version of Solaris, whenever that might appear. + + All that said: you might be able to get somewhere + by finding the line in Makefile-libbz2_so which says + + $(CC) -shared -Wl,-soname -Wl,libbz2.so.1.0 -o libbz2.so.1.0.1 $(OBJS) + + and replacing with + + ($CC) -G -shared -o libbz2.so.1.0.1 -h libbz2.so.1.0 $(OBJS) + + If gcc objects to the combination -fpic -fPIC, get rid of + the second one, leaving just "-fpic". + + +That's the end of the currently known compilation problems. diff --git a/contrib/bzip2/Y2K_INFO b/contrib/bzip2/Y2K_INFO new file mode 100644 index 000000000000..55fd56a2edbf --- /dev/null +++ b/contrib/bzip2/Y2K_INFO @@ -0,0 +1,34 @@ + +Y2K status of bzip2 and libbzip2, versions 0.1, 0.9.0 and 0.9.5 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Informally speaking: + bzip2 is a compression program built on top of libbzip2, + a library which does the real work of compression and + decompression. As far as I am aware, libbzip2 does not have + any date-related code at all. + + bzip2 itself copies dates from source to destination files + when compressing or decompressing, using the 'stat' and 'utime' + UNIX system calls. It doesn't examine, manipulate or store the + dates in any way. So as far as I can see, there shouldn't be any + problem with bzip2 providing 'stat' and 'utime' work correctly + on your system. + + On non-unix platforms (those for which BZ_UNIX in bzip2.c is + not set to 1), bzip2 doesn't even do the date copying. + + Overall, informally speaking, I don't think bzip2 or libbzip2 + have a Y2K problem. + +Formally speaking: + I am not prepared to offer you any assurance whatsoever + regarding Y2K issues in my software. You alone assume the + entire risk of using the software. The disclaimer of liability + in the LICENSE file in the bzip2 source distribution continues + to apply on this issue as with every other issue pertaining + to the software. + +Julian Seward +Cambridge, UK +25 August 1999 diff --git a/contrib/bzip2/blocksort.c b/contrib/bzip2/blocksort.c new file mode 100644 index 000000000000..ec426725b1e2 --- /dev/null +++ b/contrib/bzip2/blocksort.c @@ -0,0 +1,1134 @@ + +/*-------------------------------------------------------------*/ +/*--- Block sorting machinery ---*/ +/*--- blocksort.c ---*/ +/*-------------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. + + To get some idea how the block sorting algorithms in this file + work, read my paper + On the Performance of BWT Sorting Algorithms + in Proceedings of the IEEE Data Compression Conference 2000, + Snowbird, Utah, USA, 27-30 March 2000. The main sort in this + file implements the algorithm called cache in the paper. +--*/ + + +#include "bzlib_private.h" + +/*---------------------------------------------*/ +/*--- Fallback O(N log(N)^2) sorting ---*/ +/*--- algorithm, for repetitive blocks ---*/ +/*---------------------------------------------*/ + +/*---------------------------------------------*/ +static +__inline__ +void fallbackSimpleSort ( UInt32* fmap, + UInt32* eclass, + Int32 lo, + Int32 hi ) +{ + Int32 i, j, tmp; + UInt32 ec_tmp; + + if (lo == hi) return; + + if (hi - lo > 3) { + for ( i = hi-4; i >= lo; i-- ) { + tmp = fmap[i]; + ec_tmp = eclass[tmp]; + for ( j = i+4; j <= hi && ec_tmp > eclass[fmap[j]]; j += 4 ) + fmap[j-4] = fmap[j]; + fmap[j-4] = tmp; + } + } + + for ( i = hi-1; i >= lo; i-- ) { + tmp = fmap[i]; + ec_tmp = eclass[tmp]; + for ( j = i+1; j <= hi && ec_tmp > eclass[fmap[j]]; j++ ) + fmap[j-1] = fmap[j]; + fmap[j-1] = tmp; + } +} + + +/*---------------------------------------------*/ +#define fswap(zz1, zz2) \ + { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; } + +#define fvswap(zzp1, zzp2, zzn) \ +{ \ + Int32 yyp1 = (zzp1); \ + Int32 yyp2 = (zzp2); \ + Int32 yyn = (zzn); \ + while (yyn > 0) { \ + fswap(fmap[yyp1], fmap[yyp2]); \ + yyp1++; yyp2++; yyn--; \ + } \ +} + + +#define fmin(a,b) ((a) < (b)) ? (a) : (b) + +#define fpush(lz,hz) { stackLo[sp] = lz; \ + stackHi[sp] = hz; \ + sp++; } + +#define fpop(lz,hz) { sp--; \ + lz = stackLo[sp]; \ + hz = stackHi[sp]; } + +#define FALLBACK_QSORT_SMALL_THRESH 10 +#define FALLBACK_QSORT_STACK_SIZE 100 + + +static +void fallbackQSort3 ( UInt32* fmap, + UInt32* eclass, + Int32 loSt, + Int32 hiSt ) +{ + Int32 unLo, unHi, ltLo, gtHi, n, m; + Int32 sp, lo, hi; + UInt32 med, r, r3; + Int32 stackLo[FALLBACK_QSORT_STACK_SIZE]; + Int32 stackHi[FALLBACK_QSORT_STACK_SIZE]; + + r = 0; + + sp = 0; + fpush ( loSt, hiSt ); + + while (sp > 0) { + + AssertH ( sp < FALLBACK_QSORT_STACK_SIZE, 1004 ); + + fpop ( lo, hi ); + if (hi - lo < FALLBACK_QSORT_SMALL_THRESH) { + fallbackSimpleSort ( fmap, eclass, lo, hi ); + continue; + } + + /* Random partitioning. Median of 3 sometimes fails to + avoid bad cases. Median of 9 seems to help but + looks rather expensive. This too seems to work but + is cheaper. Guidance for the magic constants + 7621 and 32768 is taken from Sedgewick's algorithms + book, chapter 35. + */ + r = ((r * 7621) + 1) % 32768; + r3 = r % 3; + if (r3 == 0) med = eclass[fmap[lo]]; else + if (r3 == 1) med = eclass[fmap[(lo+hi)>>1]]; else + med = eclass[fmap[hi]]; + + unLo = ltLo = lo; + unHi = gtHi = hi; + + while (1) { + while (1) { + if (unLo > unHi) break; + n = (Int32)eclass[fmap[unLo]] - (Int32)med; + if (n == 0) { + fswap(fmap[unLo], fmap[ltLo]); + ltLo++; unLo++; + continue; + }; + if (n > 0) break; + unLo++; + } + while (1) { + if (unLo > unHi) break; + n = (Int32)eclass[fmap[unHi]] - (Int32)med; + if (n == 0) { + fswap(fmap[unHi], fmap[gtHi]); + gtHi--; unHi--; + continue; + }; + if (n < 0) break; + unHi--; + } + if (unLo > unHi) break; + fswap(fmap[unLo], fmap[unHi]); unLo++; unHi--; + } + + AssertD ( unHi == unLo-1, "fallbackQSort3(2)" ); + + if (gtHi < ltLo) continue; + + n = fmin(ltLo-lo, unLo-ltLo); fvswap(lo, unLo-n, n); + m = fmin(hi-gtHi, gtHi-unHi); fvswap(unLo, hi-m+1, m); + + n = lo + unLo - ltLo - 1; + m = hi - (gtHi - unHi) + 1; + + if (n - lo > hi - m) { + fpush ( lo, n ); + fpush ( m, hi ); + } else { + fpush ( m, hi ); + fpush ( lo, n ); + } + } +} + +#undef fmin +#undef fpush +#undef fpop +#undef fswap +#undef fvswap +#undef FALLBACK_QSORT_SMALL_THRESH +#undef FALLBACK_QSORT_STACK_SIZE + + +/*---------------------------------------------*/ +/* Pre: + nblock > 0 + eclass exists for [0 .. nblock-1] + ((UChar*)eclass) [0 .. nblock-1] holds block + ptr exists for [0 .. nblock-1] + + Post: + ((UChar*)eclass) [0 .. nblock-1] holds block + All other areas of eclass destroyed + fmap [0 .. nblock-1] holds sorted order + bhtab [ 0 .. 2+(nblock/32) ] destroyed +*/ + +#define SET_BH(zz) bhtab[(zz) >> 5] |= (1 << ((zz) & 31)) +#define CLEAR_BH(zz) bhtab[(zz) >> 5] &= ~(1 << ((zz) & 31)) +#define ISSET_BH(zz) (bhtab[(zz) >> 5] & (1 << ((zz) & 31))) +#define WORD_BH(zz) bhtab[(zz) >> 5] +#define UNALIGNED_BH(zz) ((zz) & 0x01f) + +static +void fallbackSort ( UInt32* fmap, + UInt32* eclass, + UInt32* bhtab, + Int32 nblock, + Int32 verb ) +{ + Int32 ftab[257]; + Int32 ftabCopy[256]; + Int32 H, i, j, k, l, r, cc, cc1; + Int32 nNotDone; + Int32 nBhtab; + UChar* eclass8 = (UChar*)eclass; + + /*-- + Initial 1-char radix sort to generate + initial fmap and initial BH bits. + --*/ + if (verb >= 4) + VPrintf0 ( " bucket sorting ...\n" ); + for (i = 0; i < 257; i++) ftab[i] = 0; + for (i = 0; i < nblock; i++) ftab[eclass8[i]]++; + for (i = 0; i < 256; i++) ftabCopy[i] = ftab[i]; + for (i = 1; i < 257; i++) ftab[i] += ftab[i-1]; + + for (i = 0; i < nblock; i++) { + j = eclass8[i]; + k = ftab[j] - 1; + ftab[j] = k; + fmap[k] = i; + } + + nBhtab = 2 + (nblock / 32); + for (i = 0; i < nBhtab; i++) bhtab[i] = 0; + for (i = 0; i < 256; i++) SET_BH(ftab[i]); + + /*-- + Inductively refine the buckets. Kind-of an + "exponential radix sort" (!), inspired by the + Manber-Myers suffix array construction algorithm. + --*/ + + /*-- set sentinel bits for block-end detection --*/ + for (i = 0; i < 32; i++) { + SET_BH(nblock + 2*i); + CLEAR_BH(nblock + 2*i + 1); + } + + /*-- the log(N) loop --*/ + H = 1; + while (1) { + + if (verb >= 4) + VPrintf1 ( " depth %6d has ", H ); + + j = 0; + for (i = 0; i < nblock; i++) { + if (ISSET_BH(i)) j = i; + k = fmap[i] - H; if (k < 0) k += nblock; + eclass[k] = j; + } + + nNotDone = 0; + r = -1; + while (1) { + + /*-- find the next non-singleton bucket --*/ + k = r + 1; + while (ISSET_BH(k) && UNALIGNED_BH(k)) k++; + if (ISSET_BH(k)) { + while (WORD_BH(k) == 0xffffffff) k += 32; + while (ISSET_BH(k)) k++; + } + l = k - 1; + if (l >= nblock) break; + while (!ISSET_BH(k) && UNALIGNED_BH(k)) k++; + if (!ISSET_BH(k)) { + while (WORD_BH(k) == 0x00000000) k += 32; + while (!ISSET_BH(k)) k++; + } + r = k - 1; + if (r >= nblock) break; + + /*-- now [l, r] bracket current bucket --*/ + if (r > l) { + nNotDone += (r - l + 1); + fallbackQSort3 ( fmap, eclass, l, r ); + + /*-- scan bucket and generate header bits-- */ + cc = -1; + for (i = l; i <= r; i++) { + cc1 = eclass[fmap[i]]; + if (cc != cc1) { SET_BH(i); cc = cc1; }; + } + } + } + + if (verb >= 4) + VPrintf1 ( "%6d unresolved strings\n", nNotDone ); + + H *= 2; + if (H > nblock || nNotDone == 0) break; + } + + /*-- + Reconstruct the original block in + eclass8 [0 .. nblock-1], since the + previous phase destroyed it. + --*/ + if (verb >= 4) + VPrintf0 ( " reconstructing block ...\n" ); + j = 0; + for (i = 0; i < nblock; i++) { + while (ftabCopy[j] == 0) j++; + ftabCopy[j]--; + eclass8[fmap[i]] = (UChar)j; + } + AssertH ( j < 256, 1005 ); +} + +#undef SET_BH +#undef CLEAR_BH +#undef ISSET_BH +#undef WORD_BH +#undef UNALIGNED_BH + + +/*---------------------------------------------*/ +/*--- The main, O(N^2 log(N)) sorting ---*/ +/*--- algorithm. Faster for "normal" ---*/ +/*--- non-repetitive blocks. ---*/ +/*---------------------------------------------*/ + +/*---------------------------------------------*/ +static +__inline__ +Bool mainGtU ( UInt32 i1, + UInt32 i2, + UChar* block, + UInt16* quadrant, + UInt32 nblock, + Int32* budget ) +{ + Int32 k; + UChar c1, c2; + UInt16 s1, s2; + + AssertD ( i1 != i2, "mainGtU" ); + /* 1 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 2 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 3 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 4 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 5 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 6 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 7 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 8 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 9 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 10 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 11 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + /* 12 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + i1++; i2++; + + k = nblock + 8; + + do { + /* 1 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 2 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 3 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 4 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 5 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 6 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 7 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + /* 8 */ + c1 = block[i1]; c2 = block[i2]; + if (c1 != c2) return (c1 > c2); + s1 = quadrant[i1]; s2 = quadrant[i2]; + if (s1 != s2) return (s1 > s2); + i1++; i2++; + + if (i1 >= nblock) i1 -= nblock; + if (i2 >= nblock) i2 -= nblock; + + k -= 8; + (*budget)--; + } + while (k >= 0); + + return False; +} + + +/*---------------------------------------------*/ +/*-- + Knuth's increments seem to work better + than Incerpi-Sedgewick here. Possibly + because the number of elems to sort is + usually small, typically <= 20. +--*/ +static +Int32 incs[14] = { 1, 4, 13, 40, 121, 364, 1093, 3280, + 9841, 29524, 88573, 265720, + 797161, 2391484 }; + +static +void mainSimpleSort ( UInt32* ptr, + UChar* block, + UInt16* quadrant, + Int32 nblock, + Int32 lo, + Int32 hi, + Int32 d, + Int32* budget ) +{ + Int32 i, j, h, bigN, hp; + UInt32 v; + + bigN = hi - lo + 1; + if (bigN < 2) return; + + hp = 0; + while (incs[hp] < bigN) hp++; + hp--; + + for (; hp >= 0; hp--) { + h = incs[hp]; + + i = lo + h; + while (True) { + + /*-- copy 1 --*/ + if (i > hi) break; + v = ptr[i]; + j = i; + while ( mainGtU ( + ptr[j-h]+d, v+d, block, quadrant, nblock, budget + ) ) { + ptr[j] = ptr[j-h]; + j = j - h; + if (j <= (lo + h - 1)) break; + } + ptr[j] = v; + i++; + + /*-- copy 2 --*/ + if (i > hi) break; + v = ptr[i]; + j = i; + while ( mainGtU ( + ptr[j-h]+d, v+d, block, quadrant, nblock, budget + ) ) { + ptr[j] = ptr[j-h]; + j = j - h; + if (j <= (lo + h - 1)) break; + } + ptr[j] = v; + i++; + + /*-- copy 3 --*/ + if (i > hi) break; + v = ptr[i]; + j = i; + while ( mainGtU ( + ptr[j-h]+d, v+d, block, quadrant, nblock, budget + ) ) { + ptr[j] = ptr[j-h]; + j = j - h; + if (j <= (lo + h - 1)) break; + } + ptr[j] = v; + i++; + + if (*budget < 0) return; + } + } +} + + +/*---------------------------------------------*/ +/*-- + The following is an implementation of + an elegant 3-way quicksort for strings, + described in a paper "Fast Algorithms for + Sorting and Searching Strings", by Robert + Sedgewick and Jon L. Bentley. +--*/ + +#define mswap(zz1, zz2) \ + { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; } + +#define mvswap(zzp1, zzp2, zzn) \ +{ \ + Int32 yyp1 = (zzp1); \ + Int32 yyp2 = (zzp2); \ + Int32 yyn = (zzn); \ + while (yyn > 0) { \ + mswap(ptr[yyp1], ptr[yyp2]); \ + yyp1++; yyp2++; yyn--; \ + } \ +} + +static +__inline__ +UChar mmed3 ( UChar a, UChar b, UChar c ) +{ + UChar t; + if (a > b) { t = a; a = b; b = t; }; + if (b > c) { + b = c; + if (a > b) b = a; + } + return b; +} + +#define mmin(a,b) ((a) < (b)) ? (a) : (b) + +#define mpush(lz,hz,dz) { stackLo[sp] = lz; \ + stackHi[sp] = hz; \ + stackD [sp] = dz; \ + sp++; } + +#define mpop(lz,hz,dz) { sp--; \ + lz = stackLo[sp]; \ + hz = stackHi[sp]; \ + dz = stackD [sp]; } + + +#define mnextsize(az) (nextHi[az]-nextLo[az]) + +#define mnextswap(az,bz) \ + { Int32 tz; \ + tz = nextLo[az]; nextLo[az] = nextLo[bz]; nextLo[bz] = tz; \ + tz = nextHi[az]; nextHi[az] = nextHi[bz]; nextHi[bz] = tz; \ + tz = nextD [az]; nextD [az] = nextD [bz]; nextD [bz] = tz; } + + +#define MAIN_QSORT_SMALL_THRESH 20 +#define MAIN_QSORT_DEPTH_THRESH (BZ_N_RADIX + BZ_N_QSORT) +#define MAIN_QSORT_STACK_SIZE 100 + +static +void mainQSort3 ( UInt32* ptr, + UChar* block, + UInt16* quadrant, + Int32 nblock, + Int32 loSt, + Int32 hiSt, + Int32 dSt, + Int32* budget ) +{ + Int32 unLo, unHi, ltLo, gtHi, n, m, med; + Int32 sp, lo, hi, d; + + Int32 stackLo[MAIN_QSORT_STACK_SIZE]; + Int32 stackHi[MAIN_QSORT_STACK_SIZE]; + Int32 stackD [MAIN_QSORT_STACK_SIZE]; + + Int32 nextLo[3]; + Int32 nextHi[3]; + Int32 nextD [3]; + + sp = 0; + mpush ( loSt, hiSt, dSt ); + + while (sp > 0) { + + AssertH ( sp < MAIN_QSORT_STACK_SIZE, 1001 ); + + mpop ( lo, hi, d ); + if (hi - lo < MAIN_QSORT_SMALL_THRESH || + d > MAIN_QSORT_DEPTH_THRESH) { + mainSimpleSort ( ptr, block, quadrant, nblock, lo, hi, d, budget ); + if (*budget < 0) return; + continue; + } + + med = (Int32) + mmed3 ( block[ptr[ lo ]+d], + block[ptr[ hi ]+d], + block[ptr[ (lo+hi)>>1 ]+d] ); + + unLo = ltLo = lo; + unHi = gtHi = hi; + + while (True) { + while (True) { + if (unLo > unHi) break; + n = ((Int32)block[ptr[unLo]+d]) - med; + if (n == 0) { + mswap(ptr[unLo], ptr[ltLo]); + ltLo++; unLo++; continue; + }; + if (n > 0) break; + unLo++; + } + while (True) { + if (unLo > unHi) break; + n = ((Int32)block[ptr[unHi]+d]) - med; + if (n == 0) { + mswap(ptr[unHi], ptr[gtHi]); + gtHi--; unHi--; continue; + }; + if (n < 0) break; + unHi--; + } + if (unLo > unHi) break; + mswap(ptr[unLo], ptr[unHi]); unLo++; unHi--; + } + + AssertD ( unHi == unLo-1, "mainQSort3(2)" ); + + if (gtHi < ltLo) { + mpush(lo, hi, d+1 ); + continue; + } + + n = mmin(ltLo-lo, unLo-ltLo); mvswap(lo, unLo-n, n); + m = mmin(hi-gtHi, gtHi-unHi); mvswap(unLo, hi-m+1, m); + + n = lo + unLo - ltLo - 1; + m = hi - (gtHi - unHi) + 1; + + nextLo[0] = lo; nextHi[0] = n; nextD[0] = d; + nextLo[1] = m; nextHi[1] = hi; nextD[1] = d; + nextLo[2] = n+1; nextHi[2] = m-1; nextD[2] = d+1; + + if (mnextsize(0) < mnextsize(1)) mnextswap(0,1); + if (mnextsize(1) < mnextsize(2)) mnextswap(1,2); + if (mnextsize(0) < mnextsize(1)) mnextswap(0,1); + + AssertD (mnextsize(0) >= mnextsize(1), "mainQSort3(8)" ); + AssertD (mnextsize(1) >= mnextsize(2), "mainQSort3(9)" ); + + mpush (nextLo[0], nextHi[0], nextD[0]); + mpush (nextLo[1], nextHi[1], nextD[1]); + mpush (nextLo[2], nextHi[2], nextD[2]); + } +} + +#undef mswap +#undef mvswap +#undef mpush +#undef mpop +#undef mmin +#undef mnextsize +#undef mnextswap +#undef MAIN_QSORT_SMALL_THRESH +#undef MAIN_QSORT_DEPTH_THRESH +#undef MAIN_QSORT_STACK_SIZE + + +/*---------------------------------------------*/ +/* Pre: + nblock > N_OVERSHOOT + block32 exists for [0 .. nblock-1 +N_OVERSHOOT] + ((UChar*)block32) [0 .. nblock-1] holds block + ptr exists for [0 .. nblock-1] + + Post: + ((UChar*)block32) [0 .. nblock-1] holds block + All other areas of block32 destroyed + ftab [0 .. 65536 ] destroyed + ptr [0 .. nblock-1] holds sorted order + if (*budget < 0), sorting was abandoned +*/ + +#define BIGFREQ(b) (ftab[((b)+1) << 8] - ftab[(b) << 8]) +#define SETMASK (1 << 21) +#define CLEARMASK (~(SETMASK)) + +static +void mainSort ( UInt32* ptr, + UChar* block, + UInt16* quadrant, + UInt32* ftab, + Int32 nblock, + Int32 verb, + Int32* budget ) +{ + Int32 i, j, k, ss, sb; + Int32 runningOrder[256]; + Bool bigDone[256]; + Int32 copyStart[256]; + Int32 copyEnd [256]; + UChar c1; + Int32 numQSorted; + UInt16 s; + if (verb >= 4) VPrintf0 ( " main sort initialise ...\n" ); + + /*-- set up the 2-byte frequency table --*/ + for (i = 65536; i >= 0; i--) ftab[i] = 0; + + j = block[0] << 8; + i = nblock-1; + for (; i >= 3; i -= 4) { + quadrant[i] = 0; + j = (j >> 8) | ( ((UInt16)block[i]) << 8); + ftab[j]++; + quadrant[i-1] = 0; + j = (j >> 8) | ( ((UInt16)block[i-1]) << 8); + ftab[j]++; + quadrant[i-2] = 0; + j = (j >> 8) | ( ((UInt16)block[i-2]) << 8); + ftab[j]++; + quadrant[i-3] = 0; + j = (j >> 8) | ( ((UInt16)block[i-3]) << 8); + ftab[j]++; + } + for (; i >= 0; i--) { + quadrant[i] = 0; + j = (j >> 8) | ( ((UInt16)block[i]) << 8); + ftab[j]++; + } + + /*-- (emphasises close relationship of block & quadrant) --*/ + for (i = 0; i < BZ_N_OVERSHOOT; i++) { + block [nblock+i] = block[i]; + quadrant[nblock+i] = 0; + } + + if (verb >= 4) VPrintf0 ( " bucket sorting ...\n" ); + + /*-- Complete the initial radix sort --*/ + for (i = 1; i <= 65536; i++) ftab[i] += ftab[i-1]; + + s = block[0] << 8; + i = nblock-1; + for (; i >= 3; i -= 4) { + s = (s >> 8) | (block[i] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i; + s = (s >> 8) | (block[i-1] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i-1; + s = (s >> 8) | (block[i-2] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i-2; + s = (s >> 8) | (block[i-3] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i-3; + } + for (; i >= 0; i--) { + s = (s >> 8) | (block[i] << 8); + j = ftab[s] -1; + ftab[s] = j; + ptr[j] = i; + } + + /*-- + Now ftab contains the first loc of every small bucket. + Calculate the running order, from smallest to largest + big bucket. + --*/ + for (i = 0; i <= 255; i++) { + bigDone [i] = False; + runningOrder[i] = i; + } + + { + Int32 vv; + Int32 h = 1; + do h = 3 * h + 1; while (h <= 256); + do { + h = h / 3; + for (i = h; i <= 255; i++) { + vv = runningOrder[i]; + j = i; + while ( BIGFREQ(runningOrder[j-h]) > BIGFREQ(vv) ) { + runningOrder[j] = runningOrder[j-h]; + j = j - h; + if (j <= (h - 1)) goto zero; + } + zero: + runningOrder[j] = vv; + } + } while (h != 1); + } + + /*-- + The main sorting loop. + --*/ + + numQSorted = 0; + + for (i = 0; i <= 255; i++) { + + /*-- + Process big buckets, starting with the least full. + Basically this is a 3-step process in which we call + mainQSort3 to sort the small buckets [ss, j], but + also make a big effort to avoid the calls if we can. + --*/ + ss = runningOrder[i]; + + /*-- + Step 1: + Complete the big bucket [ss] by quicksorting + any unsorted small buckets [ss, j], for j != ss. + Hopefully previous pointer-scanning phases have already + completed many of the small buckets [ss, j], so + we don't have to sort them at all. + --*/ + for (j = 0; j <= 255; j++) { + if (j != ss) { + sb = (ss << 8) + j; + if ( ! (ftab[sb] & SETMASK) ) { + Int32 lo = ftab[sb] & CLEARMASK; + Int32 hi = (ftab[sb+1] & CLEARMASK) - 1; + if (hi > lo) { + if (verb >= 4) + VPrintf4 ( " qsort [0x%x, 0x%x] " + "done %d this %d\n", + ss, j, numQSorted, hi - lo + 1 ); + mainQSort3 ( + ptr, block, quadrant, nblock, + lo, hi, BZ_N_RADIX, budget + ); + numQSorted += (hi - lo + 1); + if (*budget < 0) return; + } + } + ftab[sb] |= SETMASK; + } + } + + AssertH ( !bigDone[ss], 1006 ); + + /*-- + Step 2: + Now scan this big bucket [ss] so as to synthesise the + sorted order for small buckets [t, ss] for all t, + including, magically, the bucket [ss,ss] too. + This will avoid doing Real Work in subsequent Step 1's. + --*/ + { + for (j = 0; j <= 255; j++) { + copyStart[j] = ftab[(j << 8) + ss] & CLEARMASK; + copyEnd [j] = (ftab[(j << 8) + ss + 1] & CLEARMASK) - 1; + } + for (j = ftab[ss << 8] & CLEARMASK; j < copyStart[ss]; j++) { + k = ptr[j]-1; if (k < 0) k += nblock; + c1 = block[k]; + if (!bigDone[c1]) + ptr[ copyStart[c1]++ ] = k; + } + for (j = (ftab[(ss+1) << 8] & CLEARMASK) - 1; j > copyEnd[ss]; j--) { + k = ptr[j]-1; if (k < 0) k += nblock; + c1 = block[k]; + if (!bigDone[c1]) + ptr[ copyEnd[c1]-- ] = k; + } + } + + AssertH ( copyStart[ss]-1 == copyEnd[ss], 1007 ); + + for (j = 0; j <= 255; j++) ftab[(j << 8) + ss] |= SETMASK; + + /*-- + Step 3: + The [ss] big bucket is now done. Record this fact, + and update the quadrant descriptors. Remember to + update quadrants in the overshoot area too, if + necessary. The "if (i < 255)" test merely skips + this updating for the last bucket processed, since + updating for the last bucket is pointless. + + The quadrant array provides a way to incrementally + cache sort orderings, as they appear, so as to + make subsequent comparisons in fullGtU() complete + faster. For repetitive blocks this makes a big + difference (but not big enough to be able to avoid + the fallback sorting mechanism, exponential radix sort). + + The precise meaning is: at all times: + + for 0 <= i < nblock and 0 <= j <= nblock + + if block[i] != block[j], + + then the relative values of quadrant[i] and + quadrant[j] are meaningless. + + else { + if quadrant[i] < quadrant[j] + then the string starting at i lexicographically + precedes the string starting at j + + else if quadrant[i] > quadrant[j] + then the string starting at j lexicographically + precedes the string starting at i + + else + the relative ordering of the strings starting + at i and j has not yet been determined. + } + --*/ + bigDone[ss] = True; + + if (i < 255) { + Int32 bbStart = ftab[ss << 8] & CLEARMASK; + Int32 bbSize = (ftab[(ss+1) << 8] & CLEARMASK) - bbStart; + Int32 shifts = 0; + + while ((bbSize >> shifts) > 65534) shifts++; + + for (j = bbSize-1; j >= 0; j--) { + Int32 a2update = ptr[bbStart + j]; + UInt16 qVal = (UInt16)(j >> shifts); + quadrant[a2update] = qVal; + if (a2update < BZ_N_OVERSHOOT) + quadrant[a2update + nblock] = qVal; + } + AssertH ( ((bbSize-1) >> shifts) <= 65535, 1002 ); + } + + } + + if (verb >= 4) + VPrintf3 ( " %d pointers, %d sorted, %d scanned\n", + nblock, numQSorted, nblock - numQSorted ); +} + +#undef BIGFREQ +#undef SETMASK +#undef CLEARMASK + + +/*---------------------------------------------*/ +/* Pre: + nblock > 0 + arr2 exists for [0 .. nblock-1 +N_OVERSHOOT] + ((UChar*)arr2) [0 .. nblock-1] holds block + arr1 exists for [0 .. nblock-1] + + Post: + ((UChar*)arr2) [0 .. nblock-1] holds block + All other areas of block destroyed + ftab [ 0 .. 65536 ] destroyed + arr1 [0 .. nblock-1] holds sorted order +*/ +void BZ2_blockSort ( EState* s ) +{ + UInt32* ptr = s->ptr; + UChar* block = s->block; + UInt32* ftab = s->ftab; + Int32 nblock = s->nblock; + Int32 verb = s->verbosity; + Int32 wfact = s->workFactor; + UInt16* quadrant; + Int32 budget; + Int32 budgetInit; + Int32 i; + + if (nblock < 10000) { + fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb ); + } else { + /* Calculate the location for quadrant, remembering to get + the alignment right. Assumes that &(block[0]) is at least + 2-byte aligned -- this should be ok since block is really + the first section of arr2. + */ + i = nblock+BZ_N_OVERSHOOT; + if (i & 1) i++; + quadrant = (UInt16*)(&(block[i])); + + /* (wfact-1) / 3 puts the default-factor-30 + transition point at very roughly the same place as + with v0.1 and v0.9.0. + Not that it particularly matters any more, since the + resulting compressed stream is now the same regardless + of whether or not we use the main sort or fallback sort. + */ + if (wfact < 1 ) wfact = 1; + if (wfact > 100) wfact = 100; + budgetInit = nblock * ((wfact-1) / 3); + budget = budgetInit; + + mainSort ( ptr, block, quadrant, ftab, nblock, verb, &budget ); + if (verb >= 3) + VPrintf3 ( " %d work, %d block, ratio %5.2f\n", + budgetInit - budget, + nblock, + (float)(budgetInit - budget) / + (float)(nblock==0 ? 1 : nblock) ); + if (budget < 0) { + if (verb >= 2) + VPrintf0 ( " too repetitive; using fallback" + " sorting algorithm\n" ); + fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb ); + } + } + + s->origPtr = -1; + for (i = 0; i < s->nblock; i++) + if (ptr[i] == 0) + { s->origPtr = i; break; }; + + AssertH( s->origPtr != -1, 1003 ); +} + + +/*-------------------------------------------------------------*/ +/*--- end blocksort.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/contrib/bzip2/bzip2.1 b/contrib/bzip2/bzip2.1 new file mode 100644 index 000000000000..7de54a0118c3 --- /dev/null +++ b/contrib/bzip2/bzip2.1 @@ -0,0 +1,439 @@ +.PU +.TH bzip2 1 +.SH NAME +bzip2, bunzip2 \- a block-sorting file compressor, v1.0 +.br +bzcat \- decompresses files to stdout +.br +bzip2recover \- recovers data from damaged bzip2 files + +.SH SYNOPSIS +.ll +8 +.B bzip2 +.RB [ " \-cdfkqstvzVL123456789 " ] +[ +.I "filenames \&..." +] +.ll -8 +.br +.B bunzip2 +.RB [ " \-fkvsVL " ] +[ +.I "filenames \&..." +] +.br +.B bzcat +.RB [ " \-s " ] +[ +.I "filenames \&..." +] +.br +.B bzip2recover +.I "filename" + +.SH DESCRIPTION +.I bzip2 +compresses files using the Burrows-Wheeler block sorting +text compression algorithm, and Huffman coding. Compression is +generally considerably better than that achieved by more conventional +LZ77/LZ78-based compressors, and approaches the performance of the PPM +family of statistical compressors. + +The command-line options are deliberately very similar to +those of +.I GNU gzip, +but they are not identical. + +.I bzip2 +expects a list of file names to accompany the +command-line flags. Each file is replaced by a compressed version of +itself, with the name "original_name.bz2". +Each compressed file +has the same modification date, permissions, and, when possible, +ownership as the corresponding original, so that these properties can +be correctly restored at decompression time. File name handling is +naive in the sense that there is no mechanism for preserving original +file names, permissions, ownerships or dates in filesystems which lack +these concepts, or have serious file name length restrictions, such as +MS-DOS. + +.I bzip2 +and +.I bunzip2 +will by default not overwrite existing +files. If you want this to happen, specify the \-f flag. + +If no file names are specified, +.I bzip2 +compresses from standard +input to standard output. In this case, +.I bzip2 +will decline to +write compressed output to a terminal, as this would be entirely +incomprehensible and therefore pointless. + +.I bunzip2 +(or +.I bzip2 \-d) +decompresses all +specified files. Files which were not created by +.I bzip2 +will be detected and ignored, and a warning issued. +.I bzip2 +attempts to guess the filename for the decompressed file +from that of the compressed file as follows: + + filename.bz2 becomes filename + filename.bz becomes filename + filename.tbz2 becomes filename.tar + filename.tbz becomes filename.tar + anyothername becomes anyothername.out + +If the file does not end in one of the recognised endings, +.I .bz2, +.I .bz, +.I .tbz2 +or +.I .tbz, +.I bzip2 +complains that it cannot +guess the name of the original file, and uses the original name +with +.I .out +appended. + +As with compression, supplying no +filenames causes decompression from +standard input to standard output. + +.I bunzip2 +will correctly decompress a file which is the +concatenation of two or more compressed files. The result is the +concatenation of the corresponding uncompressed files. Integrity +testing (\-t) +of concatenated +compressed files is also supported. + +You can also compress or decompress files to the standard output by +giving the \-c flag. Multiple files may be compressed and +decompressed like this. The resulting outputs are fed sequentially to +stdout. Compression of multiple files +in this manner generates a stream +containing multiple compressed file representations. Such a stream +can be decompressed correctly only by +.I bzip2 +version 0.9.0 or +later. Earlier versions of +.I bzip2 +will stop after decompressing +the first file in the stream. + +.I bzcat +(or +.I bzip2 -dc) +decompresses all specified files to +the standard output. + +.I bzip2 +will read arguments from the environment variables +.I BZIP2 +and +.I BZIP, +in that order, and will process them +before any arguments read from the command line. This gives a +convenient way to supply default arguments. + +Compression is always performed, even if the compressed +file is slightly +larger than the original. Files of less than about one hundred bytes +tend to get larger, since the compression mechanism has a constant +overhead in the region of 50 bytes. Random data (including the output +of most file compressors) is coded at about 8.05 bits per byte, giving +an expansion of around 0.5%. + +As a self-check for your protection, +.I +bzip2 +uses 32-bit CRCs to +make sure that the decompressed version of a file is identical to the +original. This guards against corruption of the compressed data, and +against undetected bugs in +.I bzip2 +(hopefully very unlikely). The +chances of data corruption going undetected is microscopic, about one +chance in four billion for each file processed. Be aware, though, that +the check occurs upon decompression, so it can only tell you that +something is wrong. It can't help you +recover the original uncompressed +data. You can use +.I bzip2recover +to try to recover data from +damaged files. + +Return values: 0 for a normal exit, 1 for environmental problems (file +not found, invalid flags, I/O errors, &c), 2 to indicate a corrupt +compressed file, 3 for an internal consistency error (eg, bug) which +caused +.I bzip2 +to panic. + +.SH OPTIONS +.TP +.B \-c --stdout +Compress or decompress to standard output. +.TP +.B \-d --decompress +Force decompression. +.I bzip2, +.I bunzip2 +and +.I bzcat +are +really the same program, and the decision about what actions to take is +done on the basis of which name is used. This flag overrides that +mechanism, and forces +.I bzip2 +to decompress. +.TP +.B \-z --compress +The complement to \-d: forces compression, regardless of the +invokation name. +.TP +.B \-t --test +Check integrity of the specified file(s), but don't decompress them. +This really performs a trial decompression and throws away the result. +.TP +.B \-f --force +Force overwrite of output files. Normally, +.I bzip2 +will not overwrite +existing output files. Also forces +.I bzip2 +to break hard links +to files, which it otherwise wouldn't do. +.TP +.B \-k --keep +Keep (don't delete) input files during compression +or decompression. +.TP +.B \-s --small +Reduce memory usage, for compression, decompression and testing. Files +are decompressed and tested using a modified algorithm which only +requires 2.5 bytes per block byte. This means any file can be +decompressed in 2300k of memory, albeit at about half the normal speed. + +During compression, \-s selects a block size of 200k, which limits +memory use to around the same figure, at the expense of your compression +ratio. In short, if your machine is low on memory (8 megabytes or +less), use \-s for everything. See MEMORY MANAGEMENT below. +.TP +.B \-q --quiet +Suppress non-essential warning messages. Messages pertaining to +I/O errors and other critical events will not be suppressed. +.TP +.B \-v --verbose +Verbose mode -- show the compression ratio for each file processed. +Further \-v's increase the verbosity level, spewing out lots of +information which is primarily of interest for diagnostic purposes. +.TP +.B \-L --license -V --version +Display the software version, license terms and conditions. +.TP +.B \-1 to \-9 +Set the block size to 100 k, 200 k .. 900 k when compressing. Has no +effect when decompressing. See MEMORY MANAGEMENT below. +.TP +.B \-- +Treats all subsequent arguments as file names, even if they start +with a dash. This is so you can handle files with names beginning +with a dash, for example: bzip2 \-- \-myfilename. +.TP +.B \--repetitive-fast --repetitive-best +These flags are redundant in versions 0.9.5 and above. They provided +some coarse control over the behaviour of the sorting algorithm in +earlier versions, which was sometimes useful. 0.9.5 and above have an +improved algorithm which renders these flags irrelevant. + +.SH MEMORY MANAGEMENT +.I bzip2 +compresses large files in blocks. The block size affects +both the compression ratio achieved, and the amount of memory needed for +compression and decompression. The flags \-1 through \-9 +specify the block size to be 100,000 bytes through 900,000 bytes (the +default) respectively. At decompression time, the block size used for +compression is read from the header of the compressed file, and +.I bunzip2 +then allocates itself just enough memory to decompress +the file. Since block sizes are stored in compressed files, it follows +that the flags \-1 to \-9 are irrelevant to and so ignored +during decompression. + +Compression and decompression requirements, +in bytes, can be estimated as: + + Compression: 400k + ( 8 x block size ) + + Decompression: 100k + ( 4 x block size ), or + 100k + ( 2.5 x block size ) + +Larger block sizes give rapidly diminishing marginal returns. Most of +the compression comes from the first two or three hundred k of block +size, a fact worth bearing in mind when using +.I bzip2 +on small machines. +It is also important to appreciate that the decompression memory +requirement is set at compression time by the choice of block size. + +For files compressed with the default 900k block size, +.I bunzip2 +will require about 3700 kbytes to decompress. To support decompression +of any file on a 4 megabyte machine, +.I bunzip2 +has an option to +decompress using approximately half this amount of memory, about 2300 +kbytes. Decompression speed is also halved, so you should use this +option only where necessary. The relevant flag is -s. + +In general, try and use the largest block size memory constraints allow, +since that maximises the compression achieved. Compression and +decompression speed are virtually unaffected by block size. + +Another significant point applies to files which fit in a single block +-- that means most files you'd encounter using a large block size. The +amount of real memory touched is proportional to the size of the file, +since the file is smaller than a block. For example, compressing a file +20,000 bytes long with the flag -9 will cause the compressor to +allocate around 7600k of memory, but only touch 400k + 20000 * 8 = 560 +kbytes of it. Similarly, the decompressor will allocate 3700k but only +touch 100k + 20000 * 4 = 180 kbytes. + +Here is a table which summarises the maximum memory usage for different +block sizes. Also recorded is the total compressed size for 14 files of +the Calgary Text Compression Corpus totalling 3,141,622 bytes. This +column gives some feel for how compression varies with block size. +These figures tend to understate the advantage of larger block sizes for +larger files, since the Corpus is dominated by smaller files. + + Compress Decompress Decompress Corpus + Flag usage usage -s usage Size + + -1 1200k 500k 350k 914704 + -2 2000k 900k 600k 877703 + -3 2800k 1300k 850k 860338 + -4 3600k 1700k 1100k 846899 + -5 4400k 2100k 1350k 845160 + -6 5200k 2500k 1600k 838626 + -7 6100k 2900k 1850k 834096 + -8 6800k 3300k 2100k 828642 + -9 7600k 3700k 2350k 828642 + +.SH RECOVERING DATA FROM DAMAGED FILES +.I bzip2 +compresses files in blocks, usually 900kbytes long. Each +block is handled independently. If a media or transmission error causes +a multi-block .bz2 +file to become damaged, it may be possible to +recover data from the undamaged blocks in the file. + +The compressed representation of each block is delimited by a 48-bit +pattern, which makes it possible to find the block boundaries with +reasonable certainty. Each block also carries its own 32-bit CRC, so +damaged blocks can be distinguished from undamaged ones. + +.I bzip2recover +is a simple program whose purpose is to search for +blocks in .bz2 files, and write each block out into its own .bz2 +file. You can then use +.I bzip2 +\-t +to test the +integrity of the resulting files, and decompress those which are +undamaged. + +.I bzip2recover +takes a single argument, the name of the damaged file, +and writes a number of files "rec0001file.bz2", +"rec0002file.bz2", etc, containing the extracted blocks. +The output filenames are designed so that the use of +wildcards in subsequent processing -- for example, +"bzip2 -dc rec*file.bz2 > recovered_data" -- lists the files in +the correct order. + +.I bzip2recover +should be of most use dealing with large .bz2 +files, as these will contain many blocks. It is clearly +futile to use it on damaged single-block files, since a +damaged block cannot be recovered. If you wish to minimise +any potential data loss through media or transmission errors, +you might consider compressing with a smaller +block size. + +.SH PERFORMANCE NOTES +The sorting phase of compression gathers together similar strings in the +file. Because of this, files containing very long runs of repeated +symbols, like "aabaabaabaab ..." (repeated several hundred times) may +compress more slowly than normal. Versions 0.9.5 and above fare much +better than previous versions in this respect. The ratio between +worst-case and average-case compression time is in the region of 10:1. +For previous versions, this figure was more like 100:1. You can use the +\-vvvv option to monitor progress in great detail, if you want. + +Decompression speed is unaffected by these phenomena. + +.I bzip2 +usually allocates several megabytes of memory to operate +in, and then charges all over it in a fairly random fashion. This means +that performance, both for compressing and decompressing, is largely +determined by the speed at which your machine can service cache misses. +Because of this, small changes to the code to reduce the miss rate have +been observed to give disproportionately large performance improvements. +I imagine +.I bzip2 +will perform best on machines with very large caches. + +.SH CAVEATS +I/O error messages are not as helpful as they could be. +.I bzip2 +tries hard to detect I/O errors and exit cleanly, but the details of +what the problem is sometimes seem rather misleading. + +This manual page pertains to version 1.0 of +.I bzip2. +Compressed +data created by this version is entirely forwards and backwards +compatible with the previous public releases, versions 0.1pl2, 0.9.0 +and 0.9.5, +but with the following exception: 0.9.0 and above can correctly +decompress multiple concatenated compressed files. 0.1pl2 cannot do +this; it will stop after decompressing just the first file in the +stream. + +.I bzip2recover +uses 32-bit integers to represent bit positions in +compressed files, so it cannot handle compressed files more than 512 +megabytes long. This could easily be fixed. + +.SH AUTHOR +Julian Seward, jseward@acm.org. + +http://sourceware.cygnus.com/bzip2 +http://www.muraroa.demon.co.uk + +The ideas embodied in +.I bzip2 +are due to (at least) the following +people: Michael Burrows and David Wheeler (for the block sorting +transformation), David Wheeler (again, for the Huffman coder), Peter +Fenwick (for the structured coding model in the original +.I bzip, +and many refinements), and Alistair Moffat, Radford Neal and Ian Witten +(for the arithmetic coder in the original +.I bzip). +I am much +indebted for their help, support and advice. See the manual in the +source distribution for pointers to sources of documentation. Christian +von Roques encouraged me to look for faster sorting algorithms, so as to +speed up compression. Bela Lubkin encouraged me to improve the +worst-case compression performance. Many people sent patches, helped +with portability problems, lent machines, gave advice and were generally +helpful. diff --git a/contrib/bzip2/bzip2.c b/contrib/bzip2/bzip2.c new file mode 100644 index 000000000000..56adfdcbc46b --- /dev/null +++ b/contrib/bzip2/bzip2.c @@ -0,0 +1,2044 @@ + +/*-----------------------------------------------------------*/ +/*--- A block-sorting, lossless compressor bzip2.c ---*/ +/*-----------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + + +/*----------------------------------------------------*/ +/*--- IMPORTANT ---*/ +/*----------------------------------------------------*/ + +/*-- + WARNING: + This program and library (attempts to) compress data by + performing several non-trivial transformations on it. + Unless you are 100% familiar with *all* the algorithms + contained herein, and with the consequences of modifying them, + you should NOT meddle with the compression or decompression + machinery. Incorrect changes can and very likely *will* + lead to disasterous loss of data. + + DISCLAIMER: + I TAKE NO RESPONSIBILITY FOR ANY LOSS OF DATA ARISING FROM THE + USE OF THIS PROGRAM, HOWSOEVER CAUSED. + + Every compression of a file implies an assumption that the + compressed file can be decompressed to reproduce the original. + Great efforts in design, coding and testing have been made to + ensure that this program works correctly. However, the + complexity of the algorithms, and, in particular, the presence + of various special cases in the code which occur with very low + but non-zero probability make it impossible to rule out the + possibility of bugs remaining in the program. DO NOT COMPRESS + ANY DATA WITH THIS PROGRAM AND/OR LIBRARY UNLESS YOU ARE PREPARED + TO ACCEPT THE POSSIBILITY, HOWEVER SMALL, THAT THE DATA WILL + NOT BE RECOVERABLE. + + That is not to say this program is inherently unreliable. + Indeed, I very much hope the opposite is true. bzip2/libbzip2 + has been carefully constructed and extensively tested. + + PATENTS: + To the best of my knowledge, bzip2/libbzip2 does not use any + patented algorithms. However, I do not have the resources + available to carry out a full patent search. Therefore I cannot + give any guarantee of the above statement. +--*/ + + + +/*----------------------------------------------------*/ +/*--- and now for something much more pleasant :-) ---*/ +/*----------------------------------------------------*/ + +/*---------------------------------------------*/ +/*-- + Place a 1 beside your platform, and 0 elsewhere. +--*/ + +/*-- + Generic 32-bit Unix. + Also works on 64-bit Unix boxes. +--*/ +#define BZ_UNIX 1 + +/*-- + Win32, as seen by Jacob Navia's excellent + port of (Chris Fraser & David Hanson)'s excellent + lcc compiler. +--*/ +#define BZ_LCCWIN32 0 + +#if defined(_WIN32) && !defined(__CYGWIN__) +#undef BZ_LCCWIN32 +#define BZ_LCCWIN32 1 +#undef BZ_UNIX +#define BZ_UNIX 0 +#endif + + +/*---------------------------------------------*/ +/*-- + Some stuff for all platforms. +--*/ + +#include +#include +#include +#include +#include +#include +#include +#include "bzlib.h" + +#define ERROR_IF_EOF(i) { if ((i) == EOF) ioError(); } +#define ERROR_IF_NOT_ZERO(i) { if ((i) != 0) ioError(); } +#define ERROR_IF_MINUS_ONE(i) { if ((i) == (-1)) ioError(); } + + +/*---------------------------------------------*/ +/*-- + Platform-specific stuff. +--*/ + +#if BZ_UNIX +# include +# include +# include +# include +# include + +# define PATH_SEP '/' +# define MY_LSTAT lstat +# define MY_S_IFREG S_ISREG +# define MY_STAT stat + +# define APPEND_FILESPEC(root, name) \ + root=snocString((root), (name)) + +# define APPEND_FLAG(root, name) \ + root=snocString((root), (name)) + +# define SET_BINARY_MODE(fd) /**/ + +# ifdef __GNUC__ +# define NORETURN __attribute__ ((noreturn)) +# else +# define NORETURN /**/ +# endif +# ifdef __DJGPP__ +# include +# include +# undef MY_LSTAT +# define MY_LSTAT stat +# undef SET_BINARY_MODE +# define SET_BINARY_MODE(fd) \ + do { \ + int retVal = setmode ( fileno ( fd ), \ + O_BINARY ); \ + ERROR_IF_MINUS_ONE ( retVal ); \ + } while ( 0 ) +# endif +# ifdef __CYGWIN__ +# include +# include +# undef SET_BINARY_MODE +# define SET_BINARY_MODE(fd) \ + do { \ + int retVal = setmode ( fileno ( fd ), \ + O_BINARY ); \ + ERROR_IF_MINUS_ONE ( retVal ); \ + } while ( 0 ) +# endif +#endif + + + +#if BZ_LCCWIN32 +# include +# include +# include + +# define NORETURN /**/ +# define PATH_SEP '\\' +# define MY_LSTAT _stat +# define MY_STAT _stat +# define MY_S_IFREG(x) ((x) & _S_IFREG) + +# define APPEND_FLAG(root, name) \ + root=snocString((root), (name)) + +# if 0 + /*-- lcc-win32 seems to expand wildcards itself --*/ +# define APPEND_FILESPEC(root, spec) \ + do { \ + if ((spec)[0] == '-') { \ + root = snocString((root), (spec)); \ + } else { \ + struct _finddata_t c_file; \ + long hFile; \ + hFile = _findfirst((spec), &c_file); \ + if ( hFile == -1L ) { \ + root = snocString ((root), (spec)); \ + } else { \ + int anInt = 0; \ + while ( anInt == 0 ) { \ + root = snocString((root), \ + &c_file.name[0]); \ + anInt = _findnext(hFile, &c_file); \ + } \ + } \ + } \ + } while ( 0 ) +# else +# define APPEND_FILESPEC(root, name) \ + root = snocString ((root), (name)) +# endif + +# define SET_BINARY_MODE(fd) \ + do { \ + int retVal = setmode ( fileno ( fd ), \ + O_BINARY ); \ + ERROR_IF_MINUS_ONE ( retVal ); \ + } while ( 0 ) + +#endif + + +/*---------------------------------------------*/ +/*-- + Some more stuff for all platforms :-) +--*/ + +typedef char Char; +typedef unsigned char Bool; +typedef unsigned char UChar; +typedef int Int32; +typedef unsigned int UInt32; +typedef short Int16; +typedef unsigned short UInt16; + +#define True ((Bool)1) +#define False ((Bool)0) + +/*-- + IntNative is your platform's `native' int size. + Only here to avoid probs with 64-bit platforms. +--*/ +typedef int IntNative; + + +/*---------------------------------------------------*/ +/*--- Misc (file handling) data decls ---*/ +/*---------------------------------------------------*/ + +Int32 verbosity; +Bool keepInputFiles, smallMode, deleteOutputOnInterrupt; +Bool forceOverwrite, testFailsExist, unzFailsExist, noisy; +Int32 numFileNames, numFilesProcessed, blockSize100k; +Int32 exitValue; + +/*-- source modes; F==file, I==stdin, O==stdout --*/ +#define SM_I2O 1 +#define SM_F2O 2 +#define SM_F2F 3 + +/*-- operation modes --*/ +#define OM_Z 1 +#define OM_UNZ 2 +#define OM_TEST 3 + +Int32 opMode; +Int32 srcMode; + +#define FILE_NAME_LEN 1034 + +Int32 longestFileName; +Char inName [FILE_NAME_LEN]; +Char outName[FILE_NAME_LEN]; +Char tmpName[FILE_NAME_LEN]; +Char *progName; +Char progNameReally[FILE_NAME_LEN]; +FILE *outputHandleJustInCase; +Int32 workFactor; + +static void panic ( Char* ) NORETURN; +static void ioError ( void ) NORETURN; +static void outOfMemory ( void ) NORETURN; +static void configError ( void ) NORETURN; +static void crcError ( void ) NORETURN; +static void cleanUpAndFail ( Int32 ) NORETURN; +static void compressedStreamEOF ( void ) NORETURN; + +static void copyFileName ( Char*, Char* ); +static void* myMalloc ( Int32 ); + + + +/*---------------------------------------------------*/ +/*--- An implementation of 64-bit ints. Sigh. ---*/ +/*--- Roll on widespread deployment of ANSI C9X ! ---*/ +/*---------------------------------------------------*/ + +typedef + struct { UChar b[8]; } + UInt64; + +static +void uInt64_from_UInt32s ( UInt64* n, UInt32 lo32, UInt32 hi32 ) +{ + n->b[7] = (UChar)((hi32 >> 24) & 0xFF); + n->b[6] = (UChar)((hi32 >> 16) & 0xFF); + n->b[5] = (UChar)((hi32 >> 8) & 0xFF); + n->b[4] = (UChar) (hi32 & 0xFF); + n->b[3] = (UChar)((lo32 >> 24) & 0xFF); + n->b[2] = (UChar)((lo32 >> 16) & 0xFF); + n->b[1] = (UChar)((lo32 >> 8) & 0xFF); + n->b[0] = (UChar) (lo32 & 0xFF); +} + +static +double uInt64_to_double ( UInt64* n ) +{ + Int32 i; + double base = 1.0; + double sum = 0.0; + for (i = 0; i < 8; i++) { + sum += base * (double)(n->b[i]); + base *= 256.0; + } + return sum; +} + +static +void uInt64_add ( UInt64* src, UInt64* dst ) +{ + Int32 i; + Int32 carry = 0; + for (i = 0; i < 8; i++) { + carry += ( ((Int32)src->b[i]) + ((Int32)dst->b[i]) ); + dst->b[i] = (UChar)(carry & 0xFF); + carry >>= 8; + } +} + +static +void uInt64_sub ( UInt64* src, UInt64* dst ) +{ + Int32 t, i; + Int32 borrow = 0; + for (i = 0; i < 8; i++) { + t = ((Int32)dst->b[i]) - ((Int32)src->b[i]) - borrow; + if (t < 0) { + dst->b[i] = (UChar)(t + 256); + borrow = 1; + } else { + dst->b[i] = (UChar)t; + borrow = 0; + } + } +} + +static +void uInt64_mul ( UInt64* a, UInt64* b, UInt64* r_hi, UInt64* r_lo ) +{ + UChar sum[16]; + Int32 ia, ib, carry; + for (ia = 0; ia < 16; ia++) sum[ia] = 0; + for (ia = 0; ia < 8; ia++) { + carry = 0; + for (ib = 0; ib < 8; ib++) { + carry += ( ((Int32)sum[ia+ib]) + + ((Int32)a->b[ia]) * ((Int32)b->b[ib]) ); + sum[ia+ib] = (UChar)(carry & 0xFF); + carry >>= 8; + } + sum[ia+8] = (UChar)(carry & 0xFF); + if ((carry >>= 8) != 0) panic ( "uInt64_mul" ); + } + + for (ia = 0; ia < 8; ia++) r_hi->b[ia] = sum[ia+8]; + for (ia = 0; ia < 8; ia++) r_lo->b[ia] = sum[ia]; +} + + +static +void uInt64_shr1 ( UInt64* n ) +{ + Int32 i; + for (i = 0; i < 8; i++) { + n->b[i] >>= 1; + if (i < 7 && (n->b[i+1] & 1)) n->b[i] |= 0x80; + } +} + +static +void uInt64_shl1 ( UInt64* n ) +{ + Int32 i; + for (i = 7; i >= 0; i--) { + n->b[i] <<= 1; + if (i > 0 && (n->b[i-1] & 0x80)) n->b[i]++; + } +} + +static +Bool uInt64_isZero ( UInt64* n ) +{ + Int32 i; + for (i = 0; i < 8; i++) + if (n->b[i] != 0) return 0; + return 1; +} + +static +Int32 uInt64_qrm10 ( UInt64* n ) +{ + /* Divide *n by 10, and return the remainder. Long division + is difficult, so we cheat and instead multiply by + 0xCCCC CCCC CCCC CCCD, which is 0.8 (viz, 0.1 << 3). + */ + Int32 i; + UInt64 tmp1, tmp2, n_orig, zero_point_eight; + + zero_point_eight.b[1] = zero_point_eight.b[2] = + zero_point_eight.b[3] = zero_point_eight.b[4] = + zero_point_eight.b[5] = zero_point_eight.b[6] = + zero_point_eight.b[7] = 0xCC; + zero_point_eight.b[0] = 0xCD; + + n_orig = *n; + + /* divide n by 10, + by multiplying by 0.8 and then shifting right 3 times */ + uInt64_mul ( n, &zero_point_eight, &tmp1, &tmp2 ); + uInt64_shr1(&tmp1); uInt64_shr1(&tmp1); uInt64_shr1(&tmp1); + *n = tmp1; + + /* tmp1 = 8*n, tmp2 = 2*n */ + uInt64_shl1(&tmp1); uInt64_shl1(&tmp1); uInt64_shl1(&tmp1); + tmp2 = *n; uInt64_shl1(&tmp2); + + /* tmp1 = 10*n */ + uInt64_add ( &tmp2, &tmp1 ); + + /* n_orig = n_orig - 10*n */ + uInt64_sub ( &tmp1, &n_orig ); + + /* n_orig should now hold quotient, in range 0 .. 9 */ + for (i = 7; i >= 1; i--) + if (n_orig.b[i] != 0) panic ( "uInt64_qrm10(1)" ); + if (n_orig.b[0] > 9) + panic ( "uInt64_qrm10(2)" ); + + return (int)n_orig.b[0]; +} + +/* ... and the Whole Entire Point of all this UInt64 stuff is + so that we can supply the following function. +*/ +static +void uInt64_toAscii ( char* outbuf, UInt64* n ) +{ + Int32 i, q; + UChar buf[32]; + Int32 nBuf = 0; + UInt64 n_copy = *n; + do { + q = uInt64_qrm10 ( &n_copy ); + buf[nBuf] = q + '0'; + nBuf++; + } while (!uInt64_isZero(&n_copy)); + outbuf[nBuf] = 0; + for (i = 0; i < nBuf; i++) outbuf[i] = buf[nBuf-i-1]; +} + + +/*---------------------------------------------------*/ +/*--- Processing of complete files and streams ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------*/ +static +Bool myfeof ( FILE* f ) +{ + Int32 c = fgetc ( f ); + if (c == EOF) return True; + ungetc ( c, f ); + return False; +} + + +/*---------------------------------------------*/ +static +void compressStream ( FILE *stream, FILE *zStream ) +{ + BZFILE* bzf = NULL; + UChar ibuf[5000]; + Int32 nIbuf; + UInt32 nbytes_in_lo32, nbytes_in_hi32; + UInt32 nbytes_out_lo32, nbytes_out_hi32; + Int32 bzerr, bzerr_dummy, ret; + + SET_BINARY_MODE(stream); + SET_BINARY_MODE(zStream); + + if (ferror(stream)) goto errhandler_io; + if (ferror(zStream)) goto errhandler_io; + + bzf = BZ2_bzWriteOpen ( &bzerr, zStream, + blockSize100k, verbosity, workFactor ); + if (bzerr != BZ_OK) goto errhandler; + + if (verbosity >= 2) fprintf ( stderr, "\n" ); + + while (True) { + + if (myfeof(stream)) break; + nIbuf = fread ( ibuf, sizeof(UChar), 5000, stream ); + if (ferror(stream)) goto errhandler_io; + if (nIbuf > 0) BZ2_bzWrite ( &bzerr, bzf, (void*)ibuf, nIbuf ); + if (bzerr != BZ_OK) goto errhandler; + + } + + BZ2_bzWriteClose64 ( &bzerr, bzf, 0, + &nbytes_in_lo32, &nbytes_in_hi32, + &nbytes_out_lo32, &nbytes_out_hi32 ); + if (bzerr != BZ_OK) goto errhandler; + + if (ferror(zStream)) goto errhandler_io; + ret = fflush ( zStream ); + if (ret == EOF) goto errhandler_io; + if (zStream != stdout) { + ret = fclose ( zStream ); + if (ret == EOF) goto errhandler_io; + } + if (ferror(stream)) goto errhandler_io; + ret = fclose ( stream ); + if (ret == EOF) goto errhandler_io; + + if (nbytes_in_lo32 == 0 && nbytes_in_hi32 == 0) + nbytes_in_lo32 = 1; + + if (verbosity >= 1) { + Char buf_nin[32], buf_nout[32]; + UInt64 nbytes_in, nbytes_out; + double nbytes_in_d, nbytes_out_d; + uInt64_from_UInt32s ( &nbytes_in, + nbytes_in_lo32, nbytes_in_hi32 ); + uInt64_from_UInt32s ( &nbytes_out, + nbytes_out_lo32, nbytes_out_hi32 ); + nbytes_in_d = uInt64_to_double ( &nbytes_in ); + nbytes_out_d = uInt64_to_double ( &nbytes_out ); + uInt64_toAscii ( buf_nin, &nbytes_in ); + uInt64_toAscii ( buf_nout, &nbytes_out ); + fprintf ( stderr, "%6.3f:1, %6.3f bits/byte, " + "%5.2f%% saved, %s in, %s out.\n", + nbytes_in_d / nbytes_out_d, + (8.0 * nbytes_out_d) / nbytes_in_d, + 100.0 * (1.0 - nbytes_out_d / nbytes_in_d), + buf_nin, + buf_nout + ); + } + + return; + + errhandler: + BZ2_bzWriteClose64 ( &bzerr_dummy, bzf, 1, + &nbytes_in_lo32, &nbytes_in_hi32, + &nbytes_out_lo32, &nbytes_out_hi32 ); + switch (bzerr) { + case BZ_CONFIG_ERROR: + configError(); break; + case BZ_MEM_ERROR: + outOfMemory (); break; + case BZ_IO_ERROR: + errhandler_io: + ioError(); break; + default: + panic ( "compress:unexpected error" ); + } + + panic ( "compress:end" ); + /*notreached*/ +} + + + +/*---------------------------------------------*/ +static +Bool uncompressStream ( FILE *zStream, FILE *stream ) +{ + BZFILE* bzf = NULL; + Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i; + UChar obuf[5000]; + UChar unused[BZ_MAX_UNUSED]; + Int32 nUnused; + UChar* unusedTmp; + + nUnused = 0; + streamNo = 0; + + SET_BINARY_MODE(stream); + SET_BINARY_MODE(zStream); + + if (ferror(stream)) goto errhandler_io; + if (ferror(zStream)) goto errhandler_io; + + while (True) { + + bzf = BZ2_bzReadOpen ( + &bzerr, zStream, verbosity, + (int)smallMode, unused, nUnused + ); + if (bzf == NULL || bzerr != BZ_OK) goto errhandler; + streamNo++; + + while (bzerr == BZ_OK) { + nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 ); + if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler; + if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0) + fwrite ( obuf, sizeof(UChar), nread, stream ); + if (ferror(stream)) goto errhandler_io; + } + if (bzerr != BZ_STREAM_END) goto errhandler; + + BZ2_bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused ); + if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" ); + + for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i]; + + BZ2_bzReadClose ( &bzerr, bzf ); + if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" ); + + if (nUnused == 0 && myfeof(zStream)) break; + + } + + if (ferror(zStream)) goto errhandler_io; + ret = fclose ( zStream ); + if (ret == EOF) goto errhandler_io; + + if (ferror(stream)) goto errhandler_io; + ret = fflush ( stream ); + if (ret != 0) goto errhandler_io; + if (stream != stdout) { + ret = fclose ( stream ); + if (ret == EOF) goto errhandler_io; + } + if (verbosity >= 2) fprintf ( stderr, "\n " ); + return True; + + errhandler: + BZ2_bzReadClose ( &bzerr_dummy, bzf ); + switch (bzerr) { + case BZ_CONFIG_ERROR: + configError(); break; + case BZ_IO_ERROR: + errhandler_io: + ioError(); break; + case BZ_DATA_ERROR: + crcError(); + case BZ_MEM_ERROR: + outOfMemory(); + case BZ_UNEXPECTED_EOF: + compressedStreamEOF(); + case BZ_DATA_ERROR_MAGIC: + if (zStream != stdin) fclose(zStream); + if (stream != stdout) fclose(stream); + if (streamNo == 1) { + return False; + } else { + if (noisy) + fprintf ( stderr, + "\n%s: %s: trailing garbage after EOF ignored\n", + progName, inName ); + return True; + } + default: + panic ( "decompress:unexpected error" ); + } + + panic ( "decompress:end" ); + return True; /*notreached*/ +} + + +/*---------------------------------------------*/ +static +Bool testStream ( FILE *zStream ) +{ + BZFILE* bzf = NULL; + Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i; + UChar obuf[5000]; + UChar unused[BZ_MAX_UNUSED]; + Int32 nUnused; + UChar* unusedTmp; + + nUnused = 0; + streamNo = 0; + + SET_BINARY_MODE(zStream); + if (ferror(zStream)) goto errhandler_io; + + while (True) { + + bzf = BZ2_bzReadOpen ( + &bzerr, zStream, verbosity, + (int)smallMode, unused, nUnused + ); + if (bzf == NULL || bzerr != BZ_OK) goto errhandler; + streamNo++; + + while (bzerr == BZ_OK) { + nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 ); + if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler; + } + if (bzerr != BZ_STREAM_END) goto errhandler; + + BZ2_bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused ); + if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" ); + + for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i]; + + BZ2_bzReadClose ( &bzerr, bzf ); + if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" ); + if (nUnused == 0 && myfeof(zStream)) break; + + } + + if (ferror(zStream)) goto errhandler_io; + ret = fclose ( zStream ); + if (ret == EOF) goto errhandler_io; + + if (verbosity >= 2) fprintf ( stderr, "\n " ); + return True; + + errhandler: + BZ2_bzReadClose ( &bzerr_dummy, bzf ); + if (verbosity == 0) + fprintf ( stderr, "%s: %s: ", progName, inName ); + switch (bzerr) { + case BZ_CONFIG_ERROR: + configError(); break; + case BZ_IO_ERROR: + errhandler_io: + ioError(); break; + case BZ_DATA_ERROR: + fprintf ( stderr, + "data integrity (CRC) error in data\n" ); + return False; + case BZ_MEM_ERROR: + outOfMemory(); + case BZ_UNEXPECTED_EOF: + fprintf ( stderr, + "file ends unexpectedly\n" ); + return False; + case BZ_DATA_ERROR_MAGIC: + if (zStream != stdin) fclose(zStream); + if (streamNo == 1) { + fprintf ( stderr, + "bad magic number (file not created by bzip2)\n" ); + return False; + } else { + if (noisy) + fprintf ( stderr, + "trailing garbage after EOF ignored\n" ); + return True; + } + default: + panic ( "test:unexpected error" ); + } + + panic ( "test:end" ); + return True; /*notreached*/ +} + + +/*---------------------------------------------------*/ +/*--- Error [non-] handling grunge ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------*/ +static +void setExit ( Int32 v ) +{ + if (v > exitValue) exitValue = v; +} + + +/*---------------------------------------------*/ +static +void cadvise ( void ) +{ + if (noisy) + fprintf ( + stderr, + "\nIt is possible that the compressed file(s) have become corrupted.\n" + "You can use the -tvv option to test integrity of such files.\n\n" + "You can use the `bzip2recover' program to *attempt* to recover\n" + "data from undamaged sections of corrupted files.\n\n" + ); +} + + +/*---------------------------------------------*/ +static +void showFileNames ( void ) +{ + if (noisy) + fprintf ( + stderr, + "\tInput file = %s, output file = %s\n", + inName, outName + ); +} + + +/*---------------------------------------------*/ +static +void cleanUpAndFail ( Int32 ec ) +{ + IntNative retVal; + + if ( srcMode == SM_F2F + && opMode != OM_TEST + && deleteOutputOnInterrupt ) { + if (noisy) + fprintf ( stderr, "%s: Deleting output file %s, if it exists.\n", + progName, outName ); + if (outputHandleJustInCase != NULL) + fclose ( outputHandleJustInCase ); + retVal = remove ( outName ); + if (retVal != 0) + fprintf ( stderr, + "%s: WARNING: deletion of output file (apparently) failed.\n", + progName ); + } + if (noisy && numFileNames > 0 && numFilesProcessed < numFileNames) { + fprintf ( stderr, + "%s: WARNING: some files have not been processed:\n" + "\t%d specified on command line, %d not processed yet.\n\n", + progName, numFileNames, + numFileNames - numFilesProcessed ); + } + setExit(ec); + exit(exitValue); +} + + +/*---------------------------------------------*/ +static +void panic ( Char* s ) +{ + fprintf ( stderr, + "\n%s: PANIC -- internal consistency error:\n" + "\t%s\n" + "\tThis is a BUG. Please report it to me at:\n" + "\tjseward@acm.org\n", + progName, s ); + showFileNames(); + cleanUpAndFail( 3 ); +} + + +/*---------------------------------------------*/ +static +void crcError ( void ) +{ + fprintf ( stderr, + "\n%s: Data integrity error when decompressing.\n", + progName ); + showFileNames(); + cadvise(); + cleanUpAndFail( 2 ); +} + + +/*---------------------------------------------*/ +static +void compressedStreamEOF ( void ) +{ + fprintf ( stderr, + "\n%s: Compressed file ends unexpectedly;\n\t" + "perhaps it is corrupted? *Possible* reason follows.\n", + progName ); + perror ( progName ); + showFileNames(); + cadvise(); + cleanUpAndFail( 2 ); +} + + +/*---------------------------------------------*/ +static +void ioError ( void ) +{ + fprintf ( stderr, + "\n%s: I/O or other error, bailing out. " + "Possible reason follows.\n", + progName ); + perror ( progName ); + showFileNames(); + cleanUpAndFail( 1 ); +} + + +/*---------------------------------------------*/ +static +void mySignalCatcher ( IntNative n ) +{ + fprintf ( stderr, + "\n%s: Control-C or similar caught, quitting.\n", + progName ); + cleanUpAndFail(1); +} + + +/*---------------------------------------------*/ +static +void mySIGSEGVorSIGBUScatcher ( IntNative n ) +{ + if (opMode == OM_Z) + fprintf ( + stderr, + "\n%s: Caught a SIGSEGV or SIGBUS whilst compressing.\n" + "\n" + " Possible causes are (most likely first):\n" + " (1) This computer has unreliable memory or cache hardware\n" + " (a surprisingly common problem; try a different machine.)\n" + " (2) A bug in the compiler used to create this executable\n" + " (unlikely, if you didn't compile bzip2 yourself.)\n" + " (3) A real bug in bzip2 -- I hope this should never be the case.\n" + " The user's manual, Section 4.3, has more info on (1) and (2).\n" + " \n" + " If you suspect this is a bug in bzip2, or are unsure about (1)\n" + " or (2), feel free to report it to me at: jseward@acm.org.\n" + " Section 4.3 of the user's manual describes the info a useful\n" + " bug report should have. If the manual is available on your\n" + " system, please try and read it before mailing me. If you don't\n" + " have the manual or can't be bothered to read it, mail me anyway.\n" + "\n", + progName ); + else + fprintf ( + stderr, + "\n%s: Caught a SIGSEGV or SIGBUS whilst decompressing.\n" + "\n" + " Possible causes are (most likely first):\n" + " (1) The compressed data is corrupted, and bzip2's usual checks\n" + " failed to detect this. Try bzip2 -tvv my_file.bz2.\n" + " (2) This computer has unreliable memory or cache hardware\n" + " (a surprisingly common problem; try a different machine.)\n" + " (3) A bug in the compiler used to create this executable\n" + " (unlikely, if you didn't compile bzip2 yourself.)\n" + " (4) A real bug in bzip2 -- I hope this should never be the case.\n" + " The user's manual, Section 4.3, has more info on (2) and (3).\n" + " \n" + " If you suspect this is a bug in bzip2, or are unsure about (2)\n" + " or (3), feel free to report it to me at: jseward@acm.org.\n" + " Section 4.3 of the user's manual describes the info a useful\n" + " bug report should have. If the manual is available on your\n" + " system, please try and read it before mailing me. If you don't\n" + " have the manual or can't be bothered to read it, mail me anyway.\n" + "\n", + progName ); + + showFileNames(); + if (opMode == OM_Z) + cleanUpAndFail( 3 ); else + { cadvise(); cleanUpAndFail( 2 ); } +} + + +/*---------------------------------------------*/ +static +void outOfMemory ( void ) +{ + fprintf ( stderr, + "\n%s: couldn't allocate enough memory\n", + progName ); + showFileNames(); + cleanUpAndFail(1); +} + + +/*---------------------------------------------*/ +static +void configError ( void ) +{ + fprintf ( stderr, + "bzip2: I'm not configured correctly for this platform!\n" + "\tI require Int32, Int16 and Char to have sizes\n" + "\tof 4, 2 and 1 bytes to run properly, and they don't.\n" + "\tProbably you can fix this by defining them correctly,\n" + "\tand recompiling. Bye!\n" ); + setExit(3); + exit(exitValue); +} + + +/*---------------------------------------------------*/ +/*--- The main driver machinery ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------*/ +static +void pad ( Char *s ) +{ + Int32 i; + if ( (Int32)strlen(s) >= longestFileName ) return; + for (i = 1; i <= longestFileName - (Int32)strlen(s); i++) + fprintf ( stderr, " " ); +} + + +/*---------------------------------------------*/ +static +void copyFileName ( Char* to, Char* from ) +{ + if ( strlen(from) > FILE_NAME_LEN-10 ) { + fprintf ( + stderr, + "bzip2: file name\n`%s'\n" + "is suspiciously (more than %d chars) long.\n" + "Try using a reasonable file name instead. Sorry! :-)\n", + from, FILE_NAME_LEN-10 + ); + setExit(1); + exit(exitValue); + } + + strncpy(to,from,FILE_NAME_LEN-10); + to[FILE_NAME_LEN-10]='\0'; +} + + +/*---------------------------------------------*/ +static +Bool fileExists ( Char* name ) +{ + FILE *tmp = fopen ( name, "rb" ); + Bool exists = (tmp != NULL); + if (tmp != NULL) fclose ( tmp ); + return exists; +} + + +/*---------------------------------------------*/ +/*-- + if in doubt, return True +--*/ +static +Bool notAStandardFile ( Char* name ) +{ + IntNative i; + struct MY_STAT statBuf; + + i = MY_LSTAT ( name, &statBuf ); + if (i != 0) return True; + if (MY_S_IFREG(statBuf.st_mode)) return False; + return True; +} + + +/*---------------------------------------------*/ +/*-- + rac 11/21/98 see if file has hard links to it +--*/ +static +Int32 countHardLinks ( Char* name ) +{ + IntNative i; + struct MY_STAT statBuf; + + i = MY_LSTAT ( name, &statBuf ); + if (i != 0) return 0; + return (statBuf.st_nlink - 1); +} + + +/*---------------------------------------------*/ +static +void copyDatePermissionsAndOwner ( Char *srcName, Char *dstName ) +{ +#if BZ_UNIX + IntNative retVal; + struct MY_STAT statBuf; + struct utimbuf uTimBuf; + + retVal = MY_LSTAT ( srcName, &statBuf ); + ERROR_IF_NOT_ZERO ( retVal ); + uTimBuf.actime = statBuf.st_atime; + uTimBuf.modtime = statBuf.st_mtime; + + retVal = chmod ( dstName, statBuf.st_mode ); + ERROR_IF_NOT_ZERO ( retVal ); + + retVal = utime ( dstName, &uTimBuf ); + ERROR_IF_NOT_ZERO ( retVal ); + + retVal = chown ( dstName, statBuf.st_uid, statBuf.st_gid ); + /* chown() will in many cases return with EPERM, which can + be safely ignored. + */ +#endif +} + + +/*---------------------------------------------*/ +static +void setInterimPermissions ( Char *dstName ) +{ +#if BZ_UNIX + IntNative retVal; + retVal = chmod ( dstName, S_IRUSR | S_IWUSR ); + ERROR_IF_NOT_ZERO ( retVal ); +#endif +} + + +/*---------------------------------------------*/ +static +Bool containsDubiousChars ( Char* name ) +{ + Bool cdc = False; + for (; *name != '\0'; name++) + if (*name == '?' || *name == '*') cdc = True; + return cdc; +} + + +/*---------------------------------------------*/ +#define BZ_N_SUFFIX_PAIRS 4 + +Char* zSuffix[BZ_N_SUFFIX_PAIRS] + = { ".bz2", ".bz", ".tbz2", ".tbz" }; +Char* unzSuffix[BZ_N_SUFFIX_PAIRS] + = { "", "", ".tar", ".tar" }; + +static +Bool hasSuffix ( Char* s, Char* suffix ) +{ + Int32 ns = strlen(s); + Int32 nx = strlen(suffix); + if (ns < nx) return False; + if (strcmp(s + ns - nx, suffix) == 0) return True; + return False; +} + +static +Bool mapSuffix ( Char* name, + Char* oldSuffix, Char* newSuffix ) +{ + if (!hasSuffix(name,oldSuffix)) return False; + name[strlen(name)-strlen(oldSuffix)] = 0; + strcat ( name, newSuffix ); + return True; +} + + +/*---------------------------------------------*/ +static +void compress ( Char *name ) +{ + FILE *inStr; + FILE *outStr; + Int32 n, i; + + deleteOutputOnInterrupt = False; + + if (name == NULL && srcMode != SM_I2O) + panic ( "compress: bad modes\n" ); + + switch (srcMode) { + case SM_I2O: + copyFileName ( inName, "(stdin)" ); + copyFileName ( outName, "(stdout)" ); + break; + case SM_F2F: + copyFileName ( inName, name ); + copyFileName ( outName, name ); + strcat ( outName, ".bz2" ); + break; + case SM_F2O: + copyFileName ( inName, name ); + copyFileName ( outName, "(stdout)" ); + break; + } + + if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) { + if (noisy) + fprintf ( stderr, "%s: There are no files matching `%s'.\n", + progName, inName ); + setExit(1); + return; + } + if ( srcMode != SM_I2O && !fileExists ( inName ) ) { + fprintf ( stderr, "%s: Can't open input file %s: %s.\n", + progName, inName, strerror(errno) ); + setExit(1); + return; + } + for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++) { + if (hasSuffix(inName, zSuffix[i])) { + if (noisy) + fprintf ( stderr, + "%s: Input file %s already has %s suffix.\n", + progName, inName, zSuffix[i] ); + setExit(1); + return; + } + } + if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) { + if (noisy) + fprintf ( stderr, "%s: Input file %s is not a normal file.\n", + progName, inName ); + setExit(1); + return; + } + if ( srcMode == SM_F2F && !forceOverwrite && fileExists ( outName ) ) { + fprintf ( stderr, "%s: Output file %s already exists.\n", + progName, outName ); + setExit(1); + return; + } + if ( srcMode == SM_F2F && !forceOverwrite && + (n=countHardLinks ( inName )) > 0) { + fprintf ( stderr, "%s: Input file %s has %d other link%s.\n", + progName, inName, n, n > 1 ? "s" : "" ); + setExit(1); + return; + } + + switch ( srcMode ) { + + case SM_I2O: + inStr = stdin; + outStr = stdout; + if ( isatty ( fileno ( stdout ) ) ) { + fprintf ( stderr, + "%s: I won't write compressed data to a terminal.\n", + progName ); + fprintf ( stderr, "%s: For help, type: `%s --help'.\n", + progName, progName ); + setExit(1); + return; + }; + break; + + case SM_F2O: + inStr = fopen ( inName, "rb" ); + outStr = stdout; + if ( isatty ( fileno ( stdout ) ) ) { + fprintf ( stderr, + "%s: I won't write compressed data to a terminal.\n", + progName ); + fprintf ( stderr, "%s: For help, type: `%s --help'.\n", + progName, progName ); + if ( inStr != NULL ) fclose ( inStr ); + setExit(1); + return; + }; + if ( inStr == NULL ) { + fprintf ( stderr, "%s: Can't open input file %s: %s.\n", + progName, inName, strerror(errno) ); + setExit(1); + return; + }; + break; + + case SM_F2F: + inStr = fopen ( inName, "rb" ); + outStr = fopen ( outName, "wb" ); + if ( outStr == NULL) { + fprintf ( stderr, "%s: Can't create output file %s: %s.\n", + progName, outName, strerror(errno) ); + if ( inStr != NULL ) fclose ( inStr ); + setExit(1); + return; + } + if ( inStr == NULL ) { + fprintf ( stderr, "%s: Can't open input file %s: %s.\n", + progName, inName, strerror(errno) ); + if ( outStr != NULL ) fclose ( outStr ); + setExit(1); + return; + }; + setInterimPermissions ( outName ); + break; + + default: + panic ( "compress: bad srcMode" ); + break; + } + + if (verbosity >= 1) { + fprintf ( stderr, " %s: ", inName ); + pad ( inName ); + fflush ( stderr ); + } + + /*--- Now the input and output handles are sane. Do the Biz. ---*/ + outputHandleJustInCase = outStr; + deleteOutputOnInterrupt = True; + compressStream ( inStr, outStr ); + outputHandleJustInCase = NULL; + + /*--- If there was an I/O error, we won't get here. ---*/ + if ( srcMode == SM_F2F ) { + copyDatePermissionsAndOwner ( inName, outName ); + deleteOutputOnInterrupt = False; + if ( !keepInputFiles ) { + IntNative retVal = remove ( inName ); + ERROR_IF_NOT_ZERO ( retVal ); + } + } + + deleteOutputOnInterrupt = False; +} + + +/*---------------------------------------------*/ +static +void uncompress ( Char *name ) +{ + FILE *inStr; + FILE *outStr; + Int32 n, i; + Bool magicNumberOK; + Bool cantGuess; + + deleteOutputOnInterrupt = False; + + if (name == NULL && srcMode != SM_I2O) + panic ( "uncompress: bad modes\n" ); + + cantGuess = False; + switch (srcMode) { + case SM_I2O: + copyFileName ( inName, "(stdin)" ); + copyFileName ( outName, "(stdout)" ); + break; + case SM_F2F: + copyFileName ( inName, name ); + copyFileName ( outName, name ); + for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++) + if (mapSuffix(outName,zSuffix[i],unzSuffix[i])) + goto zzz; + cantGuess = True; + strcat ( outName, ".out" ); + break; + case SM_F2O: + copyFileName ( inName, name ); + copyFileName ( outName, "(stdout)" ); + break; + } + + zzz: + if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) { + if (noisy) + fprintf ( stderr, "%s: There are no files matching `%s'.\n", + progName, inName ); + setExit(1); + return; + } + if ( srcMode != SM_I2O && !fileExists ( inName ) ) { + fprintf ( stderr, "%s: Can't open input file %s: %s.\n", + progName, inName, strerror(errno) ); + setExit(1); + return; + } + if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) { + if (noisy) + fprintf ( stderr, "%s: Input file %s is not a normal file.\n", + progName, inName ); + setExit(1); + return; + } + if ( /* srcMode == SM_F2F implied && */ cantGuess ) { + if (noisy) + fprintf ( stderr, + "%s: Can't guess original name for %s -- using %s\n", + progName, inName, outName ); + /* just a warning, no return */ + } + if ( srcMode == SM_F2F && !forceOverwrite && fileExists ( outName ) ) { + fprintf ( stderr, "%s: Output file %s already exists.\n", + progName, outName ); + setExit(1); + return; + } + if ( srcMode == SM_F2F && !forceOverwrite && + (n=countHardLinks ( inName ) ) > 0) { + fprintf ( stderr, "%s: Input file %s has %d other link%s.\n", + progName, inName, n, n > 1 ? "s" : "" ); + setExit(1); + return; + } + + switch ( srcMode ) { + + case SM_I2O: + inStr = stdin; + outStr = stdout; + if ( isatty ( fileno ( stdin ) ) ) { + fprintf ( stderr, + "%s: I won't read compressed data from a terminal.\n", + progName ); + fprintf ( stderr, "%s: For help, type: `%s --help'.\n", + progName, progName ); + setExit(1); + return; + }; + break; + + case SM_F2O: + inStr = fopen ( inName, "rb" ); + outStr = stdout; + if ( inStr == NULL ) { + fprintf ( stderr, "%s: Can't open input file %s:%s.\n", + progName, inName, strerror(errno) ); + if ( inStr != NULL ) fclose ( inStr ); + setExit(1); + return; + }; + break; + + case SM_F2F: + inStr = fopen ( inName, "rb" ); + outStr = fopen ( outName, "wb" ); + if ( outStr == NULL) { + fprintf ( stderr, "%s: Can't create output file %s: %s.\n", + progName, outName, strerror(errno) ); + if ( inStr != NULL ) fclose ( inStr ); + setExit(1); + return; + } + if ( inStr == NULL ) { + fprintf ( stderr, "%s: Can't open input file %s: %s.\n", + progName, inName, strerror(errno) ); + if ( outStr != NULL ) fclose ( outStr ); + setExit(1); + return; + }; + setInterimPermissions ( outName ); + break; + + default: + panic ( "uncompress: bad srcMode" ); + break; + } + + if (verbosity >= 1) { + fprintf ( stderr, " %s: ", inName ); + pad ( inName ); + fflush ( stderr ); + } + + /*--- Now the input and output handles are sane. Do the Biz. ---*/ + outputHandleJustInCase = outStr; + deleteOutputOnInterrupt = True; + magicNumberOK = uncompressStream ( inStr, outStr ); + outputHandleJustInCase = NULL; + + /*--- If there was an I/O error, we won't get here. ---*/ + if ( magicNumberOK ) { + if ( srcMode == SM_F2F ) { + copyDatePermissionsAndOwner ( inName, outName ); + deleteOutputOnInterrupt = False; + if ( !keepInputFiles ) { + IntNative retVal = remove ( inName ); + ERROR_IF_NOT_ZERO ( retVal ); + } + } + } else { + unzFailsExist = True; + deleteOutputOnInterrupt = False; + if ( srcMode == SM_F2F ) { + IntNative retVal = remove ( outName ); + ERROR_IF_NOT_ZERO ( retVal ); + } + } + deleteOutputOnInterrupt = False; + + if ( magicNumberOK ) { + if (verbosity >= 1) + fprintf ( stderr, "done\n" ); + } else { + setExit(2); + if (verbosity >= 1) + fprintf ( stderr, "not a bzip2 file.\n" ); else + fprintf ( stderr, + "%s: %s is not a bzip2 file.\n", + progName, inName ); + } + +} + + +/*---------------------------------------------*/ +static +void testf ( Char *name ) +{ + FILE *inStr; + Bool allOK; + + deleteOutputOnInterrupt = False; + + if (name == NULL && srcMode != SM_I2O) + panic ( "testf: bad modes\n" ); + + copyFileName ( outName, "(none)" ); + switch (srcMode) { + case SM_I2O: copyFileName ( inName, "(stdin)" ); break; + case SM_F2F: copyFileName ( inName, name ); break; + case SM_F2O: copyFileName ( inName, name ); break; + } + + if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) { + if (noisy) + fprintf ( stderr, "%s: There are no files matching `%s'.\n", + progName, inName ); + setExit(1); + return; + } + if ( srcMode != SM_I2O && !fileExists ( inName ) ) { + fprintf ( stderr, "%s: Can't open input %s: %s.\n", + progName, inName, strerror(errno) ); + setExit(1); + return; + } + + switch ( srcMode ) { + + case SM_I2O: + if ( isatty ( fileno ( stdin ) ) ) { + fprintf ( stderr, + "%s: I won't read compressed data from a terminal.\n", + progName ); + fprintf ( stderr, "%s: For help, type: `%s --help'.\n", + progName, progName ); + setExit(1); + return; + }; + inStr = stdin; + break; + + case SM_F2O: case SM_F2F: + inStr = fopen ( inName, "rb" ); + if ( inStr == NULL ) { + fprintf ( stderr, "%s: Can't open input file %s:%s.\n", + progName, inName, strerror(errno) ); + setExit(1); + return; + }; + break; + + default: + panic ( "testf: bad srcMode" ); + break; + } + + if (verbosity >= 1) { + fprintf ( stderr, " %s: ", inName ); + pad ( inName ); + fflush ( stderr ); + } + + /*--- Now the input handle is sane. Do the Biz. ---*/ + allOK = testStream ( inStr ); + + if (allOK && verbosity >= 1) fprintf ( stderr, "ok\n" ); + if (!allOK) testFailsExist = True; +} + + +/*---------------------------------------------*/ +static +void license ( void ) +{ + fprintf ( stderr, + + "bzip2, a block-sorting file compressor. " + "Version %s.\n" + " \n" + " Copyright (C) 1996-2000 by Julian Seward.\n" + " \n" + " This program is free software; you can redistribute it and/or modify\n" + " it under the terms set out in the LICENSE file, which is included\n" + " in the bzip2-1.0 source distribution.\n" + " \n" + " This program is distributed in the hope that it will be useful,\n" + " but WITHOUT ANY WARRANTY; without even the implied warranty of\n" + " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + " LICENSE file for more details.\n" + " \n", + BZ2_bzlibVersion() + ); +} + + +/*---------------------------------------------*/ +static +void usage ( Char *fullProgName ) +{ + fprintf ( + stderr, + "bzip2, a block-sorting file compressor. " + "Version %s.\n" + "\n usage: %s [flags and input files in any order]\n" + "\n" + " -h --help print this message\n" + " -d --decompress force decompression\n" + " -z --compress force compression\n" + " -k --keep keep (don't delete) input files\n" + " -f --force overwrite existing output files\n" + " -t --test test compressed file integrity\n" + " -c --stdout output to standard out\n" + " -q --quiet suppress noncritical error messages\n" + " -v --verbose be verbose (a 2nd -v gives more)\n" + " -L --license display software version & license\n" + " -V --version display software version & license\n" + " -s --small use less memory (at most 2500k)\n" + " -1 .. -9 set block size to 100k .. 900k\n" + "\n" + " If invoked as `bzip2', default action is to compress.\n" + " as `bunzip2', default action is to decompress.\n" + " as `bzcat', default action is to decompress to stdout.\n" + "\n" + " If no file names are given, bzip2 compresses or decompresses\n" + " from standard input to standard output. You can combine\n" + " short flags, so `-v -4' means the same as -v4 or -4v, &c.\n" +#if BZ_UNIX + "\n" +#endif + , + + BZ2_bzlibVersion(), + fullProgName + ); +} + + +/*---------------------------------------------*/ +static +void redundant ( Char* flag ) +{ + fprintf ( + stderr, + "%s: %s is redundant in versions 0.9.5 and above\n", + progName, flag ); +} + + +/*---------------------------------------------*/ +/*-- + All the garbage from here to main() is purely to + implement a linked list of command-line arguments, + into which main() copies argv[1 .. argc-1]. + + The purpose of this exercise is to facilitate + the expansion of wildcard characters * and ? in + filenames for OSs which don't know how to do it + themselves, like MSDOS, Windows 95 and NT. + + The actual Dirty Work is done by the platform- + specific macro APPEND_FILESPEC. +--*/ + +typedef + struct zzzz { + Char *name; + struct zzzz *link; + } + Cell; + + +/*---------------------------------------------*/ +static +void *myMalloc ( Int32 n ) +{ + void* p; + + p = malloc ( (size_t)n ); + if (p == NULL) outOfMemory (); + return p; +} + + +/*---------------------------------------------*/ +static +Cell *mkCell ( void ) +{ + Cell *c; + + c = (Cell*) myMalloc ( sizeof ( Cell ) ); + c->name = NULL; + c->link = NULL; + return c; +} + + +/*---------------------------------------------*/ +static +Cell *snocString ( Cell *root, Char *name ) +{ + if (root == NULL) { + Cell *tmp = mkCell(); + tmp->name = (Char*) myMalloc ( 5 + strlen(name) ); + strcpy ( tmp->name, name ); + return tmp; + } else { + Cell *tmp = root; + while (tmp->link != NULL) tmp = tmp->link; + tmp->link = snocString ( tmp->link, name ); + return root; + } +} + + +/*---------------------------------------------*/ +static +void addFlagsFromEnvVar ( Cell** argList, Char* varName ) +{ + Int32 i, j, k; + Char *envbase, *p; + + envbase = getenv(varName); + if (envbase != NULL) { + p = envbase; + i = 0; + while (True) { + if (p[i] == 0) break; + p += i; + i = 0; + while (isspace((Int32)(p[0]))) p++; + while (p[i] != 0 && !isspace((Int32)(p[i]))) i++; + if (i > 0) { + k = i; if (k > FILE_NAME_LEN-10) k = FILE_NAME_LEN-10; + for (j = 0; j < k; j++) tmpName[j] = p[j]; + tmpName[k] = 0; + APPEND_FLAG(*argList, tmpName); + } + } + } +} + + +/*---------------------------------------------*/ +#define ISFLAG(s) (strcmp(aa->name, (s))==0) + +IntNative main ( IntNative argc, Char *argv[] ) +{ + Int32 i, j; + Char *tmp; + Cell *argList; + Cell *aa; + Bool decode; + + /*-- Be really really really paranoid :-) --*/ + if (sizeof(Int32) != 4 || sizeof(UInt32) != 4 || + sizeof(Int16) != 2 || sizeof(UInt16) != 2 || + sizeof(Char) != 1 || sizeof(UChar) != 1) + configError(); + + /*-- Initialise --*/ + outputHandleJustInCase = NULL; + smallMode = False; + keepInputFiles = False; + forceOverwrite = False; + noisy = True; + verbosity = 0; + blockSize100k = 9; + testFailsExist = False; + unzFailsExist = False; + numFileNames = 0; + numFilesProcessed = 0; + workFactor = 30; + deleteOutputOnInterrupt = False; + exitValue = 0; + i = j = 0; /* avoid bogus warning from egcs-1.1.X */ + + /*-- Set up signal handlers for mem access errors --*/ + signal (SIGSEGV, mySIGSEGVorSIGBUScatcher); +#if BZ_UNIX +#ifndef __DJGPP__ + signal (SIGBUS, mySIGSEGVorSIGBUScatcher); +#endif +#endif + + copyFileName ( inName, "(none)" ); + copyFileName ( outName, "(none)" ); + + copyFileName ( progNameReally, argv[0] ); + progName = &progNameReally[0]; + for (tmp = &progNameReally[0]; *tmp != '\0'; tmp++) + if (*tmp == PATH_SEP) progName = tmp + 1; + + + /*-- Copy flags from env var BZIP2, and + expand filename wildcards in arg list. + --*/ + argList = NULL; + addFlagsFromEnvVar ( &argList, "BZIP2" ); + addFlagsFromEnvVar ( &argList, "BZIP" ); + for (i = 1; i <= argc-1; i++) + APPEND_FILESPEC(argList, argv[i]); + + + /*-- Find the length of the longest filename --*/ + longestFileName = 7; + numFileNames = 0; + decode = True; + for (aa = argList; aa != NULL; aa = aa->link) { + if (ISFLAG("--")) { decode = False; continue; } + if (aa->name[0] == '-' && decode) continue; + numFileNames++; + if (longestFileName < (Int32)strlen(aa->name) ) + longestFileName = (Int32)strlen(aa->name); + } + + + /*-- Determine source modes; flag handling may change this too. --*/ + if (numFileNames == 0) + srcMode = SM_I2O; else srcMode = SM_F2F; + + + /*-- Determine what to do (compress/uncompress/test/cat). --*/ + /*-- Note that subsequent flag handling may change this. --*/ + opMode = OM_Z; + + if ( (strstr ( progName, "unzip" ) != 0) || + (strstr ( progName, "UNZIP" ) != 0) ) + opMode = OM_UNZ; + + if ( (strstr ( progName, "z2cat" ) != 0) || + (strstr ( progName, "Z2CAT" ) != 0) || + (strstr ( progName, "zcat" ) != 0) || + (strstr ( progName, "ZCAT" ) != 0) ) { + opMode = OM_UNZ; + srcMode = (numFileNames == 0) ? SM_I2O : SM_F2O; + } + + + /*-- Look at the flags. --*/ + for (aa = argList; aa != NULL; aa = aa->link) { + if (ISFLAG("--")) break; + if (aa->name[0] == '-' && aa->name[1] != '-') { + for (j = 1; aa->name[j] != '\0'; j++) { + switch (aa->name[j]) { + case 'c': srcMode = SM_F2O; break; + case 'd': opMode = OM_UNZ; break; + case 'z': opMode = OM_Z; break; + case 'f': forceOverwrite = True; break; + case 't': opMode = OM_TEST; break; + case 'k': keepInputFiles = True; break; + case 's': smallMode = True; break; + case 'q': noisy = False; break; + case '1': blockSize100k = 1; break; + case '2': blockSize100k = 2; break; + case '3': blockSize100k = 3; break; + case '4': blockSize100k = 4; break; + case '5': blockSize100k = 5; break; + case '6': blockSize100k = 6; break; + case '7': blockSize100k = 7; break; + case '8': blockSize100k = 8; break; + case '9': blockSize100k = 9; break; + case 'V': + case 'L': license(); break; + case 'v': verbosity++; break; + case 'h': usage ( progName ); + exit ( 0 ); + break; + default: fprintf ( stderr, "%s: Bad flag `%s'\n", + progName, aa->name ); + usage ( progName ); + exit ( 1 ); + break; + } + } + } + } + + /*-- And again ... --*/ + for (aa = argList; aa != NULL; aa = aa->link) { + if (ISFLAG("--")) break; + if (ISFLAG("--stdout")) srcMode = SM_F2O; else + if (ISFLAG("--decompress")) opMode = OM_UNZ; else + if (ISFLAG("--compress")) opMode = OM_Z; else + if (ISFLAG("--force")) forceOverwrite = True; else + if (ISFLAG("--test")) opMode = OM_TEST; else + if (ISFLAG("--keep")) keepInputFiles = True; else + if (ISFLAG("--small")) smallMode = True; else + if (ISFLAG("--quiet")) noisy = False; else + if (ISFLAG("--version")) license(); else + if (ISFLAG("--license")) license(); else + if (ISFLAG("--exponential")) workFactor = 1; else + if (ISFLAG("--repetitive-best")) redundant(aa->name); else + if (ISFLAG("--repetitive-fast")) redundant(aa->name); else + if (ISFLAG("--verbose")) verbosity++; else + if (ISFLAG("--help")) { usage ( progName ); exit ( 0 ); } + else + if (strncmp ( aa->name, "--", 2) == 0) { + fprintf ( stderr, "%s: Bad flag `%s'\n", progName, aa->name ); + usage ( progName ); + exit ( 1 ); + } + } + + if (verbosity > 4) verbosity = 4; + if (opMode == OM_Z && smallMode && blockSize100k > 2) + blockSize100k = 2; + + if (opMode == OM_TEST && srcMode == SM_F2O) { + fprintf ( stderr, "%s: -c and -t cannot be used together.\n", + progName ); + exit ( 1 ); + } + + if (srcMode == SM_F2O && numFileNames == 0) + srcMode = SM_I2O; + + if (opMode != OM_Z) blockSize100k = 0; + + if (srcMode == SM_F2F) { + signal (SIGINT, mySignalCatcher); + signal (SIGTERM, mySignalCatcher); +# if BZ_UNIX + signal (SIGHUP, mySignalCatcher); +# endif + } + + if (opMode == OM_Z) { + if (srcMode == SM_I2O) { + compress ( NULL ); + } else { + decode = True; + for (aa = argList; aa != NULL; aa = aa->link) { + if (ISFLAG("--")) { decode = False; continue; } + if (aa->name[0] == '-' && decode) continue; + numFilesProcessed++; + compress ( aa->name ); + } + } + } + else + + if (opMode == OM_UNZ) { + unzFailsExist = False; + if (srcMode == SM_I2O) { + uncompress ( NULL ); + } else { + decode = True; + for (aa = argList; aa != NULL; aa = aa->link) { + if (ISFLAG("--")) { decode = False; continue; } + if (aa->name[0] == '-' && decode) continue; + numFilesProcessed++; + uncompress ( aa->name ); + } + } + if (unzFailsExist) { + setExit(2); + exit(exitValue); + } + } + + else { + testFailsExist = False; + if (srcMode == SM_I2O) { + testf ( NULL ); + } else { + decode = True; + for (aa = argList; aa != NULL; aa = aa->link) { + if (ISFLAG("--")) { decode = False; continue; } + if (aa->name[0] == '-' && decode) continue; + numFilesProcessed++; + testf ( aa->name ); + } + } + if (testFailsExist && noisy) { + fprintf ( stderr, + "\n" + "You can use the `bzip2recover' program to attempt to recover\n" + "data from undamaged sections of corrupted files.\n\n" + ); + setExit(2); + exit(exitValue); + } + } + + /* Free the argument list memory to mollify leak detectors + (eg) Purify, Checker. Serves no other useful purpose. + */ + aa = argList; + while (aa != NULL) { + Cell* aa2 = aa->link; + if (aa->name != NULL) free(aa->name); + free(aa); + aa = aa2; + } + + return exitValue; +} + + +/*-----------------------------------------------------------*/ +/*--- end bzip2.c ---*/ +/*-----------------------------------------------------------*/ diff --git a/contrib/bzip2/bzip2recover.c b/contrib/bzip2/bzip2recover.c new file mode 100644 index 000000000000..ba3d175632a7 --- /dev/null +++ b/contrib/bzip2/bzip2recover.c @@ -0,0 +1,435 @@ + +/*-----------------------------------------------------------*/ +/*--- Block recoverer program for bzip2 ---*/ +/*--- bzip2recover.c ---*/ +/*-----------------------------------------------------------*/ + +/*-- + This program is bzip2recover, a program to attempt data + salvage from damaged files created by the accompanying + bzip2-1.0 program. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 +--*/ + +/*-- + This program is a complete hack and should be rewritten + properly. It isn't very complicated. +--*/ + +#include +#include +#include +#include + +typedef unsigned int UInt32; +typedef int Int32; +typedef unsigned char UChar; +typedef char Char; +typedef unsigned char Bool; +#define True ((Bool)1) +#define False ((Bool)0) + + +Char inFileName[2000]; +Char outFileName[2000]; +Char progName[2000]; + +UInt32 bytesOut = 0; +UInt32 bytesIn = 0; + + +/*---------------------------------------------------*/ +/*--- I/O errors ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------*/ +void readError ( void ) +{ + fprintf ( stderr, + "%s: I/O error reading `%s', possible reason follows.\n", + progName, inFileName ); + perror ( progName ); + fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n", + progName ); + exit ( 1 ); +} + + +/*---------------------------------------------*/ +void writeError ( void ) +{ + fprintf ( stderr, + "%s: I/O error reading `%s', possible reason follows.\n", + progName, inFileName ); + perror ( progName ); + fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n", + progName ); + exit ( 1 ); +} + + +/*---------------------------------------------*/ +void mallocFail ( Int32 n ) +{ + fprintf ( stderr, + "%s: malloc failed on request for %d bytes.\n", + progName, n ); + fprintf ( stderr, "%s: warning: output file(s) may be incomplete.\n", + progName ); + exit ( 1 ); +} + + +/*---------------------------------------------------*/ +/*--- Bit stream I/O ---*/ +/*---------------------------------------------------*/ + +typedef + struct { + FILE* handle; + Int32 buffer; + Int32 buffLive; + Char mode; + } + BitStream; + + +/*---------------------------------------------*/ +BitStream* bsOpenReadStream ( FILE* stream ) +{ + BitStream *bs = malloc ( sizeof(BitStream) ); + if (bs == NULL) mallocFail ( sizeof(BitStream) ); + bs->handle = stream; + bs->buffer = 0; + bs->buffLive = 0; + bs->mode = 'r'; + return bs; +} + + +/*---------------------------------------------*/ +BitStream* bsOpenWriteStream ( FILE* stream ) +{ + BitStream *bs = malloc ( sizeof(BitStream) ); + if (bs == NULL) mallocFail ( sizeof(BitStream) ); + bs->handle = stream; + bs->buffer = 0; + bs->buffLive = 0; + bs->mode = 'w'; + return bs; +} + + +/*---------------------------------------------*/ +void bsPutBit ( BitStream* bs, Int32 bit ) +{ + if (bs->buffLive == 8) { + Int32 retVal = putc ( (UChar) bs->buffer, bs->handle ); + if (retVal == EOF) writeError(); + bytesOut++; + bs->buffLive = 1; + bs->buffer = bit & 0x1; + } else { + bs->buffer = ( (bs->buffer << 1) | (bit & 0x1) ); + bs->buffLive++; + }; +} + + +/*---------------------------------------------*/ +/*-- + Returns 0 or 1, or 2 to indicate EOF. +--*/ +Int32 bsGetBit ( BitStream* bs ) +{ + if (bs->buffLive > 0) { + bs->buffLive --; + return ( ((bs->buffer) >> (bs->buffLive)) & 0x1 ); + } else { + Int32 retVal = getc ( bs->handle ); + if ( retVal == EOF ) { + if (errno != 0) readError(); + return 2; + } + bs->buffLive = 7; + bs->buffer = retVal; + return ( ((bs->buffer) >> 7) & 0x1 ); + } +} + + +/*---------------------------------------------*/ +void bsClose ( BitStream* bs ) +{ + Int32 retVal; + + if ( bs->mode == 'w' ) { + while ( bs->buffLive < 8 ) { + bs->buffLive++; + bs->buffer <<= 1; + }; + retVal = putc ( (UChar) (bs->buffer), bs->handle ); + if (retVal == EOF) writeError(); + bytesOut++; + retVal = fflush ( bs->handle ); + if (retVal == EOF) writeError(); + } + retVal = fclose ( bs->handle ); + if (retVal == EOF) { + if (bs->mode == 'w') writeError(); else readError(); + } + free ( bs ); +} + + +/*---------------------------------------------*/ +void bsPutUChar ( BitStream* bs, UChar c ) +{ + Int32 i; + for (i = 7; i >= 0; i--) + bsPutBit ( bs, (((UInt32) c) >> i) & 0x1 ); +} + + +/*---------------------------------------------*/ +void bsPutUInt32 ( BitStream* bs, UInt32 c ) +{ + Int32 i; + + for (i = 31; i >= 0; i--) + bsPutBit ( bs, (c >> i) & 0x1 ); +} + + +/*---------------------------------------------*/ +Bool endsInBz2 ( Char* name ) +{ + Int32 n = strlen ( name ); + if (n <= 4) return False; + return + (name[n-4] == '.' && + name[n-3] == 'b' && + name[n-2] == 'z' && + name[n-1] == '2'); +} + + +/*---------------------------------------------------*/ +/*--- ---*/ +/*---------------------------------------------------*/ + +#define BLOCK_HEADER_HI 0x00003141UL +#define BLOCK_HEADER_LO 0x59265359UL + +#define BLOCK_ENDMARK_HI 0x00001772UL +#define BLOCK_ENDMARK_LO 0x45385090UL + + +UInt32 bStart[20000]; +UInt32 bEnd[20000]; +UInt32 rbStart[20000]; +UInt32 rbEnd[20000]; + +Int32 main ( Int32 argc, Char** argv ) +{ + FILE* inFile; + FILE* outFile; + BitStream* bsIn, *bsWr; + Int32 currBlock, b, wrBlock; + UInt32 bitsRead; + Int32 rbCtr; + + + UInt32 buffHi, buffLo, blockCRC; + Char* p; + + strcpy ( progName, argv[0] ); + inFileName[0] = outFileName[0] = 0; + + fprintf ( stderr, "bzip2recover 1.0: extracts blocks from damaged .bz2 files.\n" ); + + if (argc != 2) { + fprintf ( stderr, "%s: usage is `%s damaged_file_name'.\n", + progName, progName ); + exit(1); + } + + strcpy ( inFileName, argv[1] ); + + inFile = fopen ( inFileName, "rb" ); + if (inFile == NULL) { + fprintf ( stderr, "%s: can't read `%s'\n", progName, inFileName ); + exit(1); + } + + bsIn = bsOpenReadStream ( inFile ); + fprintf ( stderr, "%s: searching for block boundaries ...\n", progName ); + + bitsRead = 0; + buffHi = buffLo = 0; + currBlock = 0; + bStart[currBlock] = 0; + + rbCtr = 0; + + while (True) { + b = bsGetBit ( bsIn ); + bitsRead++; + if (b == 2) { + if (bitsRead >= bStart[currBlock] && + (bitsRead - bStart[currBlock]) >= 40) { + bEnd[currBlock] = bitsRead-1; + if (currBlock > 0) + fprintf ( stderr, " block %d runs from %d to %d (incomplete)\n", + currBlock, bStart[currBlock], bEnd[currBlock] ); + } else + currBlock--; + break; + } + buffHi = (buffHi << 1) | (buffLo >> 31); + buffLo = (buffLo << 1) | (b & 1); + if ( ( (buffHi & 0x0000ffff) == BLOCK_HEADER_HI + && buffLo == BLOCK_HEADER_LO) + || + ( (buffHi & 0x0000ffff) == BLOCK_ENDMARK_HI + && buffLo == BLOCK_ENDMARK_LO) + ) { + if (bitsRead > 49) + bEnd[currBlock] = bitsRead-49; else + bEnd[currBlock] = 0; + if (currBlock > 0 && + (bEnd[currBlock] - bStart[currBlock]) >= 130) { + fprintf ( stderr, " block %d runs from %d to %d\n", + rbCtr+1, bStart[currBlock], bEnd[currBlock] ); + rbStart[rbCtr] = bStart[currBlock]; + rbEnd[rbCtr] = bEnd[currBlock]; + rbCtr++; + } + currBlock++; + + bStart[currBlock] = bitsRead; + } + } + + bsClose ( bsIn ); + + /*-- identified blocks run from 1 to rbCtr inclusive. --*/ + + if (rbCtr < 1) { + fprintf ( stderr, + "%s: sorry, I couldn't find any block boundaries.\n", + progName ); + exit(1); + }; + + fprintf ( stderr, "%s: splitting into blocks\n", progName ); + + inFile = fopen ( inFileName, "rb" ); + if (inFile == NULL) { + fprintf ( stderr, "%s: can't open `%s'\n", progName, inFileName ); + exit(1); + } + bsIn = bsOpenReadStream ( inFile ); + + /*-- placate gcc's dataflow analyser --*/ + blockCRC = 0; bsWr = 0; + + bitsRead = 0; + outFile = NULL; + wrBlock = 0; + while (True) { + b = bsGetBit(bsIn); + if (b == 2) break; + buffHi = (buffHi << 1) | (buffLo >> 31); + buffLo = (buffLo << 1) | (b & 1); + if (bitsRead == 47+rbStart[wrBlock]) + blockCRC = (buffHi << 16) | (buffLo >> 16); + + if (outFile != NULL && bitsRead >= rbStart[wrBlock] + && bitsRead <= rbEnd[wrBlock]) { + bsPutBit ( bsWr, b ); + } + + bitsRead++; + + if (bitsRead == rbEnd[wrBlock]+1) { + if (outFile != NULL) { + bsPutUChar ( bsWr, 0x17 ); bsPutUChar ( bsWr, 0x72 ); + bsPutUChar ( bsWr, 0x45 ); bsPutUChar ( bsWr, 0x38 ); + bsPutUChar ( bsWr, 0x50 ); bsPutUChar ( bsWr, 0x90 ); + bsPutUInt32 ( bsWr, blockCRC ); + bsClose ( bsWr ); + } + if (wrBlock >= rbCtr) break; + wrBlock++; + } else + if (bitsRead == rbStart[wrBlock]) { + outFileName[0] = 0; + sprintf ( outFileName, "rec%4d", wrBlock+1 ); + for (p = outFileName; *p != 0; p++) if (*p == ' ') *p = '0'; + strcat ( outFileName, inFileName ); + if ( !endsInBz2(outFileName)) strcat ( outFileName, ".bz2" ); + + fprintf ( stderr, " writing block %d to `%s' ...\n", + wrBlock+1, outFileName ); + + outFile = fopen ( outFileName, "wb" ); + if (outFile == NULL) { + fprintf ( stderr, "%s: can't write `%s'\n", + progName, outFileName ); + exit(1); + } + bsWr = bsOpenWriteStream ( outFile ); + bsPutUChar ( bsWr, 'B' ); bsPutUChar ( bsWr, 'Z' ); + bsPutUChar ( bsWr, 'h' ); bsPutUChar ( bsWr, '9' ); + bsPutUChar ( bsWr, 0x31 ); bsPutUChar ( bsWr, 0x41 ); + bsPutUChar ( bsWr, 0x59 ); bsPutUChar ( bsWr, 0x26 ); + bsPutUChar ( bsWr, 0x53 ); bsPutUChar ( bsWr, 0x59 ); + } + } + + fprintf ( stderr, "%s: finished\n", progName ); + return 0; +} + + + +/*-----------------------------------------------------------*/ +/*--- end bzip2recover.c ---*/ +/*-----------------------------------------------------------*/ diff --git a/contrib/bzip2/bzlib.c b/contrib/bzip2/bzlib.c new file mode 100644 index 000000000000..4a06d9f14b91 --- /dev/null +++ b/contrib/bzip2/bzlib.c @@ -0,0 +1,1564 @@ + +/*-------------------------------------------------------------*/ +/*--- Library top-level functions. ---*/ +/*--- bzlib.c ---*/ +/*-------------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + +/*-- + CHANGES + ~~~~~~~ + 0.9.0 -- original version. + + 0.9.0a/b -- no changes in this file. + + 0.9.0c + * made zero-length BZ_FLUSH work correctly in bzCompress(). + * fixed bzWrite/bzRead to ignore zero-length requests. + * fixed bzread to correctly handle read requests after EOF. + * wrong parameter order in call to bzDecompressInit in + bzBuffToBuffDecompress. Fixed. +--*/ + +#include "bzlib_private.h" + + +/*---------------------------------------------------*/ +/*--- Compression stuff ---*/ +/*---------------------------------------------------*/ + + +/*---------------------------------------------------*/ +#ifndef BZ_NO_STDIO +void BZ2_bz__AssertH__fail ( int errcode ) +{ + fprintf(stderr, + "\n\nbzip2/libbzip2: internal error number %d.\n" + "This is a bug in bzip2/libbzip2, %s.\n" + "Please report it to me at: jseward@acm.org. If this happened\n" + "when you were using some program which uses libbzip2 as a\n" + "component, you should also report this bug to the author(s)\n" + "of that program. Please make an effort to report this bug;\n" + "timely and accurate bug reports eventually lead to higher\n" + "quality software. Thanks. Julian Seward, 21 March 2000.\n\n", + errcode, + BZ2_bzlibVersion() + ); + exit(3); +} +#endif + + +/*---------------------------------------------------*/ +static +int bz_config_ok ( void ) +{ + if (sizeof(int) != 4) return 0; + if (sizeof(short) != 2) return 0; + if (sizeof(char) != 1) return 0; + return 1; +} + + +/*---------------------------------------------------*/ +static +void* default_bzalloc ( void* opaque, Int32 items, Int32 size ) +{ + void* v = malloc ( items * size ); + return v; +} + +static +void default_bzfree ( void* opaque, void* addr ) +{ + if (addr != NULL) free ( addr ); +} + + +/*---------------------------------------------------*/ +static +void prepare_new_block ( EState* s ) +{ + Int32 i; + s->nblock = 0; + s->numZ = 0; + s->state_out_pos = 0; + BZ_INITIALISE_CRC ( s->blockCRC ); + for (i = 0; i < 256; i++) s->inUse[i] = False; + s->blockNo++; +} + + +/*---------------------------------------------------*/ +static +void init_RL ( EState* s ) +{ + s->state_in_ch = 256; + s->state_in_len = 0; +} + + +static +Bool isempty_RL ( EState* s ) +{ + if (s->state_in_ch < 256 && s->state_in_len > 0) + return False; else + return True; +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzCompressInit) + ( bz_stream* strm, + int blockSize100k, + int verbosity, + int workFactor ) +{ + Int32 n; + EState* s; + + if (!bz_config_ok()) return BZ_CONFIG_ERROR; + + if (strm == NULL || + blockSize100k < 1 || blockSize100k > 9 || + workFactor < 0 || workFactor > 250) + return BZ_PARAM_ERROR; + + if (workFactor == 0) workFactor = 30; + if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc; + if (strm->bzfree == NULL) strm->bzfree = default_bzfree; + + s = BZALLOC( sizeof(EState) ); + if (s == NULL) return BZ_MEM_ERROR; + s->strm = strm; + + s->arr1 = NULL; + s->arr2 = NULL; + s->ftab = NULL; + + n = 100000 * blockSize100k; + s->arr1 = BZALLOC( n * sizeof(UInt32) ); + s->arr2 = BZALLOC( (n+BZ_N_OVERSHOOT) * sizeof(UInt32) ); + s->ftab = BZALLOC( 65537 * sizeof(UInt32) ); + + if (s->arr1 == NULL || s->arr2 == NULL || s->ftab == NULL) { + if (s->arr1 != NULL) BZFREE(s->arr1); + if (s->arr2 != NULL) BZFREE(s->arr2); + if (s->ftab != NULL) BZFREE(s->ftab); + if (s != NULL) BZFREE(s); + return BZ_MEM_ERROR; + } + + s->blockNo = 0; + s->state = BZ_S_INPUT; + s->mode = BZ_M_RUNNING; + s->combinedCRC = 0; + s->blockSize100k = blockSize100k; + s->nblockMAX = 100000 * blockSize100k - 19; + s->verbosity = verbosity; + s->workFactor = workFactor; + + s->block = (UChar*)s->arr2; + s->mtfv = (UInt16*)s->arr1; + s->zbits = NULL; + s->ptr = (UInt32*)s->arr1; + + strm->state = s; + strm->total_in_lo32 = 0; + strm->total_in_hi32 = 0; + strm->total_out_lo32 = 0; + strm->total_out_hi32 = 0; + init_RL ( s ); + prepare_new_block ( s ); + return BZ_OK; +} + + +/*---------------------------------------------------*/ +static +void add_pair_to_block ( EState* s ) +{ + Int32 i; + UChar ch = (UChar)(s->state_in_ch); + for (i = 0; i < s->state_in_len; i++) { + BZ_UPDATE_CRC( s->blockCRC, ch ); + } + s->inUse[s->state_in_ch] = True; + switch (s->state_in_len) { + case 1: + s->block[s->nblock] = (UChar)ch; s->nblock++; + break; + case 2: + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + break; + case 3: + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + break; + default: + s->inUse[s->state_in_len-4] = True; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = (UChar)ch; s->nblock++; + s->block[s->nblock] = ((UChar)(s->state_in_len-4)); + s->nblock++; + break; + } +} + + +/*---------------------------------------------------*/ +static +void flush_RL ( EState* s ) +{ + if (s->state_in_ch < 256) add_pair_to_block ( s ); + init_RL ( s ); +} + + +/*---------------------------------------------------*/ +#define ADD_CHAR_TO_BLOCK(zs,zchh0) \ +{ \ + UInt32 zchh = (UInt32)(zchh0); \ + /*-- fast track the common case --*/ \ + if (zchh != zs->state_in_ch && \ + zs->state_in_len == 1) { \ + UChar ch = (UChar)(zs->state_in_ch); \ + BZ_UPDATE_CRC( zs->blockCRC, ch ); \ + zs->inUse[zs->state_in_ch] = True; \ + zs->block[zs->nblock] = (UChar)ch; \ + zs->nblock++; \ + zs->state_in_ch = zchh; \ + } \ + else \ + /*-- general, uncommon cases --*/ \ + if (zchh != zs->state_in_ch || \ + zs->state_in_len == 255) { \ + if (zs->state_in_ch < 256) \ + add_pair_to_block ( zs ); \ + zs->state_in_ch = zchh; \ + zs->state_in_len = 1; \ + } else { \ + zs->state_in_len++; \ + } \ +} + + +/*---------------------------------------------------*/ +static +Bool copy_input_until_stop ( EState* s ) +{ + Bool progress_in = False; + + if (s->mode == BZ_M_RUNNING) { + + /*-- fast track the common case --*/ + while (True) { + /*-- block full? --*/ + if (s->nblock >= s->nblockMAX) break; + /*-- no input? --*/ + if (s->strm->avail_in == 0) break; + progress_in = True; + ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) ); + s->strm->next_in++; + s->strm->avail_in--; + s->strm->total_in_lo32++; + if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; + } + + } else { + + /*-- general, uncommon case --*/ + while (True) { + /*-- block full? --*/ + if (s->nblock >= s->nblockMAX) break; + /*-- no input? --*/ + if (s->strm->avail_in == 0) break; + /*-- flush/finish end? --*/ + if (s->avail_in_expect == 0) break; + progress_in = True; + ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) ); + s->strm->next_in++; + s->strm->avail_in--; + s->strm->total_in_lo32++; + if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; + s->avail_in_expect--; + } + } + return progress_in; +} + + +/*---------------------------------------------------*/ +static +Bool copy_output_until_stop ( EState* s ) +{ + Bool progress_out = False; + + while (True) { + + /*-- no output space? --*/ + if (s->strm->avail_out == 0) break; + + /*-- block done? --*/ + if (s->state_out_pos >= s->numZ) break; + + progress_out = True; + *(s->strm->next_out) = s->zbits[s->state_out_pos]; + s->state_out_pos++; + s->strm->avail_out--; + s->strm->next_out++; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; + } + + return progress_out; +} + + +/*---------------------------------------------------*/ +static +Bool handle_compress ( bz_stream* strm ) +{ + Bool progress_in = False; + Bool progress_out = False; + EState* s = strm->state; + + while (True) { + + if (s->state == BZ_S_OUTPUT) { + progress_out |= copy_output_until_stop ( s ); + if (s->state_out_pos < s->numZ) break; + if (s->mode == BZ_M_FINISHING && + s->avail_in_expect == 0 && + isempty_RL(s)) break; + prepare_new_block ( s ); + s->state = BZ_S_INPUT; + if (s->mode == BZ_M_FLUSHING && + s->avail_in_expect == 0 && + isempty_RL(s)) break; + } + + if (s->state == BZ_S_INPUT) { + progress_in |= copy_input_until_stop ( s ); + if (s->mode != BZ_M_RUNNING && s->avail_in_expect == 0) { + flush_RL ( s ); + BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING) ); + s->state = BZ_S_OUTPUT; + } + else + if (s->nblock >= s->nblockMAX) { + BZ2_compressBlock ( s, False ); + s->state = BZ_S_OUTPUT; + } + else + if (s->strm->avail_in == 0) { + break; + } + } + + } + + return progress_in || progress_out; +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action ) +{ + Bool progress; + EState* s; + if (strm == NULL) return BZ_PARAM_ERROR; + s = strm->state; + if (s == NULL) return BZ_PARAM_ERROR; + if (s->strm != strm) return BZ_PARAM_ERROR; + + preswitch: + switch (s->mode) { + + case BZ_M_IDLE: + return BZ_SEQUENCE_ERROR; + + case BZ_M_RUNNING: + if (action == BZ_RUN) { + progress = handle_compress ( strm ); + return progress ? BZ_RUN_OK : BZ_PARAM_ERROR; + } + else + if (action == BZ_FLUSH) { + s->avail_in_expect = strm->avail_in; + s->mode = BZ_M_FLUSHING; + goto preswitch; + } + else + if (action == BZ_FINISH) { + s->avail_in_expect = strm->avail_in; + s->mode = BZ_M_FINISHING; + goto preswitch; + } + else + return BZ_PARAM_ERROR; + + case BZ_M_FLUSHING: + if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR; + if (s->avail_in_expect != s->strm->avail_in) + return BZ_SEQUENCE_ERROR; + progress = handle_compress ( strm ); + if (s->avail_in_expect > 0 || !isempty_RL(s) || + s->state_out_pos < s->numZ) return BZ_FLUSH_OK; + s->mode = BZ_M_RUNNING; + return BZ_RUN_OK; + + case BZ_M_FINISHING: + if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR; + if (s->avail_in_expect != s->strm->avail_in) + return BZ_SEQUENCE_ERROR; + progress = handle_compress ( strm ); + if (!progress) return BZ_SEQUENCE_ERROR; + if (s->avail_in_expect > 0 || !isempty_RL(s) || + s->state_out_pos < s->numZ) return BZ_FINISH_OK; + s->mode = BZ_M_IDLE; + return BZ_STREAM_END; + } + return BZ_OK; /*--not reached--*/ +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzCompressEnd) ( bz_stream *strm ) +{ + EState* s; + if (strm == NULL) return BZ_PARAM_ERROR; + s = strm->state; + if (s == NULL) return BZ_PARAM_ERROR; + if (s->strm != strm) return BZ_PARAM_ERROR; + + if (s->arr1 != NULL) BZFREE(s->arr1); + if (s->arr2 != NULL) BZFREE(s->arr2); + if (s->ftab != NULL) BZFREE(s->ftab); + BZFREE(strm->state); + + strm->state = NULL; + + return BZ_OK; +} + + +/*---------------------------------------------------*/ +/*--- Decompression stuff ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzDecompressInit) + ( bz_stream* strm, + int verbosity, + int small ) +{ + DState* s; + + if (!bz_config_ok()) return BZ_CONFIG_ERROR; + + if (strm == NULL) return BZ_PARAM_ERROR; + if (small != 0 && small != 1) return BZ_PARAM_ERROR; + if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR; + + if (strm->bzalloc == NULL) strm->bzalloc = default_bzalloc; + if (strm->bzfree == NULL) strm->bzfree = default_bzfree; + + s = BZALLOC( sizeof(DState) ); + if (s == NULL) return BZ_MEM_ERROR; + s->strm = strm; + strm->state = s; + s->state = BZ_X_MAGIC_1; + s->bsLive = 0; + s->bsBuff = 0; + s->calculatedCombinedCRC = 0; + strm->total_in_lo32 = 0; + strm->total_in_hi32 = 0; + strm->total_out_lo32 = 0; + strm->total_out_hi32 = 0; + s->smallDecompress = (Bool)small; + s->ll4 = NULL; + s->ll16 = NULL; + s->tt = NULL; + s->currBlockNo = 0; + s->verbosity = verbosity; + + return BZ_OK; +} + + +/*---------------------------------------------------*/ +static +void unRLE_obuf_to_output_FAST ( DState* s ) +{ + UChar k1; + + if (s->blockRandomised) { + + while (True) { + /* try to finish existing run */ + while (True) { + if (s->strm->avail_out == 0) return; + if (s->state_out_len == 0) break; + *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; + BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) return; + + + s->state_out_len = 1; + s->state_out_ch = s->k0; + BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 2; + BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 3; + BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + s->state_out_len = ((Int32)k1) + 4; + BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK; + s->k0 ^= BZ_RAND_MASK; s->nblock_used++; + } + + } else { + + /* restore */ + UInt32 c_calculatedBlockCRC = s->calculatedBlockCRC; + UChar c_state_out_ch = s->state_out_ch; + Int32 c_state_out_len = s->state_out_len; + Int32 c_nblock_used = s->nblock_used; + Int32 c_k0 = s->k0; + UInt32* c_tt = s->tt; + UInt32 c_tPos = s->tPos; + char* cs_next_out = s->strm->next_out; + unsigned int cs_avail_out = s->strm->avail_out; + /* end restore */ + + UInt32 avail_out_INIT = cs_avail_out; + Int32 s_save_nblockPP = s->save_nblock+1; + unsigned int total_out_lo32_old; + + while (True) { + + /* try to finish existing run */ + if (c_state_out_len > 0) { + while (True) { + if (cs_avail_out == 0) goto return_notr; + if (c_state_out_len == 1) break; + *( (UChar*)(cs_next_out) ) = c_state_out_ch; + BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ); + c_state_out_len--; + cs_next_out++; + cs_avail_out--; + } + s_state_out_len_eq_one: + { + if (cs_avail_out == 0) { + c_state_out_len = 1; goto return_notr; + }; + *( (UChar*)(cs_next_out) ) = c_state_out_ch; + BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ); + cs_next_out++; + cs_avail_out--; + } + } + /* can a new run be started? */ + if (c_nblock_used == s_save_nblockPP) { + c_state_out_len = 0; goto return_notr; + }; + c_state_out_ch = c_k0; + BZ_GET_FAST_C(k1); c_nblock_used++; + if (k1 != c_k0) { + c_k0 = k1; goto s_state_out_len_eq_one; + }; + if (c_nblock_used == s_save_nblockPP) + goto s_state_out_len_eq_one; + + c_state_out_len = 2; + BZ_GET_FAST_C(k1); c_nblock_used++; + if (c_nblock_used == s_save_nblockPP) continue; + if (k1 != c_k0) { c_k0 = k1; continue; }; + + c_state_out_len = 3; + BZ_GET_FAST_C(k1); c_nblock_used++; + if (c_nblock_used == s_save_nblockPP) continue; + if (k1 != c_k0) { c_k0 = k1; continue; }; + + BZ_GET_FAST_C(k1); c_nblock_used++; + c_state_out_len = ((Int32)k1) + 4; + BZ_GET_FAST_C(c_k0); c_nblock_used++; + } + + return_notr: + total_out_lo32_old = s->strm->total_out_lo32; + s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out); + if (s->strm->total_out_lo32 < total_out_lo32_old) + s->strm->total_out_hi32++; + + /* save */ + s->calculatedBlockCRC = c_calculatedBlockCRC; + s->state_out_ch = c_state_out_ch; + s->state_out_len = c_state_out_len; + s->nblock_used = c_nblock_used; + s->k0 = c_k0; + s->tt = c_tt; + s->tPos = c_tPos; + s->strm->next_out = cs_next_out; + s->strm->avail_out = cs_avail_out; + /* end save */ + } +} + + + +/*---------------------------------------------------*/ +__inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab ) +{ + Int32 nb, na, mid; + nb = 0; + na = 256; + do { + mid = (nb + na) >> 1; + if (indx >= cftab[mid]) nb = mid; else na = mid; + } + while (na - nb != 1); + return nb; +} + + +/*---------------------------------------------------*/ +static +void unRLE_obuf_to_output_SMALL ( DState* s ) +{ + UChar k1; + + if (s->blockRandomised) { + + while (True) { + /* try to finish existing run */ + while (True) { + if (s->strm->avail_out == 0) return; + if (s->state_out_len == 0) break; + *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; + BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) return; + + + s->state_out_len = 1; + s->state_out_ch = s->k0; + BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 2; + BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 3; + BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; + k1 ^= BZ_RAND_MASK; s->nblock_used++; + s->state_out_len = ((Int32)k1) + 4; + BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK; + s->k0 ^= BZ_RAND_MASK; s->nblock_used++; + } + + } else { + + while (True) { + /* try to finish existing run */ + while (True) { + if (s->strm->avail_out == 0) return; + if (s->state_out_len == 0) break; + *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; + BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); + s->state_out_len--; + s->strm->next_out++; + s->strm->avail_out--; + s->strm->total_out_lo32++; + if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; + } + + /* can a new run be started? */ + if (s->nblock_used == s->save_nblock+1) return; + + s->state_out_len = 1; + s->state_out_ch = s->k0; + BZ_GET_SMALL(k1); s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 2; + BZ_GET_SMALL(k1); s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + s->state_out_len = 3; + BZ_GET_SMALL(k1); s->nblock_used++; + if (s->nblock_used == s->save_nblock+1) continue; + if (k1 != s->k0) { s->k0 = k1; continue; }; + + BZ_GET_SMALL(k1); s->nblock_used++; + s->state_out_len = ((Int32)k1) + 4; + BZ_GET_SMALL(s->k0); s->nblock_used++; + } + + } +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzDecompress) ( bz_stream *strm ) +{ + DState* s; + if (strm == NULL) return BZ_PARAM_ERROR; + s = strm->state; + if (s == NULL) return BZ_PARAM_ERROR; + if (s->strm != strm) return BZ_PARAM_ERROR; + + while (True) { + if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR; + if (s->state == BZ_X_OUTPUT) { + if (s->smallDecompress) + unRLE_obuf_to_output_SMALL ( s ); else + unRLE_obuf_to_output_FAST ( s ); + if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) { + BZ_FINALISE_CRC ( s->calculatedBlockCRC ); + if (s->verbosity >= 3) + VPrintf2 ( " {0x%x, 0x%x}", s->storedBlockCRC, + s->calculatedBlockCRC ); + if (s->verbosity >= 2) VPrintf0 ( "]" ); + if (s->calculatedBlockCRC != s->storedBlockCRC) + return BZ_DATA_ERROR; + s->calculatedCombinedCRC + = (s->calculatedCombinedCRC << 1) | + (s->calculatedCombinedCRC >> 31); + s->calculatedCombinedCRC ^= s->calculatedBlockCRC; + s->state = BZ_X_BLKHDR_1; + } else { + return BZ_OK; + } + } + if (s->state >= BZ_X_MAGIC_1) { + Int32 r = BZ2_decompress ( s ); + if (r == BZ_STREAM_END) { + if (s->verbosity >= 3) + VPrintf2 ( "\n combined CRCs: stored = 0x%x, computed = 0x%x", + s->storedCombinedCRC, s->calculatedCombinedCRC ); + if (s->calculatedCombinedCRC != s->storedCombinedCRC) + return BZ_DATA_ERROR; + return r; + } + if (s->state != BZ_X_OUTPUT) return r; + } + } + + AssertH ( 0, 6001 ); + + return 0; /*NOTREACHED*/ +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzDecompressEnd) ( bz_stream *strm ) +{ + DState* s; + if (strm == NULL) return BZ_PARAM_ERROR; + s = strm->state; + if (s == NULL) return BZ_PARAM_ERROR; + if (s->strm != strm) return BZ_PARAM_ERROR; + + if (s->tt != NULL) BZFREE(s->tt); + if (s->ll16 != NULL) BZFREE(s->ll16); + if (s->ll4 != NULL) BZFREE(s->ll4); + + BZFREE(strm->state); + strm->state = NULL; + + return BZ_OK; +} + + +#ifndef BZ_NO_STDIO +/*---------------------------------------------------*/ +/*--- File I/O stuff ---*/ +/*---------------------------------------------------*/ + +#define BZ_SETERR(eee) \ +{ \ + if (bzerror != NULL) *bzerror = eee; \ + if (bzf != NULL) bzf->lastErr = eee; \ +} + +typedef + struct { + FILE* handle; + Char buf[BZ_MAX_UNUSED]; + Int32 bufN; + Bool writing; + bz_stream strm; + Int32 lastErr; + Bool initialisedOk; + } + bzFile; + + +/*---------------------------------------------*/ +static Bool myfeof ( FILE* f ) +{ + Int32 c = fgetc ( f ); + if (c == EOF) return True; + ungetc ( c, f ); + return False; +} + + +/*---------------------------------------------------*/ +BZFILE* BZ_API(BZ2_bzWriteOpen) + ( int* bzerror, + FILE* f, + int blockSize100k, + int verbosity, + int workFactor ) +{ + Int32 ret; + bzFile* bzf = NULL; + + BZ_SETERR(BZ_OK); + + if (f == NULL || + (blockSize100k < 1 || blockSize100k > 9) || + (workFactor < 0 || workFactor > 250) || + (verbosity < 0 || verbosity > 4)) + { BZ_SETERR(BZ_PARAM_ERROR); return NULL; }; + + if (ferror(f)) + { BZ_SETERR(BZ_IO_ERROR); return NULL; }; + + bzf = malloc ( sizeof(bzFile) ); + if (bzf == NULL) + { BZ_SETERR(BZ_MEM_ERROR); return NULL; }; + + BZ_SETERR(BZ_OK); + bzf->initialisedOk = False; + bzf->bufN = 0; + bzf->handle = f; + bzf->writing = True; + bzf->strm.bzalloc = NULL; + bzf->strm.bzfree = NULL; + bzf->strm.opaque = NULL; + + if (workFactor == 0) workFactor = 30; + ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k, + verbosity, workFactor ); + if (ret != BZ_OK) + { BZ_SETERR(ret); free(bzf); return NULL; }; + + bzf->strm.avail_in = 0; + bzf->initialisedOk = True; + return bzf; +} + + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzWrite) + ( int* bzerror, + BZFILE* b, + void* buf, + int len ) +{ + Int32 n, n2, ret; + bzFile* bzf = (bzFile*)b; + + BZ_SETERR(BZ_OK); + if (bzf == NULL || buf == NULL || len < 0) + { BZ_SETERR(BZ_PARAM_ERROR); return; }; + if (!(bzf->writing)) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + + if (len == 0) + { BZ_SETERR(BZ_OK); return; }; + + bzf->strm.avail_in = len; + bzf->strm.next_in = buf; + + while (True) { + bzf->strm.avail_out = BZ_MAX_UNUSED; + bzf->strm.next_out = bzf->buf; + ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN ); + if (ret != BZ_RUN_OK) + { BZ_SETERR(ret); return; }; + + if (bzf->strm.avail_out < BZ_MAX_UNUSED) { + n = BZ_MAX_UNUSED - bzf->strm.avail_out; + n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), + n, bzf->handle ); + if (n != n2 || ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + } + + if (bzf->strm.avail_in == 0) + { BZ_SETERR(BZ_OK); return; }; + } +} + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzWriteClose) + ( int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in, + unsigned int* nbytes_out ) +{ + BZ2_bzWriteClose64 ( bzerror, b, abandon, + nbytes_in, NULL, nbytes_out, NULL ); +} + + +void BZ_API(BZ2_bzWriteClose64) + ( int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in_lo32, + unsigned int* nbytes_in_hi32, + unsigned int* nbytes_out_lo32, + unsigned int* nbytes_out_hi32 ) +{ + Int32 n, n2, ret; + bzFile* bzf = (bzFile*)b; + + if (bzf == NULL) + { BZ_SETERR(BZ_OK); return; }; + if (!(bzf->writing)) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + + if (nbytes_in_lo32 != NULL) *nbytes_in_lo32 = 0; + if (nbytes_in_hi32 != NULL) *nbytes_in_hi32 = 0; + if (nbytes_out_lo32 != NULL) *nbytes_out_lo32 = 0; + if (nbytes_out_hi32 != NULL) *nbytes_out_hi32 = 0; + + if ((!abandon) && bzf->lastErr == BZ_OK) { + while (True) { + bzf->strm.avail_out = BZ_MAX_UNUSED; + bzf->strm.next_out = bzf->buf; + ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH ); + if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END) + { BZ_SETERR(ret); return; }; + + if (bzf->strm.avail_out < BZ_MAX_UNUSED) { + n = BZ_MAX_UNUSED - bzf->strm.avail_out; + n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), + n, bzf->handle ); + if (n != n2 || ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + } + + if (ret == BZ_STREAM_END) break; + } + } + + if ( !abandon && !ferror ( bzf->handle ) ) { + fflush ( bzf->handle ); + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return; }; + } + + if (nbytes_in_lo32 != NULL) + *nbytes_in_lo32 = bzf->strm.total_in_lo32; + if (nbytes_in_hi32 != NULL) + *nbytes_in_hi32 = bzf->strm.total_in_hi32; + if (nbytes_out_lo32 != NULL) + *nbytes_out_lo32 = bzf->strm.total_out_lo32; + if (nbytes_out_hi32 != NULL) + *nbytes_out_hi32 = bzf->strm.total_out_hi32; + + BZ_SETERR(BZ_OK); + BZ2_bzCompressEnd ( &(bzf->strm) ); + free ( bzf ); +} + + +/*---------------------------------------------------*/ +BZFILE* BZ_API(BZ2_bzReadOpen) + ( int* bzerror, + FILE* f, + int verbosity, + int small, + void* unused, + int nUnused ) +{ + bzFile* bzf = NULL; + int ret; + + BZ_SETERR(BZ_OK); + + if (f == NULL || + (small != 0 && small != 1) || + (verbosity < 0 || verbosity > 4) || + (unused == NULL && nUnused != 0) || + (unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED))) + { BZ_SETERR(BZ_PARAM_ERROR); return NULL; }; + + if (ferror(f)) + { BZ_SETERR(BZ_IO_ERROR); return NULL; }; + + bzf = malloc ( sizeof(bzFile) ); + if (bzf == NULL) + { BZ_SETERR(BZ_MEM_ERROR); return NULL; }; + + BZ_SETERR(BZ_OK); + + bzf->initialisedOk = False; + bzf->handle = f; + bzf->bufN = 0; + bzf->writing = False; + bzf->strm.bzalloc = NULL; + bzf->strm.bzfree = NULL; + bzf->strm.opaque = NULL; + + while (nUnused > 0) { + bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++; + unused = ((void*)( 1 + ((UChar*)(unused)) )); + nUnused--; + } + + ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small ); + if (ret != BZ_OK) + { BZ_SETERR(ret); free(bzf); return NULL; }; + + bzf->strm.avail_in = bzf->bufN; + bzf->strm.next_in = bzf->buf; + + bzf->initialisedOk = True; + return bzf; +} + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b ) +{ + bzFile* bzf = (bzFile*)b; + + BZ_SETERR(BZ_OK); + if (bzf == NULL) + { BZ_SETERR(BZ_OK); return; }; + + if (bzf->writing) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + + if (bzf->initialisedOk) + (void)BZ2_bzDecompressEnd ( &(bzf->strm) ); + free ( bzf ); +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzRead) + ( int* bzerror, + BZFILE* b, + void* buf, + int len ) +{ + Int32 n, ret; + bzFile* bzf = (bzFile*)b; + + BZ_SETERR(BZ_OK); + + if (bzf == NULL || buf == NULL || len < 0) + { BZ_SETERR(BZ_PARAM_ERROR); return 0; }; + + if (bzf->writing) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; }; + + if (len == 0) + { BZ_SETERR(BZ_OK); return 0; }; + + bzf->strm.avail_out = len; + bzf->strm.next_out = buf; + + while (True) { + + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return 0; }; + + if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) { + n = fread ( bzf->buf, sizeof(UChar), + BZ_MAX_UNUSED, bzf->handle ); + if (ferror(bzf->handle)) + { BZ_SETERR(BZ_IO_ERROR); return 0; }; + bzf->bufN = n; + bzf->strm.avail_in = bzf->bufN; + bzf->strm.next_in = bzf->buf; + } + + ret = BZ2_bzDecompress ( &(bzf->strm) ); + + if (ret != BZ_OK && ret != BZ_STREAM_END) + { BZ_SETERR(ret); return 0; }; + + if (ret == BZ_OK && myfeof(bzf->handle) && + bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0) + { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; }; + + if (ret == BZ_STREAM_END) + { BZ_SETERR(BZ_STREAM_END); + return len - bzf->strm.avail_out; }; + if (bzf->strm.avail_out == 0) + { BZ_SETERR(BZ_OK); return len; }; + + } + + return 0; /*not reached*/ +} + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzReadGetUnused) + ( int* bzerror, + BZFILE* b, + void** unused, + int* nUnused ) +{ + bzFile* bzf = (bzFile*)b; + if (bzf == NULL) + { BZ_SETERR(BZ_PARAM_ERROR); return; }; + if (bzf->lastErr != BZ_STREAM_END) + { BZ_SETERR(BZ_SEQUENCE_ERROR); return; }; + if (unused == NULL || nUnused == NULL) + { BZ_SETERR(BZ_PARAM_ERROR); return; }; + + BZ_SETERR(BZ_OK); + *nUnused = bzf->strm.avail_in; + *unused = bzf->strm.next_in; +} +#endif + + +/*---------------------------------------------------*/ +/*--- Misc convenience stuff ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzBuffToBuffCompress) + ( char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int blockSize100k, + int verbosity, + int workFactor ) +{ + bz_stream strm; + int ret; + + if (dest == NULL || destLen == NULL || + source == NULL || + blockSize100k < 1 || blockSize100k > 9 || + verbosity < 0 || verbosity > 4 || + workFactor < 0 || workFactor > 250) + return BZ_PARAM_ERROR; + + if (workFactor == 0) workFactor = 30; + strm.bzalloc = NULL; + strm.bzfree = NULL; + strm.opaque = NULL; + ret = BZ2_bzCompressInit ( &strm, blockSize100k, + verbosity, workFactor ); + if (ret != BZ_OK) return ret; + + strm.next_in = source; + strm.next_out = dest; + strm.avail_in = sourceLen; + strm.avail_out = *destLen; + + ret = BZ2_bzCompress ( &strm, BZ_FINISH ); + if (ret == BZ_FINISH_OK) goto output_overflow; + if (ret != BZ_STREAM_END) goto errhandler; + + /* normal termination */ + *destLen -= strm.avail_out; + BZ2_bzCompressEnd ( &strm ); + return BZ_OK; + + output_overflow: + BZ2_bzCompressEnd ( &strm ); + return BZ_OUTBUFF_FULL; + + errhandler: + BZ2_bzCompressEnd ( &strm ); + return ret; +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzBuffToBuffDecompress) + ( char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int small, + int verbosity ) +{ + bz_stream strm; + int ret; + + if (dest == NULL || destLen == NULL || + source == NULL || + (small != 0 && small != 1) || + verbosity < 0 || verbosity > 4) + return BZ_PARAM_ERROR; + + strm.bzalloc = NULL; + strm.bzfree = NULL; + strm.opaque = NULL; + ret = BZ2_bzDecompressInit ( &strm, verbosity, small ); + if (ret != BZ_OK) return ret; + + strm.next_in = source; + strm.next_out = dest; + strm.avail_in = sourceLen; + strm.avail_out = *destLen; + + ret = BZ2_bzDecompress ( &strm ); + if (ret == BZ_OK) goto output_overflow_or_eof; + if (ret != BZ_STREAM_END) goto errhandler; + + /* normal termination */ + *destLen -= strm.avail_out; + BZ2_bzDecompressEnd ( &strm ); + return BZ_OK; + + output_overflow_or_eof: + if (strm.avail_out > 0) { + BZ2_bzDecompressEnd ( &strm ); + return BZ_UNEXPECTED_EOF; + } else { + BZ2_bzDecompressEnd ( &strm ); + return BZ_OUTBUFF_FULL; + }; + + errhandler: + BZ2_bzDecompressEnd ( &strm ); + return ret; +} + + +/*---------------------------------------------------*/ +/*-- + Code contributed by Yoshioka Tsuneo + (QWF00133@niftyserve.or.jp/tsuneo-y@is.aist-nara.ac.jp), + to support better zlib compatibility. + This code is not _officially_ part of libbzip2 (yet); + I haven't tested it, documented it, or considered the + threading-safeness of it. + If this code breaks, please contact both Yoshioka and me. +--*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +/*-- + return version like "0.9.0c". +--*/ +const char * BZ_API(BZ2_bzlibVersion)(void) +{ + return BZ_VERSION; +} + + +#ifndef BZ_NO_STDIO +/*---------------------------------------------------*/ + +#if defined(_WIN32) || defined(OS2) || defined(MSDOS) +# include +# include +# define SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY) +#else +# define SET_BINARY_MODE(file) +#endif +static +BZFILE * bzopen_or_bzdopen + ( const char *path, /* no use when bzdopen */ + int fd, /* no use when bzdopen */ + const char *mode, + int open_mode) /* bzopen: 0, bzdopen:1 */ +{ + int bzerr; + char unused[BZ_MAX_UNUSED]; + int blockSize100k = 9; + int writing = 0; + char mode2[10] = ""; + FILE *fp = NULL; + BZFILE *bzfp = NULL; + int verbosity = 0; + int workFactor = 30; + int smallMode = 0; + int nUnused = 0; + + if (mode == NULL) return NULL; + while (*mode) { + switch (*mode) { + case 'r': + writing = 0; break; + case 'w': + writing = 1; break; + case 's': + smallMode = 1; break; + default: + if (isdigit((int)(*mode))) { + blockSize100k = *mode-'0'; + } + } + mode++; + } + strcat(mode2, writing ? "w" : "r" ); + strcat(mode2,"b"); /* binary mode */ + + if (open_mode==0) { + if (path==NULL || strcmp(path,"")==0) { + fp = (writing ? stdout : stdin); + SET_BINARY_MODE(fp); + } else { + fp = fopen(path,mode2); + } + } else { +#ifdef BZ_STRICT_ANSI + fp = NULL; +#else + fp = fdopen(fd,mode2); +#endif + } + if (fp == NULL) return NULL; + + if (writing) { + /* Guard against total chaos and anarchy -- JRS */ + if (blockSize100k < 1) blockSize100k = 1; + if (blockSize100k > 9) blockSize100k = 9; + bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k, + verbosity,workFactor); + } else { + bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode, + unused,nUnused); + } + if (bzfp == NULL) { + if (fp != stdin && fp != stdout) fclose(fp); + return NULL; + } + return bzfp; +} + + +/*---------------------------------------------------*/ +/*-- + open file for read or write. + ex) bzopen("file","w9") + case path="" or NULL => use stdin or stdout. +--*/ +BZFILE * BZ_API(BZ2_bzopen) + ( const char *path, + const char *mode ) +{ + return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0); +} + + +/*---------------------------------------------------*/ +BZFILE * BZ_API(BZ2_bzdopen) + ( int fd, + const char *mode ) +{ + return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1); +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len ) +{ + int bzerr, nread; + if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0; + nread = BZ2_bzRead(&bzerr,b,buf,len); + if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) { + return nread; + } else { + return -1; + } +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len ) +{ + int bzerr; + + BZ2_bzWrite(&bzerr,b,buf,len); + if(bzerr == BZ_OK){ + return len; + }else{ + return -1; + } +} + + +/*---------------------------------------------------*/ +int BZ_API(BZ2_bzflush) (BZFILE *b) +{ + /* do nothing now... */ + return 0; +} + + +/*---------------------------------------------------*/ +void BZ_API(BZ2_bzclose) (BZFILE* b) +{ + int bzerr; + FILE *fp = ((bzFile *)b)->handle; + + if (b==NULL) {return;} + if(((bzFile*)b)->writing){ + BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL); + if(bzerr != BZ_OK){ + BZ2_bzWriteClose(NULL,b,1,NULL,NULL); + } + }else{ + BZ2_bzReadClose(&bzerr,b); + } + if(fp!=stdin && fp!=stdout){ + fclose(fp); + } +} + + +/*---------------------------------------------------*/ +/*-- + return last error code +--*/ +static char *bzerrorstrings[] = { + "OK" + ,"SEQUENCE_ERROR" + ,"PARAM_ERROR" + ,"MEM_ERROR" + ,"DATA_ERROR" + ,"DATA_ERROR_MAGIC" + ,"IO_ERROR" + ,"UNEXPECTED_EOF" + ,"OUTBUFF_FULL" + ,"CONFIG_ERROR" + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ +}; + + +const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum) +{ + int err = ((bzFile *)b)->lastErr; + + if(err>0) err = 0; + *errnum = err; + return bzerrorstrings[err*-1]; +} +#endif + + +/*-------------------------------------------------------------*/ +/*--- end bzlib.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/contrib/bzip2/bzlib.h b/contrib/bzip2/bzlib.h new file mode 100644 index 000000000000..c9447a295876 --- /dev/null +++ b/contrib/bzip2/bzlib.h @@ -0,0 +1,319 @@ + +/*-------------------------------------------------------------*/ +/*--- Public header file for the library. ---*/ +/*--- bzlib.h ---*/ +/*-------------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + + +#ifndef _BZLIB_H +#define _BZLIB_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define BZ_RUN 0 +#define BZ_FLUSH 1 +#define BZ_FINISH 2 + +#define BZ_OK 0 +#define BZ_RUN_OK 1 +#define BZ_FLUSH_OK 2 +#define BZ_FINISH_OK 3 +#define BZ_STREAM_END 4 +#define BZ_SEQUENCE_ERROR (-1) +#define BZ_PARAM_ERROR (-2) +#define BZ_MEM_ERROR (-3) +#define BZ_DATA_ERROR (-4) +#define BZ_DATA_ERROR_MAGIC (-5) +#define BZ_IO_ERROR (-6) +#define BZ_UNEXPECTED_EOF (-7) +#define BZ_OUTBUFF_FULL (-8) +#define BZ_CONFIG_ERROR (-9) + +typedef + struct { + char *next_in; + unsigned int avail_in; + unsigned int total_in_lo32; + unsigned int total_in_hi32; + + char *next_out; + unsigned int avail_out; + unsigned int total_out_lo32; + unsigned int total_out_hi32; + + void *state; + + void *(*bzalloc)(void *,int,int); + void (*bzfree)(void *,void *); + void *opaque; + } + bz_stream; + + +#ifndef BZ_IMPORT +#define BZ_EXPORT +#endif + +#ifdef _WIN32 +# include +# include +# ifdef small + /* windows.h define small to char */ +# undef small +# endif +# ifdef BZ_EXPORT +# define BZ_API(func) WINAPI func +# define BZ_EXTERN extern +# else + /* import windows dll dynamically */ +# define BZ_API(func) (WINAPI * func) +# define BZ_EXTERN +# endif +#else +# define BZ_API(func) func +# define BZ_EXTERN extern +#endif + + +/*-- Core (low-level) library functions --*/ + +BZ_EXTERN int BZ_API(BZ2_bzCompressInit) ( + bz_stream* strm, + int blockSize100k, + int verbosity, + int workFactor + ); + +BZ_EXTERN int BZ_API(BZ2_bzCompress) ( + bz_stream* strm, + int action + ); + +BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) ( + bz_stream* strm + ); + +BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) ( + bz_stream *strm, + int verbosity, + int small + ); + +BZ_EXTERN int BZ_API(BZ2_bzDecompress) ( + bz_stream* strm + ); + +BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) ( + bz_stream *strm + ); + + + +/*-- High(er) level library functions --*/ + +#ifndef BZ_NO_STDIO +#define BZ_MAX_UNUSED 5000 + +typedef void BZFILE; + +BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) ( + int* bzerror, + FILE* f, + int verbosity, + int small, + void* unused, + int nUnused + ); + +BZ_EXTERN void BZ_API(BZ2_bzReadClose) ( + int* bzerror, + BZFILE* b + ); + +BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) ( + int* bzerror, + BZFILE* b, + void** unused, + int* nUnused + ); + +BZ_EXTERN int BZ_API(BZ2_bzRead) ( + int* bzerror, + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) ( + int* bzerror, + FILE* f, + int blockSize100k, + int verbosity, + int workFactor + ); + +BZ_EXTERN void BZ_API(BZ2_bzWrite) ( + int* bzerror, + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN void BZ_API(BZ2_bzWriteClose) ( + int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in, + unsigned int* nbytes_out + ); + +BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) ( + int* bzerror, + BZFILE* b, + int abandon, + unsigned int* nbytes_in_lo32, + unsigned int* nbytes_in_hi32, + unsigned int* nbytes_out_lo32, + unsigned int* nbytes_out_hi32 + ); +#endif + + +/*-- Utility functions --*/ + +BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) ( + char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int blockSize100k, + int verbosity, + int workFactor + ); + +BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) ( + char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int small, + int verbosity + ); + + +/*-- + Code contributed by Yoshioka Tsuneo + (QWF00133@niftyserve.or.jp/tsuneo-y@is.aist-nara.ac.jp), + to support better zlib compatibility. + This code is not _officially_ part of libbzip2 (yet); + I haven't tested it, documented it, or considered the + threading-safeness of it. + If this code breaks, please contact both Yoshioka and me. +--*/ + +BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) ( + void + ); + +#ifndef BZ_NO_STDIO +BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) ( + const char *path, + const char *mode + ); + +BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) ( + int fd, + const char *mode + ); + +BZ_EXTERN int BZ_API(BZ2_bzread) ( + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN int BZ_API(BZ2_bzwrite) ( + BZFILE* b, + void* buf, + int len + ); + +BZ_EXTERN int BZ_API(BZ2_bzflush) ( + BZFILE* b + ); + +BZ_EXTERN void BZ_API(BZ2_bzclose) ( + BZFILE* b + ); + +BZ_EXTERN const char * BZ_API(BZ2_bzerror) ( + BZFILE *b, + int *errnum + ); +#endif + +#ifdef __cplusplus +} +#endif + +#endif + +/*-------------------------------------------------------------*/ +/*--- end bzlib.h ---*/ +/*-------------------------------------------------------------*/ diff --git a/contrib/bzip2/bzlib_private.h b/contrib/bzip2/bzlib_private.h new file mode 100644 index 000000000000..fb51c7a1d4b4 --- /dev/null +++ b/contrib/bzip2/bzlib_private.h @@ -0,0 +1,530 @@ + +/*-------------------------------------------------------------*/ +/*--- Private header file for the library. ---*/ +/*--- bzlib_private.h ---*/ +/*-------------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + + +#ifndef _BZLIB_PRIVATE_H +#define _BZLIB_PRIVATE_H + +#include + +#ifndef BZ_NO_STDIO +#include +#include +#include +#endif + +#include "bzlib.h" + + + +/*-- General stuff. --*/ + +#define BZ_VERSION "1.0.1, 23-June-2000" + +typedef char Char; +typedef unsigned char Bool; +typedef unsigned char UChar; +typedef int Int32; +typedef unsigned int UInt32; +typedef short Int16; +typedef unsigned short UInt16; + +#define True ((Bool)1) +#define False ((Bool)0) + +#ifndef __GNUC__ +#define __inline__ /* */ +#endif + +#ifndef BZ_NO_STDIO +extern void BZ2_bz__AssertH__fail ( int errcode ); +#define AssertH(cond,errcode) \ + { if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); } +#if BZ_DEBUG +#define AssertD(cond,msg) \ + { if (!(cond)) { \ + fprintf ( stderr, \ + "\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\ + exit(1); \ + }} +#else +#define AssertD(cond,msg) /* */ +#endif +#define VPrintf0(zf) \ + fprintf(stderr,zf) +#define VPrintf1(zf,za1) \ + fprintf(stderr,zf,za1) +#define VPrintf2(zf,za1,za2) \ + fprintf(stderr,zf,za1,za2) +#define VPrintf3(zf,za1,za2,za3) \ + fprintf(stderr,zf,za1,za2,za3) +#define VPrintf4(zf,za1,za2,za3,za4) \ + fprintf(stderr,zf,za1,za2,za3,za4) +#define VPrintf5(zf,za1,za2,za3,za4,za5) \ + fprintf(stderr,zf,za1,za2,za3,za4,za5) +#else +extern void bz_internal_error ( int errcode ); +#define AssertH(cond,errcode) \ + { if (!(cond)) bz_internal_error ( errcode ); } +#define AssertD(cond,msg) /* */ +#define VPrintf0(zf) /* */ +#define VPrintf1(zf,za1) /* */ +#define VPrintf2(zf,za1,za2) /* */ +#define VPrintf3(zf,za1,za2,za3) /* */ +#define VPrintf4(zf,za1,za2,za3,za4) /* */ +#define VPrintf5(zf,za1,za2,za3,za4,za5) /* */ +#endif + + +#define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1) +#define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp)) + + +/*-- Constants for the back end. --*/ + +#define BZ_MAX_ALPHA_SIZE 258 +#define BZ_MAX_CODE_LEN 23 + +#define BZ_RUNA 0 +#define BZ_RUNB 1 + +#define BZ_N_GROUPS 6 +#define BZ_G_SIZE 50 +#define BZ_N_ITERS 4 + +#define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE)) + + + +/*-- Stuff for randomising repetitive blocks. --*/ + +extern Int32 BZ2_rNums[512]; + +#define BZ_RAND_DECLS \ + Int32 rNToGo; \ + Int32 rTPos \ + +#define BZ_RAND_INIT_MASK \ + s->rNToGo = 0; \ + s->rTPos = 0 \ + +#define BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0) + +#define BZ_RAND_UPD_MASK \ + if (s->rNToGo == 0) { \ + s->rNToGo = BZ2_rNums[s->rTPos]; \ + s->rTPos++; \ + if (s->rTPos == 512) s->rTPos = 0; \ + } \ + s->rNToGo--; + + + +/*-- Stuff for doing CRCs. --*/ + +extern UInt32 BZ2_crc32Table[256]; + +#define BZ_INITIALISE_CRC(crcVar) \ +{ \ + crcVar = 0xffffffffL; \ +} + +#define BZ_FINALISE_CRC(crcVar) \ +{ \ + crcVar = ~(crcVar); \ +} + +#define BZ_UPDATE_CRC(crcVar,cha) \ +{ \ + crcVar = (crcVar << 8) ^ \ + BZ2_crc32Table[(crcVar >> 24) ^ \ + ((UChar)cha)]; \ +} + + + +/*-- States and modes for compression. --*/ + +#define BZ_M_IDLE 1 +#define BZ_M_RUNNING 2 +#define BZ_M_FLUSHING 3 +#define BZ_M_FINISHING 4 + +#define BZ_S_OUTPUT 1 +#define BZ_S_INPUT 2 + +#define BZ_N_RADIX 2 +#define BZ_N_QSORT 12 +#define BZ_N_SHELL 18 +#define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2) + + + + +/*-- Structure holding all the compression-side stuff. --*/ + +typedef + struct { + /* pointer back to the struct bz_stream */ + bz_stream* strm; + + /* mode this stream is in, and whether inputting */ + /* or outputting data */ + Int32 mode; + Int32 state; + + /* remembers avail_in when flush/finish requested */ + UInt32 avail_in_expect; + + /* for doing the block sorting */ + UInt32* arr1; + UInt32* arr2; + UInt32* ftab; + Int32 origPtr; + + /* aliases for arr1 and arr2 */ + UInt32* ptr; + UChar* block; + UInt16* mtfv; + UChar* zbits; + + /* for deciding when to use the fallback sorting algorithm */ + Int32 workFactor; + + /* run-length-encoding of the input */ + UInt32 state_in_ch; + Int32 state_in_len; + BZ_RAND_DECLS; + + /* input and output limits and current posns */ + Int32 nblock; + Int32 nblockMAX; + Int32 numZ; + Int32 state_out_pos; + + /* map of bytes used in block */ + Int32 nInUse; + Bool inUse[256]; + UChar unseqToSeq[256]; + + /* the buffer for bit stream creation */ + UInt32 bsBuff; + Int32 bsLive; + + /* block and combined CRCs */ + UInt32 blockCRC; + UInt32 combinedCRC; + + /* misc administratium */ + Int32 verbosity; + Int32 blockNo; + Int32 blockSize100k; + + /* stuff for coding the MTF values */ + Int32 nMTF; + Int32 mtfFreq [BZ_MAX_ALPHA_SIZE]; + UChar selector [BZ_MAX_SELECTORS]; + UChar selectorMtf[BZ_MAX_SELECTORS]; + + UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 rfreq [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + /* second dimension: only 3 needed; 4 makes index calculations faster */ + UInt32 len_pack[BZ_MAX_ALPHA_SIZE][4]; + + } + EState; + + + +/*-- externs for compression. --*/ + +extern void +BZ2_blockSort ( EState* ); + +extern void +BZ2_compressBlock ( EState*, Bool ); + +extern void +BZ2_bsInitWrite ( EState* ); + +extern void +BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 ); + +extern void +BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 ); + + + +/*-- states for decompression. --*/ + +#define BZ_X_IDLE 1 +#define BZ_X_OUTPUT 2 + +#define BZ_X_MAGIC_1 10 +#define BZ_X_MAGIC_2 11 +#define BZ_X_MAGIC_3 12 +#define BZ_X_MAGIC_4 13 +#define BZ_X_BLKHDR_1 14 +#define BZ_X_BLKHDR_2 15 +#define BZ_X_BLKHDR_3 16 +#define BZ_X_BLKHDR_4 17 +#define BZ_X_BLKHDR_5 18 +#define BZ_X_BLKHDR_6 19 +#define BZ_X_BCRC_1 20 +#define BZ_X_BCRC_2 21 +#define BZ_X_BCRC_3 22 +#define BZ_X_BCRC_4 23 +#define BZ_X_RANDBIT 24 +#define BZ_X_ORIGPTR_1 25 +#define BZ_X_ORIGPTR_2 26 +#define BZ_X_ORIGPTR_3 27 +#define BZ_X_MAPPING_1 28 +#define BZ_X_MAPPING_2 29 +#define BZ_X_SELECTOR_1 30 +#define BZ_X_SELECTOR_2 31 +#define BZ_X_SELECTOR_3 32 +#define BZ_X_CODING_1 33 +#define BZ_X_CODING_2 34 +#define BZ_X_CODING_3 35 +#define BZ_X_MTF_1 36 +#define BZ_X_MTF_2 37 +#define BZ_X_MTF_3 38 +#define BZ_X_MTF_4 39 +#define BZ_X_MTF_5 40 +#define BZ_X_MTF_6 41 +#define BZ_X_ENDHDR_2 42 +#define BZ_X_ENDHDR_3 43 +#define BZ_X_ENDHDR_4 44 +#define BZ_X_ENDHDR_5 45 +#define BZ_X_ENDHDR_6 46 +#define BZ_X_CCRC_1 47 +#define BZ_X_CCRC_2 48 +#define BZ_X_CCRC_3 49 +#define BZ_X_CCRC_4 50 + + + +/*-- Constants for the fast MTF decoder. --*/ + +#define MTFA_SIZE 4096 +#define MTFL_SIZE 16 + + + +/*-- Structure holding all the decompression-side stuff. --*/ + +typedef + struct { + /* pointer back to the struct bz_stream */ + bz_stream* strm; + + /* state indicator for this stream */ + Int32 state; + + /* for doing the final run-length decoding */ + UChar state_out_ch; + Int32 state_out_len; + Bool blockRandomised; + BZ_RAND_DECLS; + + /* the buffer for bit stream reading */ + UInt32 bsBuff; + Int32 bsLive; + + /* misc administratium */ + Int32 blockSize100k; + Bool smallDecompress; + Int32 currBlockNo; + Int32 verbosity; + + /* for undoing the Burrows-Wheeler transform */ + Int32 origPtr; + UInt32 tPos; + Int32 k0; + Int32 unzftab[256]; + Int32 nblock_used; + Int32 cftab[257]; + Int32 cftabCopy[257]; + + /* for undoing the Burrows-Wheeler transform (FAST) */ + UInt32 *tt; + + /* for undoing the Burrows-Wheeler transform (SMALL) */ + UInt16 *ll16; + UChar *ll4; + + /* stored and calculated CRCs */ + UInt32 storedBlockCRC; + UInt32 storedCombinedCRC; + UInt32 calculatedBlockCRC; + UInt32 calculatedCombinedCRC; + + /* map of bytes used in block */ + Int32 nInUse; + Bool inUse[256]; + Bool inUse16[16]; + UChar seqToUnseq[256]; + + /* for decoding the MTF values */ + UChar mtfa [MTFA_SIZE]; + Int32 mtfbase[256 / MTFL_SIZE]; + UChar selector [BZ_MAX_SELECTORS]; + UChar selectorMtf[BZ_MAX_SELECTORS]; + UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + + Int32 limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 minLens[BZ_N_GROUPS]; + + /* save area for scalars in the main decompress code */ + Int32 save_i; + Int32 save_j; + Int32 save_t; + Int32 save_alphaSize; + Int32 save_nGroups; + Int32 save_nSelectors; + Int32 save_EOB; + Int32 save_groupNo; + Int32 save_groupPos; + Int32 save_nextSym; + Int32 save_nblockMAX; + Int32 save_nblock; + Int32 save_es; + Int32 save_N; + Int32 save_curr; + Int32 save_zt; + Int32 save_zn; + Int32 save_zvec; + Int32 save_zj; + Int32 save_gSel; + Int32 save_gMinlen; + Int32* save_gLimit; + Int32* save_gBase; + Int32* save_gPerm; + + } + DState; + + + +/*-- Macros for decompression. --*/ + +#define BZ_GET_FAST(cccc) \ + s->tPos = s->tt[s->tPos]; \ + cccc = (UChar)(s->tPos & 0xff); \ + s->tPos >>= 8; + +#define BZ_GET_FAST_C(cccc) \ + c_tPos = c_tt[c_tPos]; \ + cccc = (UChar)(c_tPos & 0xff); \ + c_tPos >>= 8; + +#define SET_LL4(i,n) \ + { if (((i) & 0x1) == 0) \ + s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else \ + s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4); \ + } + +#define GET_LL4(i) \ + ((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF) + +#define SET_LL(i,n) \ + { s->ll16[i] = (UInt16)(n & 0x0000ffff); \ + SET_LL4(i, n >> 16); \ + } + +#define GET_LL(i) \ + (((UInt32)s->ll16[i]) | (GET_LL4(i) << 16)) + +#define BZ_GET_SMALL(cccc) \ + cccc = BZ2_indexIntoF ( s->tPos, s->cftab ); \ + s->tPos = GET_LL(s->tPos); + + +/*-- externs for decompression. --*/ + +extern Int32 +BZ2_indexIntoF ( Int32, Int32* ); + +extern Int32 +BZ2_decompress ( DState* ); + +extern void +BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*, + Int32, Int32, Int32 ); + + +#endif + + +/*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/ + +#ifdef BZ_NO_STDIO +#ifndef NULL +#define NULL 0 +#endif +#endif + + +/*-------------------------------------------------------------*/ +/*--- end bzlib_private.h ---*/ +/*-------------------------------------------------------------*/ diff --git a/contrib/bzip2/compress.c b/contrib/bzip2/compress.c new file mode 100644 index 000000000000..cc5e31d6f0ec --- /dev/null +++ b/contrib/bzip2/compress.c @@ -0,0 +1,714 @@ + +/*-------------------------------------------------------------*/ +/*--- Compression machinery (not incl block sorting) ---*/ +/*--- compress.c ---*/ +/*-------------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + +/*-- + CHANGES + ~~~~~~~ + 0.9.0 -- original version. + + 0.9.0a/b -- no changes in this file. + + 0.9.0c + * changed setting of nGroups in sendMTFValues() so as to + do a bit better on small files +--*/ + +#include "bzlib_private.h" + + +/*---------------------------------------------------*/ +/*--- Bit stream I/O ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +void BZ2_bsInitWrite ( EState* s ) +{ + s->bsLive = 0; + s->bsBuff = 0; +} + + +/*---------------------------------------------------*/ +static +void bsFinishWrite ( EState* s ) +{ + while (s->bsLive > 0) { + s->zbits[s->numZ] = (UChar)(s->bsBuff >> 24); + s->numZ++; + s->bsBuff <<= 8; + s->bsLive -= 8; + } +} + + +/*---------------------------------------------------*/ +#define bsNEEDW(nz) \ +{ \ + while (s->bsLive >= 8) { \ + s->zbits[s->numZ] \ + = (UChar)(s->bsBuff >> 24); \ + s->numZ++; \ + s->bsBuff <<= 8; \ + s->bsLive -= 8; \ + } \ +} + + +/*---------------------------------------------------*/ +static +__inline__ +void bsW ( EState* s, Int32 n, UInt32 v ) +{ + bsNEEDW ( n ); + s->bsBuff |= (v << (32 - s->bsLive - n)); + s->bsLive += n; +} + + +/*---------------------------------------------------*/ +static +void bsPutUInt32 ( EState* s, UInt32 u ) +{ + bsW ( s, 8, (u >> 24) & 0xffL ); + bsW ( s, 8, (u >> 16) & 0xffL ); + bsW ( s, 8, (u >> 8) & 0xffL ); + bsW ( s, 8, u & 0xffL ); +} + + +/*---------------------------------------------------*/ +static +void bsPutUChar ( EState* s, UChar c ) +{ + bsW( s, 8, (UInt32)c ); +} + + +/*---------------------------------------------------*/ +/*--- The back end proper ---*/ +/*---------------------------------------------------*/ + +/*---------------------------------------------------*/ +static +void makeMaps_e ( EState* s ) +{ + Int32 i; + s->nInUse = 0; + for (i = 0; i < 256; i++) + if (s->inUse[i]) { + s->unseqToSeq[i] = s->nInUse; + s->nInUse++; + } +} + + +/*---------------------------------------------------*/ +static +void generateMTFValues ( EState* s ) +{ + UChar yy[256]; + Int32 i, j; + Int32 zPend; + Int32 wr; + Int32 EOB; + + /* + After sorting (eg, here), + s->arr1 [ 0 .. s->nblock-1 ] holds sorted order, + and + ((UChar*)s->arr2) [ 0 .. s->nblock-1 ] + holds the original block data. + + The first thing to do is generate the MTF values, + and put them in + ((UInt16*)s->arr1) [ 0 .. s->nblock-1 ]. + Because there are strictly fewer or equal MTF values + than block values, ptr values in this area are overwritten + with MTF values only when they are no longer needed. + + The final compressed bitstream is generated into the + area starting at + (UChar*) (&((UChar*)s->arr2)[s->nblock]) + + These storage aliases are set up in bzCompressInit(), + except for the last one, which is arranged in + compressBlock(). + */ + UInt32* ptr = s->ptr; + UChar* block = s->block; + UInt16* mtfv = s->mtfv; + + makeMaps_e ( s ); + EOB = s->nInUse+1; + + for (i = 0; i <= EOB; i++) s->mtfFreq[i] = 0; + + wr = 0; + zPend = 0; + for (i = 0; i < s->nInUse; i++) yy[i] = (UChar) i; + + for (i = 0; i < s->nblock; i++) { + UChar ll_i; + AssertD ( wr <= i, "generateMTFValues(1)" ); + j = ptr[i]-1; if (j < 0) j += s->nblock; + ll_i = s->unseqToSeq[block[j]]; + AssertD ( ll_i < s->nInUse, "generateMTFValues(2a)" ); + + if (yy[0] == ll_i) { + zPend++; + } else { + + if (zPend > 0) { + zPend--; + while (True) { + if (zPend & 1) { + mtfv[wr] = BZ_RUNB; wr++; + s->mtfFreq[BZ_RUNB]++; + } else { + mtfv[wr] = BZ_RUNA; wr++; + s->mtfFreq[BZ_RUNA]++; + } + if (zPend < 2) break; + zPend = (zPend - 2) / 2; + }; + zPend = 0; + } + { + register UChar rtmp; + register UChar* ryy_j; + register UChar rll_i; + rtmp = yy[1]; + yy[1] = yy[0]; + ryy_j = &(yy[1]); + rll_i = ll_i; + while ( rll_i != rtmp ) { + register UChar rtmp2; + ryy_j++; + rtmp2 = rtmp; + rtmp = *ryy_j; + *ryy_j = rtmp2; + }; + yy[0] = rtmp; + j = ryy_j - &(yy[0]); + mtfv[wr] = j+1; wr++; s->mtfFreq[j+1]++; + } + + } + } + + if (zPend > 0) { + zPend--; + while (True) { + if (zPend & 1) { + mtfv[wr] = BZ_RUNB; wr++; + s->mtfFreq[BZ_RUNB]++; + } else { + mtfv[wr] = BZ_RUNA; wr++; + s->mtfFreq[BZ_RUNA]++; + } + if (zPend < 2) break; + zPend = (zPend - 2) / 2; + }; + zPend = 0; + } + + mtfv[wr] = EOB; wr++; s->mtfFreq[EOB]++; + + s->nMTF = wr; +} + + +/*---------------------------------------------------*/ +#define BZ_LESSER_ICOST 0 +#define BZ_GREATER_ICOST 15 + +static +void sendMTFValues ( EState* s ) +{ + Int32 v, t, i, j, gs, ge, totc, bt, bc, iter; + Int32 nSelectors, alphaSize, minLen, maxLen, selCtr; + Int32 nGroups, nBytes; + + /*-- + UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + is a global since the decoder also needs it. + + Int32 code[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + Int32 rfreq[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE]; + are also globals only used in this proc. + Made global to keep stack frame size small. + --*/ + + + UInt16 cost[BZ_N_GROUPS]; + Int32 fave[BZ_N_GROUPS]; + + UInt16* mtfv = s->mtfv; + + if (s->verbosity >= 3) + VPrintf3( " %d in block, %d after MTF & 1-2 coding, " + "%d+2 syms in use\n", + s->nblock, s->nMTF, s->nInUse ); + + alphaSize = s->nInUse+2; + for (t = 0; t < BZ_N_GROUPS; t++) + for (v = 0; v < alphaSize; v++) + s->len[t][v] = BZ_GREATER_ICOST; + + /*--- Decide how many coding tables to use ---*/ + AssertH ( s->nMTF > 0, 3001 ); + if (s->nMTF < 200) nGroups = 2; else + if (s->nMTF < 600) nGroups = 3; else + if (s->nMTF < 1200) nGroups = 4; else + if (s->nMTF < 2400) nGroups = 5; else + nGroups = 6; + + /*--- Generate an initial set of coding tables ---*/ + { + Int32 nPart, remF, tFreq, aFreq; + + nPart = nGroups; + remF = s->nMTF; + gs = 0; + while (nPart > 0) { + tFreq = remF / nPart; + ge = gs-1; + aFreq = 0; + while (aFreq < tFreq && ge < alphaSize-1) { + ge++; + aFreq += s->mtfFreq[ge]; + } + + if (ge > gs + && nPart != nGroups && nPart != 1 + && ((nGroups-nPart) % 2 == 1)) { + aFreq -= s->mtfFreq[ge]; + ge--; + } + + if (s->verbosity >= 3) + VPrintf5( " initial group %d, [%d .. %d], " + "has %d syms (%4.1f%%)\n", + nPart, gs, ge, aFreq, + (100.0 * (float)aFreq) / (float)(s->nMTF) ); + + for (v = 0; v < alphaSize; v++) + if (v >= gs && v <= ge) + s->len[nPart-1][v] = BZ_LESSER_ICOST; else + s->len[nPart-1][v] = BZ_GREATER_ICOST; + + nPart--; + gs = ge+1; + remF -= aFreq; + } + } + + /*--- + Iterate up to BZ_N_ITERS times to improve the tables. + ---*/ + for (iter = 0; iter < BZ_N_ITERS; iter++) { + + for (t = 0; t < nGroups; t++) fave[t] = 0; + + for (t = 0; t < nGroups; t++) + for (v = 0; v < alphaSize; v++) + s->rfreq[t][v] = 0; + + /*--- + Set up an auxiliary length table which is used to fast-track + the common case (nGroups == 6). + ---*/ + if (nGroups == 6) { + for (v = 0; v < alphaSize; v++) { + s->len_pack[v][0] = (s->len[1][v] << 16) | s->len[0][v]; + s->len_pack[v][1] = (s->len[3][v] << 16) | s->len[2][v]; + s->len_pack[v][2] = (s->len[5][v] << 16) | s->len[4][v]; + } + } + + nSelectors = 0; + totc = 0; + gs = 0; + while (True) { + + /*--- Set group start & end marks. --*/ + if (gs >= s->nMTF) break; + ge = gs + BZ_G_SIZE - 1; + if (ge >= s->nMTF) ge = s->nMTF-1; + + /*-- + Calculate the cost of this group as coded + by each of the coding tables. + --*/ + for (t = 0; t < nGroups; t++) cost[t] = 0; + + if (nGroups == 6 && 50 == ge-gs+1) { + /*--- fast track the common case ---*/ + register UInt32 cost01, cost23, cost45; + register UInt16 icv; + cost01 = cost23 = cost45 = 0; + +# define BZ_ITER(nn) \ + icv = mtfv[gs+(nn)]; \ + cost01 += s->len_pack[icv][0]; \ + cost23 += s->len_pack[icv][1]; \ + cost45 += s->len_pack[icv][2]; \ + + BZ_ITER(0); BZ_ITER(1); BZ_ITER(2); BZ_ITER(3); BZ_ITER(4); + BZ_ITER(5); BZ_ITER(6); BZ_ITER(7); BZ_ITER(8); BZ_ITER(9); + BZ_ITER(10); BZ_ITER(11); BZ_ITER(12); BZ_ITER(13); BZ_ITER(14); + BZ_ITER(15); BZ_ITER(16); BZ_ITER(17); BZ_ITER(18); BZ_ITER(19); + BZ_ITER(20); BZ_ITER(21); BZ_ITER(22); BZ_ITER(23); BZ_ITER(24); + BZ_ITER(25); BZ_ITER(26); BZ_ITER(27); BZ_ITER(28); BZ_ITER(29); + BZ_ITER(30); BZ_ITER(31); BZ_ITER(32); BZ_ITER(33); BZ_ITER(34); + BZ_ITER(35); BZ_ITER(36); BZ_ITER(37); BZ_ITER(38); BZ_ITER(39); + BZ_ITER(40); BZ_ITER(41); BZ_ITER(42); BZ_ITER(43); BZ_ITER(44); + BZ_ITER(45); BZ_ITER(46); BZ_ITER(47); BZ_ITER(48); BZ_ITER(49); + +# undef BZ_ITER + + cost[0] = cost01 & 0xffff; cost[1] = cost01 >> 16; + cost[2] = cost23 & 0xffff; cost[3] = cost23 >> 16; + cost[4] = cost45 & 0xffff; cost[5] = cost45 >> 16; + + } else { + /*--- slow version which correctly handles all situations ---*/ + for (i = gs; i <= ge; i++) { + UInt16 icv = mtfv[i]; + for (t = 0; t < nGroups; t++) cost[t] += s->len[t][icv]; + } + } + + /*-- + Find the coding table which is best for this group, + and record its identity in the selector table. + --*/ + bc = 999999999; bt = -1; + for (t = 0; t < nGroups; t++) + if (cost[t] < bc) { bc = cost[t]; bt = t; }; + totc += bc; + fave[bt]++; + s->selector[nSelectors] = bt; + nSelectors++; + + /*-- + Increment the symbol frequencies for the selected table. + --*/ + if (nGroups == 6 && 50 == ge-gs+1) { + /*--- fast track the common case ---*/ + +# define BZ_ITUR(nn) s->rfreq[bt][ mtfv[gs+(nn)] ]++ + + BZ_ITUR(0); BZ_ITUR(1); BZ_ITUR(2); BZ_ITUR(3); BZ_ITUR(4); + BZ_ITUR(5); BZ_ITUR(6); BZ_ITUR(7); BZ_ITUR(8); BZ_ITUR(9); + BZ_ITUR(10); BZ_ITUR(11); BZ_ITUR(12); BZ_ITUR(13); BZ_ITUR(14); + BZ_ITUR(15); BZ_ITUR(16); BZ_ITUR(17); BZ_ITUR(18); BZ_ITUR(19); + BZ_ITUR(20); BZ_ITUR(21); BZ_ITUR(22); BZ_ITUR(23); BZ_ITUR(24); + BZ_ITUR(25); BZ_ITUR(26); BZ_ITUR(27); BZ_ITUR(28); BZ_ITUR(29); + BZ_ITUR(30); BZ_ITUR(31); BZ_ITUR(32); BZ_ITUR(33); BZ_ITUR(34); + BZ_ITUR(35); BZ_ITUR(36); BZ_ITUR(37); BZ_ITUR(38); BZ_ITUR(39); + BZ_ITUR(40); BZ_ITUR(41); BZ_ITUR(42); BZ_ITUR(43); BZ_ITUR(44); + BZ_ITUR(45); BZ_ITUR(46); BZ_ITUR(47); BZ_ITUR(48); BZ_ITUR(49); + +# undef BZ_ITUR + + } else { + /*--- slow version which correctly handles all situations ---*/ + for (i = gs; i <= ge; i++) + s->rfreq[bt][ mtfv[i] ]++; + } + + gs = ge+1; + } + if (s->verbosity >= 3) { + VPrintf2 ( " pass %d: size is %d, grp uses are ", + iter+1, totc/8 ); + for (t = 0; t < nGroups; t++) + VPrintf1 ( "%d ", fave[t] ); + VPrintf0 ( "\n" ); + } + + /*-- + Recompute the tables based on the accumulated frequencies. + --*/ + for (t = 0; t < nGroups; t++) + BZ2_hbMakeCodeLengths ( &(s->len[t][0]), &(s->rfreq[t][0]), + alphaSize, 20 ); + } + + + AssertH( nGroups < 8, 3002 ); + AssertH( nSelectors < 32768 && + nSelectors <= (2 + (900000 / BZ_G_SIZE)), + 3003 ); + + + /*--- Compute MTF values for the selectors. ---*/ + { + UChar pos[BZ_N_GROUPS], ll_i, tmp2, tmp; + for (i = 0; i < nGroups; i++) pos[i] = i; + for (i = 0; i < nSelectors; i++) { + ll_i = s->selector[i]; + j = 0; + tmp = pos[j]; + while ( ll_i != tmp ) { + j++; + tmp2 = tmp; + tmp = pos[j]; + pos[j] = tmp2; + }; + pos[0] = tmp; + s->selectorMtf[i] = j; + } + }; + + /*--- Assign actual codes for the tables. --*/ + for (t = 0; t < nGroups; t++) { + minLen = 32; + maxLen = 0; + for (i = 0; i < alphaSize; i++) { + if (s->len[t][i] > maxLen) maxLen = s->len[t][i]; + if (s->len[t][i] < minLen) minLen = s->len[t][i]; + } + AssertH ( !(maxLen > 20), 3004 ); + AssertH ( !(minLen < 1), 3005 ); + BZ2_hbAssignCodes ( &(s->code[t][0]), &(s->len[t][0]), + minLen, maxLen, alphaSize ); + } + + /*--- Transmit the mapping table. ---*/ + { + Bool inUse16[16]; + for (i = 0; i < 16; i++) { + inUse16[i] = False; + for (j = 0; j < 16; j++) + if (s->inUse[i * 16 + j]) inUse16[i] = True; + } + + nBytes = s->numZ; + for (i = 0; i < 16; i++) + if (inUse16[i]) bsW(s,1,1); else bsW(s,1,0); + + for (i = 0; i < 16; i++) + if (inUse16[i]) + for (j = 0; j < 16; j++) { + if (s->inUse[i * 16 + j]) bsW(s,1,1); else bsW(s,1,0); + } + + if (s->verbosity >= 3) + VPrintf1( " bytes: mapping %d, ", s->numZ-nBytes ); + } + + /*--- Now the selectors. ---*/ + nBytes = s->numZ; + bsW ( s, 3, nGroups ); + bsW ( s, 15, nSelectors ); + for (i = 0; i < nSelectors; i++) { + for (j = 0; j < s->selectorMtf[i]; j++) bsW(s,1,1); + bsW(s,1,0); + } + if (s->verbosity >= 3) + VPrintf1( "selectors %d, ", s->numZ-nBytes ); + + /*--- Now the coding tables. ---*/ + nBytes = s->numZ; + + for (t = 0; t < nGroups; t++) { + Int32 curr = s->len[t][0]; + bsW ( s, 5, curr ); + for (i = 0; i < alphaSize; i++) { + while (curr < s->len[t][i]) { bsW(s,2,2); curr++; /* 10 */ }; + while (curr > s->len[t][i]) { bsW(s,2,3); curr--; /* 11 */ }; + bsW ( s, 1, 0 ); + } + } + + if (s->verbosity >= 3) + VPrintf1 ( "code lengths %d, ", s->numZ-nBytes ); + + /*--- And finally, the block data proper ---*/ + nBytes = s->numZ; + selCtr = 0; + gs = 0; + while (True) { + if (gs >= s->nMTF) break; + ge = gs + BZ_G_SIZE - 1; + if (ge >= s->nMTF) ge = s->nMTF-1; + AssertH ( s->selector[selCtr] < nGroups, 3006 ); + + if (nGroups == 6 && 50 == ge-gs+1) { + /*--- fast track the common case ---*/ + UInt16 mtfv_i; + UChar* s_len_sel_selCtr + = &(s->len[s->selector[selCtr]][0]); + Int32* s_code_sel_selCtr + = &(s->code[s->selector[selCtr]][0]); + +# define BZ_ITAH(nn) \ + mtfv_i = mtfv[gs+(nn)]; \ + bsW ( s, \ + s_len_sel_selCtr[mtfv_i], \ + s_code_sel_selCtr[mtfv_i] ) + + BZ_ITAH(0); BZ_ITAH(1); BZ_ITAH(2); BZ_ITAH(3); BZ_ITAH(4); + BZ_ITAH(5); BZ_ITAH(6); BZ_ITAH(7); BZ_ITAH(8); BZ_ITAH(9); + BZ_ITAH(10); BZ_ITAH(11); BZ_ITAH(12); BZ_ITAH(13); BZ_ITAH(14); + BZ_ITAH(15); BZ_ITAH(16); BZ_ITAH(17); BZ_ITAH(18); BZ_ITAH(19); + BZ_ITAH(20); BZ_ITAH(21); BZ_ITAH(22); BZ_ITAH(23); BZ_ITAH(24); + BZ_ITAH(25); BZ_ITAH(26); BZ_ITAH(27); BZ_ITAH(28); BZ_ITAH(29); + BZ_ITAH(30); BZ_ITAH(31); BZ_ITAH(32); BZ_ITAH(33); BZ_ITAH(34); + BZ_ITAH(35); BZ_ITAH(36); BZ_ITAH(37); BZ_ITAH(38); BZ_ITAH(39); + BZ_ITAH(40); BZ_ITAH(41); BZ_ITAH(42); BZ_ITAH(43); BZ_ITAH(44); + BZ_ITAH(45); BZ_ITAH(46); BZ_ITAH(47); BZ_ITAH(48); BZ_ITAH(49); + +# undef BZ_ITAH + + } else { + /*--- slow version which correctly handles all situations ---*/ + for (i = gs; i <= ge; i++) { + bsW ( s, + s->len [s->selector[selCtr]] [mtfv[i]], + s->code [s->selector[selCtr]] [mtfv[i]] ); + } + } + + + gs = ge+1; + selCtr++; + } + AssertH( selCtr == nSelectors, 3007 ); + + if (s->verbosity >= 3) + VPrintf1( "codes %d\n", s->numZ-nBytes ); +} + + +/*---------------------------------------------------*/ +void BZ2_compressBlock ( EState* s, Bool is_last_block ) +{ + if (s->nblock > 0) { + + BZ_FINALISE_CRC ( s->blockCRC ); + s->combinedCRC = (s->combinedCRC << 1) | (s->combinedCRC >> 31); + s->combinedCRC ^= s->blockCRC; + if (s->blockNo > 1) s->numZ = 0; + + if (s->verbosity >= 2) + VPrintf4( " block %d: crc = 0x%8x, " + "combined CRC = 0x%8x, size = %d\n", + s->blockNo, s->blockCRC, s->combinedCRC, s->nblock ); + + BZ2_blockSort ( s ); + } + + s->zbits = (UChar*) (&((UChar*)s->arr2)[s->nblock]); + + /*-- If this is the first block, create the stream header. --*/ + if (s->blockNo == 1) { + BZ2_bsInitWrite ( s ); + bsPutUChar ( s, 'B' ); + bsPutUChar ( s, 'Z' ); + bsPutUChar ( s, 'h' ); + bsPutUChar ( s, (UChar)('0' + s->blockSize100k) ); + } + + if (s->nblock > 0) { + + bsPutUChar ( s, 0x31 ); bsPutUChar ( s, 0x41 ); + bsPutUChar ( s, 0x59 ); bsPutUChar ( s, 0x26 ); + bsPutUChar ( s, 0x53 ); bsPutUChar ( s, 0x59 ); + + /*-- Now the block's CRC, so it is in a known place. --*/ + bsPutUInt32 ( s, s->blockCRC ); + + /*-- + Now a single bit indicating (non-)randomisation. + As of version 0.9.5, we use a better sorting algorithm + which makes randomisation unnecessary. So always set + the randomised bit to 'no'. Of course, the decoder + still needs to be able to handle randomised blocks + so as to maintain backwards compatibility with + older versions of bzip2. + --*/ + bsW(s,1,0); + + bsW ( s, 24, s->origPtr ); + generateMTFValues ( s ); + sendMTFValues ( s ); + } + + + /*-- If this is the last block, add the stream trailer. --*/ + if (is_last_block) { + + bsPutUChar ( s, 0x17 ); bsPutUChar ( s, 0x72 ); + bsPutUChar ( s, 0x45 ); bsPutUChar ( s, 0x38 ); + bsPutUChar ( s, 0x50 ); bsPutUChar ( s, 0x90 ); + bsPutUInt32 ( s, s->combinedCRC ); + if (s->verbosity >= 2) + VPrintf1( " final combined CRC = 0x%x\n ", s->combinedCRC ); + bsFinishWrite ( s ); + } +} + + +/*-------------------------------------------------------------*/ +/*--- end compress.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/contrib/bzip2/crctable.c b/contrib/bzip2/crctable.c new file mode 100644 index 000000000000..61c040c4fcfc --- /dev/null +++ b/contrib/bzip2/crctable.c @@ -0,0 +1,144 @@ + +/*-------------------------------------------------------------*/ +/*--- Table for doing CRCs ---*/ +/*--- crctable.c ---*/ +/*-------------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + + +#include "bzlib_private.h" + +/*-- + I think this is an implementation of the AUTODIN-II, + Ethernet & FDDI 32-bit CRC standard. Vaguely derived + from code by Rob Warnock, in Section 51 of the + comp.compression FAQ. +--*/ + +UInt32 BZ2_crc32Table[256] = { + + /*-- Ugly, innit? --*/ + + 0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L, + 0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L, + 0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L, + 0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL, + 0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L, + 0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L, + 0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L, + 0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL, + 0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L, + 0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L, + 0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L, + 0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL, + 0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L, + 0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L, + 0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L, + 0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL, + 0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL, + 0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L, + 0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L, + 0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL, + 0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL, + 0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L, + 0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L, + 0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL, + 0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL, + 0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L, + 0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L, + 0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL, + 0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL, + 0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L, + 0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L, + 0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL, + 0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L, + 0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL, + 0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL, + 0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L, + 0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L, + 0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL, + 0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL, + 0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L, + 0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L, + 0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL, + 0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL, + 0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L, + 0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L, + 0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL, + 0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL, + 0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L, + 0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L, + 0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL, + 0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L, + 0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L, + 0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L, + 0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL, + 0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L, + 0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L, + 0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L, + 0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL, + 0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L, + 0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L, + 0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L, + 0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL, + 0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L, + 0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L +}; + + +/*-------------------------------------------------------------*/ +/*--- end crctable.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/contrib/bzip2/decompress.c b/contrib/bzip2/decompress.c new file mode 100644 index 000000000000..cdced1889061 --- /dev/null +++ b/contrib/bzip2/decompress.c @@ -0,0 +1,660 @@ + +/*-------------------------------------------------------------*/ +/*--- Decompression machinery ---*/ +/*--- decompress.c ---*/ +/*-------------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + + +#include "bzlib_private.h" + + +/*---------------------------------------------------*/ +static +void makeMaps_d ( DState* s ) +{ + Int32 i; + s->nInUse = 0; + for (i = 0; i < 256; i++) + if (s->inUse[i]) { + s->seqToUnseq[s->nInUse] = i; + s->nInUse++; + } +} + + +/*---------------------------------------------------*/ +#define RETURN(rrr) \ + { retVal = rrr; goto save_state_and_return; }; + +#define GET_BITS(lll,vvv,nnn) \ + case lll: s->state = lll; \ + while (True) { \ + if (s->bsLive >= nnn) { \ + UInt32 v; \ + v = (s->bsBuff >> \ + (s->bsLive-nnn)) & ((1 << nnn)-1); \ + s->bsLive -= nnn; \ + vvv = v; \ + break; \ + } \ + if (s->strm->avail_in == 0) RETURN(BZ_OK); \ + s->bsBuff \ + = (s->bsBuff << 8) | \ + ((UInt32) \ + (*((UChar*)(s->strm->next_in)))); \ + s->bsLive += 8; \ + s->strm->next_in++; \ + s->strm->avail_in--; \ + s->strm->total_in_lo32++; \ + if (s->strm->total_in_lo32 == 0) \ + s->strm->total_in_hi32++; \ + } + +#define GET_UCHAR(lll,uuu) \ + GET_BITS(lll,uuu,8) + +#define GET_BIT(lll,uuu) \ + GET_BITS(lll,uuu,1) + +/*---------------------------------------------------*/ +#define GET_MTF_VAL(label1,label2,lval) \ +{ \ + if (groupPos == 0) { \ + groupNo++; \ + if (groupNo >= nSelectors) \ + RETURN(BZ_DATA_ERROR); \ + groupPos = BZ_G_SIZE; \ + gSel = s->selector[groupNo]; \ + gMinlen = s->minLens[gSel]; \ + gLimit = &(s->limit[gSel][0]); \ + gPerm = &(s->perm[gSel][0]); \ + gBase = &(s->base[gSel][0]); \ + } \ + groupPos--; \ + zn = gMinlen; \ + GET_BITS(label1, zvec, zn); \ + while (1) { \ + if (zn > 20 /* the longest code */) \ + RETURN(BZ_DATA_ERROR); \ + if (zvec <= gLimit[zn]) break; \ + zn++; \ + GET_BIT(label2, zj); \ + zvec = (zvec << 1) | zj; \ + }; \ + if (zvec - gBase[zn] < 0 \ + || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) \ + RETURN(BZ_DATA_ERROR); \ + lval = gPerm[zvec - gBase[zn]]; \ +} + + +/*---------------------------------------------------*/ +Int32 BZ2_decompress ( DState* s ) +{ + UChar uc; + Int32 retVal; + Int32 minLen, maxLen; + bz_stream* strm = s->strm; + + /* stuff that needs to be saved/restored */ + Int32 i; + Int32 j; + Int32 t; + Int32 alphaSize; + Int32 nGroups; + Int32 nSelectors; + Int32 EOB; + Int32 groupNo; + Int32 groupPos; + Int32 nextSym; + Int32 nblockMAX; + Int32 nblock; + Int32 es; + Int32 N; + Int32 curr; + Int32 zt; + Int32 zn; + Int32 zvec; + Int32 zj; + Int32 gSel; + Int32 gMinlen; + Int32* gLimit; + Int32* gBase; + Int32* gPerm; + + if (s->state == BZ_X_MAGIC_1) { + /*initialise the save area*/ + s->save_i = 0; + s->save_j = 0; + s->save_t = 0; + s->save_alphaSize = 0; + s->save_nGroups = 0; + s->save_nSelectors = 0; + s->save_EOB = 0; + s->save_groupNo = 0; + s->save_groupPos = 0; + s->save_nextSym = 0; + s->save_nblockMAX = 0; + s->save_nblock = 0; + s->save_es = 0; + s->save_N = 0; + s->save_curr = 0; + s->save_zt = 0; + s->save_zn = 0; + s->save_zvec = 0; + s->save_zj = 0; + s->save_gSel = 0; + s->save_gMinlen = 0; + s->save_gLimit = NULL; + s->save_gBase = NULL; + s->save_gPerm = NULL; + } + + /*restore from the save area*/ + i = s->save_i; + j = s->save_j; + t = s->save_t; + alphaSize = s->save_alphaSize; + nGroups = s->save_nGroups; + nSelectors = s->save_nSelectors; + EOB = s->save_EOB; + groupNo = s->save_groupNo; + groupPos = s->save_groupPos; + nextSym = s->save_nextSym; + nblockMAX = s->save_nblockMAX; + nblock = s->save_nblock; + es = s->save_es; + N = s->save_N; + curr = s->save_curr; + zt = s->save_zt; + zn = s->save_zn; + zvec = s->save_zvec; + zj = s->save_zj; + gSel = s->save_gSel; + gMinlen = s->save_gMinlen; + gLimit = s->save_gLimit; + gBase = s->save_gBase; + gPerm = s->save_gPerm; + + retVal = BZ_OK; + + switch (s->state) { + + GET_UCHAR(BZ_X_MAGIC_1, uc); + if (uc != 'B') RETURN(BZ_DATA_ERROR_MAGIC); + + GET_UCHAR(BZ_X_MAGIC_2, uc); + if (uc != 'Z') RETURN(BZ_DATA_ERROR_MAGIC); + + GET_UCHAR(BZ_X_MAGIC_3, uc) + if (uc != 'h') RETURN(BZ_DATA_ERROR_MAGIC); + + GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8) + if (s->blockSize100k < '1' || + s->blockSize100k > '9') RETURN(BZ_DATA_ERROR_MAGIC); + s->blockSize100k -= '0'; + + if (s->smallDecompress) { + s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) ); + s->ll4 = BZALLOC( + ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) + ); + if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR); + } else { + s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) ); + if (s->tt == NULL) RETURN(BZ_MEM_ERROR); + } + + GET_UCHAR(BZ_X_BLKHDR_1, uc); + + if (uc == 0x17) goto endhdr_2; + if (uc != 0x31) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_2, uc); + if (uc != 0x41) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_3, uc); + if (uc != 0x59) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_4, uc); + if (uc != 0x26) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_5, uc); + if (uc != 0x53) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_BLKHDR_6, uc); + if (uc != 0x59) RETURN(BZ_DATA_ERROR); + + s->currBlockNo++; + if (s->verbosity >= 2) + VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo ); + + s->storedBlockCRC = 0; + GET_UCHAR(BZ_X_BCRC_1, uc); + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_BCRC_2, uc); + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_BCRC_3, uc); + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_BCRC_4, uc); + s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc); + + GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1); + + s->origPtr = 0; + GET_UCHAR(BZ_X_ORIGPTR_1, uc); + s->origPtr = (s->origPtr << 8) | ((Int32)uc); + GET_UCHAR(BZ_X_ORIGPTR_2, uc); + s->origPtr = (s->origPtr << 8) | ((Int32)uc); + GET_UCHAR(BZ_X_ORIGPTR_3, uc); + s->origPtr = (s->origPtr << 8) | ((Int32)uc); + + if (s->origPtr < 0) + RETURN(BZ_DATA_ERROR); + if (s->origPtr > 10 + 100000*s->blockSize100k) + RETURN(BZ_DATA_ERROR); + + /*--- Receive the mapping table ---*/ + for (i = 0; i < 16; i++) { + GET_BIT(BZ_X_MAPPING_1, uc); + if (uc == 1) + s->inUse16[i] = True; else + s->inUse16[i] = False; + } + + for (i = 0; i < 256; i++) s->inUse[i] = False; + + for (i = 0; i < 16; i++) + if (s->inUse16[i]) + for (j = 0; j < 16; j++) { + GET_BIT(BZ_X_MAPPING_2, uc); + if (uc == 1) s->inUse[i * 16 + j] = True; + } + makeMaps_d ( s ); + if (s->nInUse == 0) RETURN(BZ_DATA_ERROR); + alphaSize = s->nInUse+2; + + /*--- Now the selectors ---*/ + GET_BITS(BZ_X_SELECTOR_1, nGroups, 3); + if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR); + GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15); + if (nSelectors < 1) RETURN(BZ_DATA_ERROR); + for (i = 0; i < nSelectors; i++) { + j = 0; + while (True) { + GET_BIT(BZ_X_SELECTOR_3, uc); + if (uc == 0) break; + j++; + if (j >= nGroups) RETURN(BZ_DATA_ERROR); + } + s->selectorMtf[i] = j; + } + + /*--- Undo the MTF values for the selectors. ---*/ + { + UChar pos[BZ_N_GROUPS], tmp, v; + for (v = 0; v < nGroups; v++) pos[v] = v; + + for (i = 0; i < nSelectors; i++) { + v = s->selectorMtf[i]; + tmp = pos[v]; + while (v > 0) { pos[v] = pos[v-1]; v--; } + pos[0] = tmp; + s->selector[i] = tmp; + } + } + + /*--- Now the coding tables ---*/ + for (t = 0; t < nGroups; t++) { + GET_BITS(BZ_X_CODING_1, curr, 5); + for (i = 0; i < alphaSize; i++) { + while (True) { + if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR); + GET_BIT(BZ_X_CODING_2, uc); + if (uc == 0) break; + GET_BIT(BZ_X_CODING_3, uc); + if (uc == 0) curr++; else curr--; + } + s->len[t][i] = curr; + } + } + + /*--- Create the Huffman decoding tables ---*/ + for (t = 0; t < nGroups; t++) { + minLen = 32; + maxLen = 0; + for (i = 0; i < alphaSize; i++) { + if (s->len[t][i] > maxLen) maxLen = s->len[t][i]; + if (s->len[t][i] < minLen) minLen = s->len[t][i]; + } + BZ2_hbCreateDecodeTables ( + &(s->limit[t][0]), + &(s->base[t][0]), + &(s->perm[t][0]), + &(s->len[t][0]), + minLen, maxLen, alphaSize + ); + s->minLens[t] = minLen; + } + + /*--- Now the MTF values ---*/ + + EOB = s->nInUse+1; + nblockMAX = 100000 * s->blockSize100k; + groupNo = -1; + groupPos = 0; + + for (i = 0; i <= 255; i++) s->unzftab[i] = 0; + + /*-- MTF init --*/ + { + Int32 ii, jj, kk; + kk = MTFA_SIZE-1; + for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) { + for (jj = MTFL_SIZE-1; jj >= 0; jj--) { + s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj); + kk--; + } + s->mtfbase[ii] = kk + 1; + } + } + /*-- end MTF init --*/ + + nblock = 0; + GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym); + + while (True) { + + if (nextSym == EOB) break; + + if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) { + + es = -1; + N = 1; + do { + if (nextSym == BZ_RUNA) es = es + (0+1) * N; else + if (nextSym == BZ_RUNB) es = es + (1+1) * N; + N = N * 2; + GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym); + } + while (nextSym == BZ_RUNA || nextSym == BZ_RUNB); + + es++; + uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ]; + s->unzftab[uc] += es; + + if (s->smallDecompress) + while (es > 0) { + if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); + s->ll16[nblock] = (UInt16)uc; + nblock++; + es--; + } + else + while (es > 0) { + if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); + s->tt[nblock] = (UInt32)uc; + nblock++; + es--; + }; + + continue; + + } else { + + if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR); + + /*-- uc = MTF ( nextSym-1 ) --*/ + { + Int32 ii, jj, kk, pp, lno, off; + UInt32 nn; + nn = (UInt32)(nextSym - 1); + + if (nn < MTFL_SIZE) { + /* avoid general-case expense */ + pp = s->mtfbase[0]; + uc = s->mtfa[pp+nn]; + while (nn > 3) { + Int32 z = pp+nn; + s->mtfa[(z) ] = s->mtfa[(z)-1]; + s->mtfa[(z)-1] = s->mtfa[(z)-2]; + s->mtfa[(z)-2] = s->mtfa[(z)-3]; + s->mtfa[(z)-3] = s->mtfa[(z)-4]; + nn -= 4; + } + while (nn > 0) { + s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; + }; + s->mtfa[pp] = uc; + } else { + /* general case */ + lno = nn / MTFL_SIZE; + off = nn % MTFL_SIZE; + pp = s->mtfbase[lno] + off; + uc = s->mtfa[pp]; + while (pp > s->mtfbase[lno]) { + s->mtfa[pp] = s->mtfa[pp-1]; pp--; + }; + s->mtfbase[lno]++; + while (lno > 0) { + s->mtfbase[lno]--; + s->mtfa[s->mtfbase[lno]] + = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1]; + lno--; + } + s->mtfbase[0]--; + s->mtfa[s->mtfbase[0]] = uc; + if (s->mtfbase[0] == 0) { + kk = MTFA_SIZE-1; + for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) { + for (jj = MTFL_SIZE-1; jj >= 0; jj--) { + s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj]; + kk--; + } + s->mtfbase[ii] = kk + 1; + } + } + } + } + /*-- end uc = MTF ( nextSym-1 ) --*/ + + s->unzftab[s->seqToUnseq[uc]]++; + if (s->smallDecompress) + s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else + s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]); + nblock++; + + GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym); + continue; + } + } + + /* Now we know what nblock is, we can do a better sanity + check on s->origPtr. + */ + if (s->origPtr < 0 || s->origPtr >= nblock) + RETURN(BZ_DATA_ERROR); + + s->state_out_len = 0; + s->state_out_ch = 0; + BZ_INITIALISE_CRC ( s->calculatedBlockCRC ); + s->state = BZ_X_OUTPUT; + if (s->verbosity >= 2) VPrintf0 ( "rt+rld" ); + + /*-- Set up cftab to facilitate generation of T^(-1) --*/ + s->cftab[0] = 0; + for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1]; + for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1]; + + if (s->smallDecompress) { + + /*-- Make a copy of cftab, used in generation of T --*/ + for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i]; + + /*-- compute the T vector --*/ + for (i = 0; i < nblock; i++) { + uc = (UChar)(s->ll16[i]); + SET_LL(i, s->cftabCopy[uc]); + s->cftabCopy[uc]++; + } + + /*-- Compute T^(-1) by pointer reversal on T --*/ + i = s->origPtr; + j = GET_LL(i); + do { + Int32 tmp = GET_LL(j); + SET_LL(j, i); + i = j; + j = tmp; + } + while (i != s->origPtr); + + s->tPos = s->origPtr; + s->nblock_used = 0; + if (s->blockRandomised) { + BZ_RAND_INIT_MASK; + BZ_GET_SMALL(s->k0); s->nblock_used++; + BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; + } else { + BZ_GET_SMALL(s->k0); s->nblock_used++; + } + + } else { + + /*-- compute the T^(-1) vector --*/ + for (i = 0; i < nblock; i++) { + uc = (UChar)(s->tt[i] & 0xff); + s->tt[s->cftab[uc]] |= (i << 8); + s->cftab[uc]++; + } + + s->tPos = s->tt[s->origPtr] >> 8; + s->nblock_used = 0; + if (s->blockRandomised) { + BZ_RAND_INIT_MASK; + BZ_GET_FAST(s->k0); s->nblock_used++; + BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; + } else { + BZ_GET_FAST(s->k0); s->nblock_used++; + } + + } + + RETURN(BZ_OK); + + + + endhdr_2: + + GET_UCHAR(BZ_X_ENDHDR_2, uc); + if (uc != 0x72) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_ENDHDR_3, uc); + if (uc != 0x45) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_ENDHDR_4, uc); + if (uc != 0x38) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_ENDHDR_5, uc); + if (uc != 0x50) RETURN(BZ_DATA_ERROR); + GET_UCHAR(BZ_X_ENDHDR_6, uc); + if (uc != 0x90) RETURN(BZ_DATA_ERROR); + + s->storedCombinedCRC = 0; + GET_UCHAR(BZ_X_CCRC_1, uc); + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_CCRC_2, uc); + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_CCRC_3, uc); + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); + GET_UCHAR(BZ_X_CCRC_4, uc); + s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc); + + s->state = BZ_X_IDLE; + RETURN(BZ_STREAM_END); + + default: AssertH ( False, 4001 ); + } + + AssertH ( False, 4002 ); + + save_state_and_return: + + s->save_i = i; + s->save_j = j; + s->save_t = t; + s->save_alphaSize = alphaSize; + s->save_nGroups = nGroups; + s->save_nSelectors = nSelectors; + s->save_EOB = EOB; + s->save_groupNo = groupNo; + s->save_groupPos = groupPos; + s->save_nextSym = nextSym; + s->save_nblockMAX = nblockMAX; + s->save_nblock = nblock; + s->save_es = es; + s->save_N = N; + s->save_curr = curr; + s->save_zt = zt; + s->save_zn = zn; + s->save_zvec = zvec; + s->save_zj = zj; + s->save_gSel = gSel; + s->save_gMinlen = gMinlen; + s->save_gLimit = gLimit; + s->save_gBase = gBase; + s->save_gPerm = gPerm; + + return retVal; +} + + +/*-------------------------------------------------------------*/ +/*--- end decompress.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/contrib/bzip2/dlltest.c b/contrib/bzip2/dlltest.c new file mode 100644 index 000000000000..f79279cef846 --- /dev/null +++ b/contrib/bzip2/dlltest.c @@ -0,0 +1,176 @@ +/* + minibz2 + libbz2.dll test program. + by Yoshioka Tsuneo(QWF00133@nifty.ne.jp/tsuneo-y@is.aist-nara.ac.jp) + This file is Public Domain. + welcome any email to me. + + usage: minibz2 [-d] [-{1,2,..9}] [[srcfilename] destfilename] +*/ + +#define BZ_IMPORT +#include +#include +#include "bzlib.h" +#ifdef _WIN32 +#include +#endif + + +#ifdef _WIN32 + +#define BZ2_LIBNAME "libbz2-1.0.0.DLL" + +#include +static int BZ2DLLLoaded = 0; +static HINSTANCE BZ2DLLhLib; +int BZ2DLLLoadLibrary(void) +{ + HINSTANCE hLib; + + if(BZ2DLLLoaded==1){return 0;} + hLib=LoadLibrary(BZ2_LIBNAME); + if(hLib == NULL){ + fprintf(stderr,"Can't load %s\n",BZ2_LIBNAME); + return -1; + } + BZ2_bzlibVersion=GetProcAddress(hLib,"BZ2_bzlibVersion"); + BZ2_bzopen=GetProcAddress(hLib,"BZ2_bzopen"); + BZ2_bzdopen=GetProcAddress(hLib,"BZ2_bzdopen"); + BZ2_bzread=GetProcAddress(hLib,"BZ2_bzread"); + BZ2_bzwrite=GetProcAddress(hLib,"BZ2_bzwrite"); + BZ2_bzflush=GetProcAddress(hLib,"BZ2_bzflush"); + BZ2_bzclose=GetProcAddress(hLib,"BZ2_bzclose"); + BZ2_bzerror=GetProcAddress(hLib,"BZ2_bzerror"); + + if (!BZ2_bzlibVersion || !BZ2_bzopen || !BZ2_bzdopen + || !BZ2_bzread || !BZ2_bzwrite || !BZ2_bzflush + || !BZ2_bzclose || !BZ2_bzerror) { + fprintf(stderr,"GetProcAddress failed.\n"); + return -1; + } + BZ2DLLLoaded=1; + BZ2DLLhLib=hLib; + return 0; + +} +int BZ2DLLFreeLibrary(void) +{ + if(BZ2DLLLoaded==0){return 0;} + FreeLibrary(BZ2DLLhLib); + BZ2DLLLoaded=0; +} +#endif /* WIN32 */ + +void usage(void) +{ + puts("usage: minibz2 [-d] [-{1,2,..9}] [[srcfilename] destfilename]"); +} + +int main(int argc,char *argv[]) +{ + int decompress = 0; + int level = 9; + char *fn_r = NULL; + char *fn_w = NULL; + +#ifdef _WIN32 + if(BZ2DLLLoadLibrary()<0){ + fprintf(stderr,"Loading of %s failed. Giving up.\n", BZ2_LIBNAME); + exit(1); + } + printf("Loading of %s succeeded. Library version is %s.\n", + BZ2_LIBNAME, BZ2_bzlibVersion() ); +#endif + while(++argv,--argc){ + if(**argv =='-' || **argv=='/'){ + char *p; + + for(p=*argv+1;*p;p++){ + if(*p=='d'){ + decompress = 1; + }else if('1'<=*p && *p<='9'){ + level = *p - '0'; + }else{ + usage(); + exit(1); + } + } + }else{ + break; + } + } + if(argc>=1){ + fn_r = *argv; + argc--;argv++; + }else{ + fn_r = NULL; + } + if(argc>=1){ + fn_w = *argv; + argc--;argv++; + }else{ + fn_w = NULL; + } + { + int len; + char buff[0x1000]; + char mode[10]; + + if(decompress){ + BZFILE *BZ2fp_r = NULL; + FILE *fp_w = NULL; + + if(fn_w){ + if((fp_w = fopen(fn_w,"wb"))==NULL){ + printf("can't open [%s]\n",fn_w); + perror("reason:"); + exit(1); + } + }else{ + fp_w = stdout; + } + if((BZ2fp_r == NULL && (BZ2fp_r = BZ2_bzdopen(fileno(stdin),"rb"))==NULL) + || (BZ2fp_r != NULL && (BZ2fp_r = BZ2_bzopen(fn_r,"rb"))==NULL)){ + printf("can't bz2openstream\n"); + exit(1); + } + while((len=BZ2_bzread(BZ2fp_r,buff,0x1000))>0){ + fwrite(buff,1,len,fp_w); + } + BZ2_bzclose(BZ2fp_r); + if(fp_w != stdout) fclose(fp_w); + }else{ + BZFILE *BZ2fp_w = NULL; + FILE *fp_r = NULL; + + if(fn_r){ + if((fp_r = fopen(fn_r,"rb"))==NULL){ + printf("can't open [%s]\n",fn_r); + perror("reason:"); + exit(1); + } + }else{ + fp_r = stdin; + } + mode[0]='w'; + mode[1] = '0' + level; + mode[2] = '\0'; + + if((fn_w == NULL && (BZ2fp_w = BZ2_bzdopen(fileno(stdout),mode))==NULL) + || (fn_w !=NULL && (BZ2fp_w = BZ2_bzopen(fn_w,mode))==NULL)){ + printf("can't bz2openstream\n"); + exit(1); + } + while((len=fread(buff,1,0x1000,fp_r))>0){ + BZ2_bzwrite(BZ2fp_w,buff,len); + } + BZ2_bzclose(BZ2fp_w); + if(fp_r!=stdin)fclose(fp_r); + } + } +#ifdef _WIN32 + BZ2DLLFreeLibrary(); +#endif + return 0; +} diff --git a/contrib/bzip2/huffman.c b/contrib/bzip2/huffman.c new file mode 100644 index 000000000000..9b446c4b36d1 --- /dev/null +++ b/contrib/bzip2/huffman.c @@ -0,0 +1,228 @@ + +/*-------------------------------------------------------------*/ +/*--- Huffman coding low-level stuff ---*/ +/*--- huffman.c ---*/ +/*-------------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + + +#include "bzlib_private.h" + +/*---------------------------------------------------*/ +#define WEIGHTOF(zz0) ((zz0) & 0xffffff00) +#define DEPTHOF(zz1) ((zz1) & 0x000000ff) +#define MYMAX(zz2,zz3) ((zz2) > (zz3) ? (zz2) : (zz3)) + +#define ADDWEIGHTS(zw1,zw2) \ + (WEIGHTOF(zw1)+WEIGHTOF(zw2)) | \ + (1 + MYMAX(DEPTHOF(zw1),DEPTHOF(zw2))) + +#define UPHEAP(z) \ +{ \ + Int32 zz, tmp; \ + zz = z; tmp = heap[zz]; \ + while (weight[tmp] < weight[heap[zz >> 1]]) { \ + heap[zz] = heap[zz >> 1]; \ + zz >>= 1; \ + } \ + heap[zz] = tmp; \ +} + +#define DOWNHEAP(z) \ +{ \ + Int32 zz, yy, tmp; \ + zz = z; tmp = heap[zz]; \ + while (True) { \ + yy = zz << 1; \ + if (yy > nHeap) break; \ + if (yy < nHeap && \ + weight[heap[yy+1]] < weight[heap[yy]]) \ + yy++; \ + if (weight[tmp] < weight[heap[yy]]) break; \ + heap[zz] = heap[yy]; \ + zz = yy; \ + } \ + heap[zz] = tmp; \ +} + + +/*---------------------------------------------------*/ +void BZ2_hbMakeCodeLengths ( UChar *len, + Int32 *freq, + Int32 alphaSize, + Int32 maxLen ) +{ + /*-- + Nodes and heap entries run from 1. Entry 0 + for both the heap and nodes is a sentinel. + --*/ + Int32 nNodes, nHeap, n1, n2, i, j, k; + Bool tooLong; + + Int32 heap [ BZ_MAX_ALPHA_SIZE + 2 ]; + Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ]; + Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ]; + + for (i = 0; i < alphaSize; i++) + weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8; + + while (True) { + + nNodes = alphaSize; + nHeap = 0; + + heap[0] = 0; + weight[0] = 0; + parent[0] = -2; + + for (i = 1; i <= alphaSize; i++) { + parent[i] = -1; + nHeap++; + heap[nHeap] = i; + UPHEAP(nHeap); + } + + AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 ); + + while (nHeap > 1) { + n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1); + n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1); + nNodes++; + parent[n1] = parent[n2] = nNodes; + weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]); + parent[nNodes] = -1; + nHeap++; + heap[nHeap] = nNodes; + UPHEAP(nHeap); + } + + AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 ); + + tooLong = False; + for (i = 1; i <= alphaSize; i++) { + j = 0; + k = i; + while (parent[k] >= 0) { k = parent[k]; j++; } + len[i-1] = j; + if (j > maxLen) tooLong = True; + } + + if (! tooLong) break; + + for (i = 1; i < alphaSize; i++) { + j = weight[i] >> 8; + j = 1 + (j / 2); + weight[i] = j << 8; + } + } +} + + +/*---------------------------------------------------*/ +void BZ2_hbAssignCodes ( Int32 *code, + UChar *length, + Int32 minLen, + Int32 maxLen, + Int32 alphaSize ) +{ + Int32 n, vec, i; + + vec = 0; + for (n = minLen; n <= maxLen; n++) { + for (i = 0; i < alphaSize; i++) + if (length[i] == n) { code[i] = vec; vec++; }; + vec <<= 1; + } +} + + +/*---------------------------------------------------*/ +void BZ2_hbCreateDecodeTables ( Int32 *limit, + Int32 *base, + Int32 *perm, + UChar *length, + Int32 minLen, + Int32 maxLen, + Int32 alphaSize ) +{ + Int32 pp, i, j, vec; + + pp = 0; + for (i = minLen; i <= maxLen; i++) + for (j = 0; j < alphaSize; j++) + if (length[j] == i) { perm[pp] = j; pp++; }; + + for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0; + for (i = 0; i < alphaSize; i++) base[length[i]+1]++; + + for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1]; + + for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0; + vec = 0; + + for (i = minLen; i <= maxLen; i++) { + vec += (base[i+1] - base[i]); + limit[i] = vec-1; + vec <<= 1; + } + for (i = minLen + 1; i <= maxLen; i++) + base[i] = ((limit[i-1] + 1) << 1) - base[i]; +} + + +/*-------------------------------------------------------------*/ +/*--- end huffman.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/contrib/bzip2/libbz2.def b/contrib/bzip2/libbz2.def new file mode 100644 index 000000000000..2dc0dd891dc6 --- /dev/null +++ b/contrib/bzip2/libbz2.def @@ -0,0 +1,27 @@ +LIBRARY LIBBZ2 +DESCRIPTION "libbzip2: library for data compression" +EXPORTS + BZ2_bzCompressInit + BZ2_bzCompress + BZ2_bzCompressEnd + BZ2_bzDecompressInit + BZ2_bzDecompress + BZ2_bzDecompressEnd + BZ2_bzReadOpen + BZ2_bzReadClose + BZ2_bzReadGetUnused + BZ2_bzRead + BZ2_bzWriteOpen + BZ2_bzWrite + BZ2_bzWriteClose + BZ2_bzWriteClose64 + BZ2_bzBuffToBuffCompress + BZ2_bzBuffToBuffDecompress + BZ2_bzlibVersion + BZ2_bzopen + BZ2_bzdopen + BZ2_bzread + BZ2_bzwrite + BZ2_bzflush + BZ2_bzclose + BZ2_bzerror diff --git a/contrib/bzip2/makefile.msc b/contrib/bzip2/makefile.msc new file mode 100644 index 000000000000..3fe42324aca1 --- /dev/null +++ b/contrib/bzip2/makefile.msc @@ -0,0 +1,63 @@ +# Makefile for Microsoft Visual C++ 6.0 +# usage: nmake -f makefile.msc +# K.M. Syring (syring@gsf.de) +# Fixed up by JRS for bzip2-0.9.5d release. + +CC=cl +CFLAGS= -DWIN32 -MD -Ox -D_FILE_OFFSET_BITS=64 + +OBJS= blocksort.obj \ + huffman.obj \ + crctable.obj \ + randtable.obj \ + compress.obj \ + decompress.obj \ + bzlib.obj + +all: lib bzip2 test + +bzip2: lib + $(CC) $(CFLAGS) -o bzip2 bzip2.c libbz2.lib setargv.obj + $(CC) $(CFLAGS) -o bzip2recover bzip2recover.c + +lib: $(OBJS) + lib /out:libbz2.lib $(OBJS) + +test: bzip2 + type words1 + .\\bzip2 -1 < sample1.ref > sample1.rb2 + .\\bzip2 -2 < sample2.ref > sample2.rb2 + .\\bzip2 -3 < sample3.ref > sample3.rb2 + .\\bzip2 -d < sample1.bz2 > sample1.tst + .\\bzip2 -d < sample2.bz2 > sample2.tst + .\\bzip2 -ds < sample3.bz2 > sample3.tst + @echo All six of the fc's should find no differences. + @echo If fc finds an error on sample3.bz2, this could be + @echo because WinZip's 'TAR file smart CR/LF conversion' + @echo is too clever for its own good. Disable this option. + @echo The correct size for sample3.ref is 120,244. If it + @echo is 150,251, WinZip has messed it up. + fc sample1.bz2 sample1.rb2 + fc sample2.bz2 sample2.rb2 + fc sample3.bz2 sample3.rb2 + fc sample1.tst sample1.ref + fc sample2.tst sample2.ref + fc sample3.tst sample3.ref + + + +clean: + del *.obj + del libbz2.lib + del bzip2.exe + del bzip2recover.exe + del sample1.rb2 + del sample2.rb2 + del sample3.rb2 + del sample1.tst + del sample2.tst + del sample3.tst + +.c.obj: + $(CC) $(CFLAGS) -c $*.c -o $*.obj + diff --git a/contrib/bzip2/manual.texi b/contrib/bzip2/manual.texi new file mode 100644 index 000000000000..336776ab805a --- /dev/null +++ b/contrib/bzip2/manual.texi @@ -0,0 +1,2215 @@ +\input texinfo @c -*- Texinfo -*- +@setfilename bzip2.info + +@ignore +This file documents bzip2 version 1.0, and associated library +libbzip2, written by Julian Seward (jseward@acm.org). + +Copyright (C) 1996-2000 Julian R Seward + +Permission is granted to make and distribute verbatim copies of +this manual provided the copyright notice and this permission notice +are preserved on all copies. + +Permission is granted to copy and distribute translations of this manual +into another language, under the above conditions for verbatim copies. +@end ignore + +@ifinfo +@format +START-INFO-DIR-ENTRY +* Bzip2: (bzip2). A program and library for data compression. +END-INFO-DIR-ENTRY +@end format + +@end ifinfo + +@iftex +@c @finalout +@settitle bzip2 and libbzip2 +@titlepage +@title bzip2 and libbzip2 +@subtitle a program and library for data compression +@subtitle copyright (C) 1996-2000 Julian Seward +@subtitle version 1.0 of 21 March 2000 +@author Julian Seward + +@end titlepage + +@parindent 0mm +@parskip 2mm + +@end iftex +@node Top, Overview, (dir), (dir) + +This program, @code{bzip2}, +and associated library @code{libbzip2}, are +Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +@itemize @bullet +@item + Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +@item + The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. +@item + Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. +@item + The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. +@end itemize +THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS +OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE +GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Julian Seward, Cambridge, UK. + +@code{jseward@@acm.org} + +@code{http://sourceware.cygnus.com/bzip2} + +@code{http://www.cacheprof.org} + +@code{http://www.muraroa.demon.co.uk} + +@code{bzip2}/@code{libbzip2} version 1.0 of 21 March 2000. + +PATENTS: To the best of my knowledge, @code{bzip2} does not use any patented +algorithms. However, I do not have the resources available to carry out +a full patent search. Therefore I cannot give any guarantee of the +above statement. + + + + + + + +@node Overview, Implementation, Top, Top +@chapter Introduction + +@code{bzip2} compresses files using the Burrows-Wheeler +block-sorting text compression algorithm, and Huffman coding. +Compression is generally considerably better than that +achieved by more conventional LZ77/LZ78-based compressors, +and approaches the performance of the PPM family of statistical compressors. + +@code{bzip2} is built on top of @code{libbzip2}, a flexible library +for handling compressed data in the @code{bzip2} format. This manual +describes both how to use the program and +how to work with the library interface. Most of the +manual is devoted to this library, not the program, +which is good news if your interest is only in the program. + +Chapter 2 describes how to use @code{bzip2}; this is the only part +you need to read if you just want to know how to operate the program. +Chapter 3 describes the programming interfaces in detail, and +Chapter 4 records some miscellaneous notes which I thought +ought to be recorded somewhere. + + +@chapter How to use @code{bzip2} + +This chapter contains a copy of the @code{bzip2} man page, +and nothing else. + +@quotation + +@unnumberedsubsubsec NAME +@itemize +@item @code{bzip2}, @code{bunzip2} +- a block-sorting file compressor, v1.0 +@item @code{bzcat} +- decompresses files to stdout +@item @code{bzip2recover} +- recovers data from damaged bzip2 files +@end itemize + +@unnumberedsubsubsec SYNOPSIS +@itemize +@item @code{bzip2} [ -cdfkqstvzVL123456789 ] [ filenames ... ] +@item @code{bunzip2} [ -fkvsVL ] [ filenames ... ] +@item @code{bzcat} [ -s ] [ filenames ... ] +@item @code{bzip2recover} filename +@end itemize + +@unnumberedsubsubsec DESCRIPTION + +@code{bzip2} compresses files using the Burrows-Wheeler block sorting +text compression algorithm, and Huffman coding. Compression is +generally considerably better than that achieved by more conventional +LZ77/LZ78-based compressors, and approaches the performance of the PPM +family of statistical compressors. + +The command-line options are deliberately very similar to those of GNU +@code{gzip}, but they are not identical. + +@code{bzip2} expects a list of file names to accompany the command-line +flags. Each file is replaced by a compressed version of itself, with +the name @code{original_name.bz2}. Each compressed file has the same +modification date, permissions, and, when possible, ownership as the +corresponding original, so that these properties can be correctly +restored at decompression time. File name handling is naive in the +sense that there is no mechanism for preserving original file names, +permissions, ownerships or dates in filesystems which lack these +concepts, or have serious file name length restrictions, such as MS-DOS. + +@code{bzip2} and @code{bunzip2} will by default not overwrite existing +files. If you want this to happen, specify the @code{-f} flag. + +If no file names are specified, @code{bzip2} compresses from standard +input to standard output. In this case, @code{bzip2} will decline to +write compressed output to a terminal, as this would be entirely +incomprehensible and therefore pointless. + +@code{bunzip2} (or @code{bzip2 -d}) decompresses all +specified files. Files which were not created by @code{bzip2} +will be detected and ignored, and a warning issued. +@code{bzip2} attempts to guess the filename for the decompressed file +from that of the compressed file as follows: +@itemize +@item @code{filename.bz2 } becomes @code{filename} +@item @code{filename.bz } becomes @code{filename} +@item @code{filename.tbz2} becomes @code{filename.tar} +@item @code{filename.tbz } becomes @code{filename.tar} +@item @code{anyothername } becomes @code{anyothername.out} +@end itemize +If the file does not end in one of the recognised endings, +@code{.bz2}, @code{.bz}, +@code{.tbz2} or @code{.tbz}, @code{bzip2} complains that it cannot +guess the name of the original file, and uses the original name +with @code{.out} appended. + +As with compression, supplying no +filenames causes decompression from standard input to standard output. + +@code{bunzip2} will correctly decompress a file which is the +concatenation of two or more compressed files. The result is the +concatenation of the corresponding uncompressed files. Integrity +testing (@code{-t}) of concatenated compressed files is also supported. + +You can also compress or decompress files to the standard output by +giving the @code{-c} flag. Multiple files may be compressed and +decompressed like this. The resulting outputs are fed sequentially to +stdout. Compression of multiple files in this manner generates a stream +containing multiple compressed file representations. Such a stream +can be decompressed correctly only by @code{bzip2} version 0.9.0 or +later. Earlier versions of @code{bzip2} will stop after decompressing +the first file in the stream. + +@code{bzcat} (or @code{bzip2 -dc}) decompresses all specified files to +the standard output. + +@code{bzip2} will read arguments from the environment variables +@code{BZIP2} and @code{BZIP}, in that order, and will process them +before any arguments read from the command line. This gives a +convenient way to supply default arguments. + +Compression is always performed, even if the compressed file is slightly +larger than the original. Files of less than about one hundred bytes +tend to get larger, since the compression mechanism has a constant +overhead in the region of 50 bytes. Random data (including the output +of most file compressors) is coded at about 8.05 bits per byte, giving +an expansion of around 0.5%. + +As a self-check for your protection, @code{bzip2} uses 32-bit CRCs to +make sure that the decompressed version of a file is identical to the +original. This guards against corruption of the compressed data, and +against undetected bugs in @code{bzip2} (hopefully very unlikely). The +chances of data corruption going undetected is microscopic, about one +chance in four billion for each file processed. Be aware, though, that +the check occurs upon decompression, so it can only tell you that +something is wrong. It can't help you recover the original uncompressed +data. You can use @code{bzip2recover} to try to recover data from +damaged files. + +Return values: 0 for a normal exit, 1 for environmental problems (file +not found, invalid flags, I/O errors, &c), 2 to indicate a corrupt +compressed file, 3 for an internal consistency error (eg, bug) which +caused @code{bzip2} to panic. + + +@unnumberedsubsubsec OPTIONS +@table @code +@item -c --stdout +Compress or decompress to standard output. +@item -d --decompress +Force decompression. @code{bzip2}, @code{bunzip2} and @code{bzcat} are +really the same program, and the decision about what actions to take is +done on the basis of which name is used. This flag overrides that +mechanism, and forces bzip2 to decompress. +@item -z --compress +The complement to @code{-d}: forces compression, regardless of the +invokation name. +@item -t --test +Check integrity of the specified file(s), but don't decompress them. +This really performs a trial decompression and throws away the result. +@item -f --force +Force overwrite of output files. Normally, @code{bzip2} will not overwrite +existing output files. Also forces @code{bzip2} to break hard links +to files, which it otherwise wouldn't do. +@item -k --keep +Keep (don't delete) input files during compression +or decompression. +@item -s --small +Reduce memory usage, for compression, decompression and testing. Files +are decompressed and tested using a modified algorithm which only +requires 2.5 bytes per block byte. This means any file can be +decompressed in 2300k of memory, albeit at about half the normal speed. + +During compression, @code{-s} selects a block size of 200k, which limits +memory use to around the same figure, at the expense of your compression +ratio. In short, if your machine is low on memory (8 megabytes or +less), use -s for everything. See MEMORY MANAGEMENT below. +@item -q --quiet +Suppress non-essential warning messages. Messages pertaining to +I/O errors and other critical events will not be suppressed. +@item -v --verbose +Verbose mode -- show the compression ratio for each file processed. +Further @code{-v}'s increase the verbosity level, spewing out lots of +information which is primarily of interest for diagnostic purposes. +@item -L --license -V --version +Display the software version, license terms and conditions. +@item -1 to -9 +Set the block size to 100 k, 200 k .. 900 k when compressing. Has no +effect when decompressing. See MEMORY MANAGEMENT below. +@item -- +Treats all subsequent arguments as file names, even if they start +with a dash. This is so you can handle files with names beginning +with a dash, for example: @code{bzip2 -- -myfilename}. +@item --repetitive-fast +@item --repetitive-best +These flags are redundant in versions 0.9.5 and above. They provided +some coarse control over the behaviour of the sorting algorithm in +earlier versions, which was sometimes useful. 0.9.5 and above have an +improved algorithm which renders these flags irrelevant. +@end table + + +@unnumberedsubsubsec MEMORY MANAGEMENT + +@code{bzip2} compresses large files in blocks. The block size affects +both the compression ratio achieved, and the amount of memory needed for +compression and decompression. The flags @code{-1} through @code{-9} +specify the block size to be 100,000 bytes through 900,000 bytes (the +default) respectively. At decompression time, the block size used for +compression is read from the header of the compressed file, and +@code{bunzip2} then allocates itself just enough memory to decompress +the file. Since block sizes are stored in compressed files, it follows +that the flags @code{-1} to @code{-9} are irrelevant to and so ignored +during decompression. + +Compression and decompression requirements, in bytes, can be estimated +as: +@example + Compression: 400k + ( 8 x block size ) + + Decompression: 100k + ( 4 x block size ), or + 100k + ( 2.5 x block size ) +@end example +Larger block sizes give rapidly diminishing marginal returns. Most of +the compression comes from the first two or three hundred k of block +size, a fact worth bearing in mind when using @code{bzip2} on small machines. +It is also important to appreciate that the decompression memory +requirement is set at compression time by the choice of block size. + +For files compressed with the default 900k block size, @code{bunzip2} +will require about 3700 kbytes to decompress. To support decompression +of any file on a 4 megabyte machine, @code{bunzip2} has an option to +decompress using approximately half this amount of memory, about 2300 +kbytes. Decompression speed is also halved, so you should use this +option only where necessary. The relevant flag is @code{-s}. + +In general, try and use the largest block size memory constraints allow, +since that maximises the compression achieved. Compression and +decompression speed are virtually unaffected by block size. + +Another significant point applies to files which fit in a single block +-- that means most files you'd encounter using a large block size. The +amount of real memory touched is proportional to the size of the file, +since the file is smaller than a block. For example, compressing a file +20,000 bytes long with the flag @code{-9} will cause the compressor to +allocate around 7600k of memory, but only touch 400k + 20000 * 8 = 560 +kbytes of it. Similarly, the decompressor will allocate 3700k but only +touch 100k + 20000 * 4 = 180 kbytes. + +Here is a table which summarises the maximum memory usage for different +block sizes. Also recorded is the total compressed size for 14 files of +the Calgary Text Compression Corpus totalling 3,141,622 bytes. This +column gives some feel for how compression varies with block size. +These figures tend to understate the advantage of larger block sizes for +larger files, since the Corpus is dominated by smaller files. +@example + Compress Decompress Decompress Corpus + Flag usage usage -s usage Size + + -1 1200k 500k 350k 914704 + -2 2000k 900k 600k 877703 + -3 2800k 1300k 850k 860338 + -4 3600k 1700k 1100k 846899 + -5 4400k 2100k 1350k 845160 + -6 5200k 2500k 1600k 838626 + -7 6100k 2900k 1850k 834096 + -8 6800k 3300k 2100k 828642 + -9 7600k 3700k 2350k 828642 +@end example + +@unnumberedsubsubsec RECOVERING DATA FROM DAMAGED FILES + +@code{bzip2} compresses files in blocks, usually 900kbytes long. Each +block is handled independently. If a media or transmission error causes +a multi-block @code{.bz2} file to become damaged, it may be possible to +recover data from the undamaged blocks in the file. + +The compressed representation of each block is delimited by a 48-bit +pattern, which makes it possible to find the block boundaries with +reasonable certainty. Each block also carries its own 32-bit CRC, so +damaged blocks can be distinguished from undamaged ones. + +@code{bzip2recover} is a simple program whose purpose is to search for +blocks in @code{.bz2} files, and write each block out into its own +@code{.bz2} file. You can then use @code{bzip2 -t} to test the +integrity of the resulting files, and decompress those which are +undamaged. + +@code{bzip2recover} +takes a single argument, the name of the damaged file, +and writes a number of files @code{rec0001file.bz2}, + @code{rec0002file.bz2}, etc, containing the extracted blocks. + The output filenames are designed so that the use of + wildcards in subsequent processing -- for example, +@code{bzip2 -dc rec*file.bz2 > recovered_data} -- lists the files in + the correct order. + +@code{bzip2recover} should be of most use dealing with large @code{.bz2} + files, as these will contain many blocks. It is clearly + futile to use it on damaged single-block files, since a + damaged block cannot be recovered. If you wish to minimise +any potential data loss through media or transmission errors, +you might consider compressing with a smaller + block size. + + +@unnumberedsubsubsec PERFORMANCE NOTES + +The sorting phase of compression gathers together similar strings in the +file. Because of this, files containing very long runs of repeated +symbols, like "aabaabaabaab ..." (repeated several hundred times) may +compress more slowly than normal. Versions 0.9.5 and above fare much +better than previous versions in this respect. The ratio between +worst-case and average-case compression time is in the region of 10:1. +For previous versions, this figure was more like 100:1. You can use the +@code{-vvvv} option to monitor progress in great detail, if you want. + +Decompression speed is unaffected by these phenomena. + +@code{bzip2} usually allocates several megabytes of memory to operate +in, and then charges all over it in a fairly random fashion. This means +that performance, both for compressing and decompressing, is largely +determined by the speed at which your machine can service cache misses. +Because of this, small changes to the code to reduce the miss rate have +been observed to give disproportionately large performance improvements. +I imagine @code{bzip2} will perform best on machines with very large +caches. + + +@unnumberedsubsubsec CAVEATS + +I/O error messages are not as helpful as they could be. @code{bzip2} +tries hard to detect I/O errors and exit cleanly, but the details of +what the problem is sometimes seem rather misleading. + +This manual page pertains to version 1.0 of @code{bzip2}. Compressed +data created by this version is entirely forwards and backwards +compatible with the previous public releases, versions 0.1pl2, 0.9.0 and +0.9.5, but with the following exception: 0.9.0 and above can correctly +decompress multiple concatenated compressed files. 0.1pl2 cannot do +this; it will stop after decompressing just the first file in the +stream. + +@code{bzip2recover} uses 32-bit integers to represent bit positions in +compressed files, so it cannot handle compressed files more than 512 +megabytes long. This could easily be fixed. + + +@unnumberedsubsubsec AUTHOR +Julian Seward, @code{jseward@@acm.org}. + +The ideas embodied in @code{bzip2} are due to (at least) the following +people: Michael Burrows and David Wheeler (for the block sorting +transformation), David Wheeler (again, for the Huffman coder), Peter +Fenwick (for the structured coding model in the original @code{bzip}, +and many refinements), and Alistair Moffat, Radford Neal and Ian Witten +(for the arithmetic coder in the original @code{bzip}). I am much +indebted for their help, support and advice. See the manual in the +source distribution for pointers to sources of documentation. Christian +von Roques encouraged me to look for faster sorting algorithms, so as to +speed up compression. Bela Lubkin encouraged me to improve the +worst-case compression performance. Many people sent patches, helped +with portability problems, lent machines, gave advice and were generally +helpful. + +@end quotation + + + + +@chapter Programming with @code{libbzip2} + +This chapter describes the programming interface to @code{libbzip2}. + +For general background information, particularly about memory +use and performance aspects, you'd be well advised to read Chapter 2 +as well. + +@section Top-level structure + +@code{libbzip2} is a flexible library for compressing and decompressing +data in the @code{bzip2} data format. Although packaged as a single +entity, it helps to regard the library as three separate parts: the low +level interface, and the high level interface, and some utility +functions. + +The structure of @code{libbzip2}'s interfaces is similar to +that of Jean-loup Gailly's and Mark Adler's excellent @code{zlib} +library. + +All externally visible symbols have names beginning @code{BZ2_}. +This is new in version 1.0. The intention is to minimise pollution +of the namespaces of library clients. + +@subsection Low-level summary + +This interface provides services for compressing and decompressing +data in memory. There's no provision for dealing with files, streams +or any other I/O mechanisms, just straight memory-to-memory work. +In fact, this part of the library can be compiled without inclusion +of @code{stdio.h}, which may be helpful for embedded applications. + +The low-level part of the library has no global variables and +is therefore thread-safe. + +Six routines make up the low level interface: +@code{BZ2_bzCompressInit}, @code{BZ2_bzCompress}, and @* @code{BZ2_bzCompressEnd} +for compression, +and a corresponding trio @code{BZ2_bzDecompressInit}, @* @code{BZ2_bzDecompress} +and @code{BZ2_bzDecompressEnd} for decompression. +The @code{*Init} functions allocate +memory for compression/decompression and do other +initialisations, whilst the @code{*End} functions close down operations +and release memory. + +The real work is done by @code{BZ2_bzCompress} and @code{BZ2_bzDecompress}. +These compress and decompress data from a user-supplied input buffer +to a user-supplied output buffer. These buffers can be any size; +arbitrary quantities of data are handled by making repeated calls +to these functions. This is a flexible mechanism allowing a +consumer-pull style of activity, or producer-push, or a mixture of +both. + + + +@subsection High-level summary + +This interface provides some handy wrappers around the low-level +interface to facilitate reading and writing @code{bzip2} format +files (@code{.bz2} files). The routines provide hooks to facilitate +reading files in which the @code{bzip2} data stream is embedded +within some larger-scale file structure, or where there are +multiple @code{bzip2} data streams concatenated end-to-end. + +For reading files, @code{BZ2_bzReadOpen}, @code{BZ2_bzRead}, +@code{BZ2_bzReadClose} and @* @code{BZ2_bzReadGetUnused} are supplied. For +writing files, @code{BZ2_bzWriteOpen}, @code{BZ2_bzWrite} and +@code{BZ2_bzWriteFinish} are available. + +As with the low-level library, no global variables are used +so the library is per se thread-safe. However, if I/O errors +occur whilst reading or writing the underlying compressed files, +you may have to consult @code{errno} to determine the cause of +the error. In that case, you'd need a C library which correctly +supports @code{errno} in a multithreaded environment. + +To make the library a little simpler and more portable, +@code{BZ2_bzReadOpen} and @code{BZ2_bzWriteOpen} require you to pass them file +handles (@code{FILE*}s) which have previously been opened for reading or +writing respectively. That avoids portability problems associated with +file operations and file attributes, whilst not being much of an +imposition on the programmer. + + + +@subsection Utility functions summary +For very simple needs, @code{BZ2_bzBuffToBuffCompress} and +@code{BZ2_bzBuffToBuffDecompress} are provided. These compress +data in memory from one buffer to another buffer in a single +function call. You should assess whether these functions +fulfill your memory-to-memory compression/decompression +requirements before investing effort in understanding the more +general but more complex low-level interface. + +Yoshioka Tsuneo (@code{QWF00133@@niftyserve.or.jp} / +@code{tsuneo-y@@is.aist-nara.ac.jp}) has contributed some functions to +give better @code{zlib} compatibility. These functions are +@code{BZ2_bzopen}, @code{BZ2_bzread}, @code{BZ2_bzwrite}, @code{BZ2_bzflush}, +@code{BZ2_bzclose}, +@code{BZ2_bzerror} and @code{BZ2_bzlibVersion}. You may find these functions +more convenient for simple file reading and writing, than those in the +high-level interface. These functions are not (yet) officially part of +the library, and are minimally documented here. If they break, you +get to keep all the pieces. I hope to document them properly when time +permits. + +Yoshioka also contributed modifications to allow the library to be +built as a Windows DLL. + + +@section Error handling + +The library is designed to recover cleanly in all situations, including +the worst-case situation of decompressing random data. I'm not +100% sure that it can always do this, so you might want to add +a signal handler to catch segmentation violations during decompression +if you are feeling especially paranoid. I would be interested in +hearing more about the robustness of the library to corrupted +compressed data. + +Version 1.0 is much more robust in this respect than +0.9.0 or 0.9.5. Investigations with Checker (a tool for +detecting problems with memory management, similar to Purify) +indicate that, at least for the few files I tested, all single-bit +errors in the decompressed data are caught properly, with no +segmentation faults, no reads of uninitialised data and no +out of range reads or writes. So it's certainly much improved, +although I wouldn't claim it to be totally bombproof. + +The file @code{bzlib.h} contains all definitions needed to use +the library. In particular, you should definitely not include +@code{bzlib_private.h}. + +In @code{bzlib.h}, the various return values are defined. The following +list is not intended as an exhaustive description of the circumstances +in which a given value may be returned -- those descriptions are given +later. Rather, it is intended to convey the rough meaning of each +return value. The first five actions are normal and not intended to +denote an error situation. +@table @code +@item BZ_OK +The requested action was completed successfully. +@item BZ_RUN_OK +@itemx BZ_FLUSH_OK +@itemx BZ_FINISH_OK +In @code{BZ2_bzCompress}, the requested flush/finish/nothing-special action +was completed successfully. +@item BZ_STREAM_END +Compression of data was completed, or the logical stream end was +detected during decompression. +@end table + +The following return values indicate an error of some kind. +@table @code +@item BZ_CONFIG_ERROR +Indicates that the library has been improperly compiled on your +platform -- a major configuration error. Specifically, it means +that @code{sizeof(char)}, @code{sizeof(short)} and @code{sizeof(int)} +are not 1, 2 and 4 respectively, as they should be. Note that the +library should still work properly on 64-bit platforms which follow +the LP64 programming model -- that is, where @code{sizeof(long)} +and @code{sizeof(void*)} are 8. Under LP64, @code{sizeof(int)} is +still 4, so @code{libbzip2}, which doesn't use the @code{long} type, +is OK. +@item BZ_SEQUENCE_ERROR +When using the library, it is important to call the functions in the +correct sequence and with data structures (buffers etc) in the correct +states. @code{libbzip2} checks as much as it can to ensure this is +happening, and returns @code{BZ_SEQUENCE_ERROR} if not. Code which +complies precisely with the function semantics, as detailed below, +should never receive this value; such an event denotes buggy code +which you should investigate. +@item BZ_PARAM_ERROR +Returned when a parameter to a function call is out of range +or otherwise manifestly incorrect. As with @code{BZ_SEQUENCE_ERROR}, +this denotes a bug in the client code. The distinction between +@code{BZ_PARAM_ERROR} and @code{BZ_SEQUENCE_ERROR} is a bit hazy, but still worth +making. +@item BZ_MEM_ERROR +Returned when a request to allocate memory failed. Note that the +quantity of memory needed to decompress a stream cannot be determined +until the stream's header has been read. So @code{BZ2_bzDecompress} and +@code{BZ2_bzRead} may return @code{BZ_MEM_ERROR} even though some of +the compressed data has been read. The same is not true for +compression; once @code{BZ2_bzCompressInit} or @code{BZ2_bzWriteOpen} have +successfully completed, @code{BZ_MEM_ERROR} cannot occur. +@item BZ_DATA_ERROR +Returned when a data integrity error is detected during decompression. +Most importantly, this means when stored and computed CRCs for the +data do not match. This value is also returned upon detection of any +other anomaly in the compressed data. +@item BZ_DATA_ERROR_MAGIC +As a special case of @code{BZ_DATA_ERROR}, it is sometimes useful to +know when the compressed stream does not start with the correct +magic bytes (@code{'B' 'Z' 'h'}). +@item BZ_IO_ERROR +Returned by @code{BZ2_bzRead} and @code{BZ2_bzWrite} when there is an error +reading or writing in the compressed file, and by @code{BZ2_bzReadOpen} +and @code{BZ2_bzWriteOpen} for attempts to use a file for which the +error indicator (viz, @code{ferror(f)}) is set. +On receipt of @code{BZ_IO_ERROR}, the caller should consult +@code{errno} and/or @code{perror} to acquire operating-system +specific information about the problem. +@item BZ_UNEXPECTED_EOF +Returned by @code{BZ2_bzRead} when the compressed file finishes +before the logical end of stream is detected. +@item BZ_OUTBUFF_FULL +Returned by @code{BZ2_bzBuffToBuffCompress} and +@code{BZ2_bzBuffToBuffDecompress} to indicate that the output data +will not fit into the output buffer provided. +@end table + + + +@section Low-level interface + +@subsection @code{BZ2_bzCompressInit} +@example +typedef + struct @{ + char *next_in; + unsigned int avail_in; + unsigned int total_in_lo32; + unsigned int total_in_hi32; + + char *next_out; + unsigned int avail_out; + unsigned int total_out_lo32; + unsigned int total_out_hi32; + + void *state; + + void *(*bzalloc)(void *,int,int); + void (*bzfree)(void *,void *); + void *opaque; + @} + bz_stream; + +int BZ2_bzCompressInit ( bz_stream *strm, + int blockSize100k, + int verbosity, + int workFactor ); + +@end example + +Prepares for compression. The @code{bz_stream} structure +holds all data pertaining to the compression activity. +A @code{bz_stream} structure should be allocated and initialised +prior to the call. +The fields of @code{bz_stream} +comprise the entirety of the user-visible data. @code{state} +is a pointer to the private data structures required for compression. + +Custom memory allocators are supported, via fields @code{bzalloc}, +@code{bzfree}, +and @code{opaque}. The value +@code{opaque} is passed to as the first argument to +all calls to @code{bzalloc} and @code{bzfree}, but is +otherwise ignored by the library. +The call @code{bzalloc ( opaque, n, m )} is expected to return a +pointer @code{p} to +@code{n * m} bytes of memory, and @code{bzfree ( opaque, p )} +should free +that memory. + +If you don't want to use a custom memory allocator, set @code{bzalloc}, +@code{bzfree} and +@code{opaque} to @code{NULL}, +and the library will then use the standard @code{malloc}/@code{free} +routines. + +Before calling @code{BZ2_bzCompressInit}, fields @code{bzalloc}, +@code{bzfree} and @code{opaque} should +be filled appropriately, as just described. Upon return, the internal +state will have been allocated and initialised, and @code{total_in_lo32}, +@code{total_in_hi32}, @code{total_out_lo32} and +@code{total_out_hi32} will have been set to zero. +These four fields are used by the library +to inform the caller of the total amount of data passed into and out of +the library, respectively. You should not try to change them. +As of version 1.0, 64-bit counts are maintained, even on 32-bit +platforms, using the @code{_hi32} fields to store the upper 32 bits +of the count. So, for example, the total amount of data in +is @code{(total_in_hi32 << 32) + total_in_lo32}. + +Parameter @code{blockSize100k} specifies the block size to be used for +compression. It should be a value between 1 and 9 inclusive, and the +actual block size used is 100000 x this figure. 9 gives the best +compression but takes most memory. + +Parameter @code{verbosity} should be set to a number between 0 and 4 +inclusive. 0 is silent, and greater numbers give increasingly verbose +monitoring/debugging output. If the library has been compiled with +@code{-DBZ_NO_STDIO}, no such output will appear for any verbosity +setting. + +Parameter @code{workFactor} controls how the compression phase behaves +when presented with worst case, highly repetitive, input data. If +compression runs into difficulties caused by repetitive data, the +library switches from the standard sorting algorithm to a fallback +algorithm. The fallback is slower than the standard algorithm by +perhaps a factor of three, but always behaves reasonably, no matter how +bad the input. + +Lower values of @code{workFactor} reduce the amount of effort the +standard algorithm will expend before resorting to the fallback. You +should set this parameter carefully; too low, and many inputs will be +handled by the fallback algorithm and so compress rather slowly, too +high, and your average-to-worst case compression times can become very +large. The default value of 30 gives reasonable behaviour over a wide +range of circumstances. + +Allowable values range from 0 to 250 inclusive. 0 is a special case, +equivalent to using the default value of 30. + +Note that the compressed output generated is the same regardless of +whether or not the fallback algorithm is used. + +Be aware also that this parameter may disappear entirely in future +versions of the library. In principle it should be possible to devise a +good way to automatically choose which algorithm to use. Such a +mechanism would render the parameter obsolete. + +Possible return values: +@display + @code{BZ_CONFIG_ERROR} + if the library has been mis-compiled + @code{BZ_PARAM_ERROR} + if @code{strm} is @code{NULL} + or @code{blockSize} < 1 or @code{blockSize} > 9 + or @code{verbosity} < 0 or @code{verbosity} > 4 + or @code{workFactor} < 0 or @code{workFactor} > 250 + @code{BZ_MEM_ERROR} + if not enough memory is available + @code{BZ_OK} + otherwise +@end display +Allowable next actions: +@display + @code{BZ2_bzCompress} + if @code{BZ_OK} is returned + no specific action needed in case of error +@end display + +@subsection @code{BZ2_bzCompress} +@example + int BZ2_bzCompress ( bz_stream *strm, int action ); +@end example +Provides more input and/or output buffer space for the library. The +caller maintains input and output buffers, and calls @code{BZ2_bzCompress} to +transfer data between them. + +Before each call to @code{BZ2_bzCompress}, @code{next_in} should point at +the data to be compressed, and @code{avail_in} should indicate how many +bytes the library may read. @code{BZ2_bzCompress} updates @code{next_in}, +@code{avail_in} and @code{total_in} to reflect the number of bytes it +has read. + +Similarly, @code{next_out} should point to a buffer in which the +compressed data is to be placed, with @code{avail_out} indicating how +much output space is available. @code{BZ2_bzCompress} updates +@code{next_out}, @code{avail_out} and @code{total_out} to reflect the +number of bytes output. + +You may provide and remove as little or as much data as you like on each +call of @code{BZ2_bzCompress}. In the limit, it is acceptable to supply and +remove data one byte at a time, although this would be terribly +inefficient. You should always ensure that at least one byte of output +space is available at each call. + +A second purpose of @code{BZ2_bzCompress} is to request a change of mode of the +compressed stream. + +Conceptually, a compressed stream can be in one of four states: IDLE, +RUNNING, FLUSHING and FINISHING. Before initialisation +(@code{BZ2_bzCompressInit}) and after termination (@code{BZ2_bzCompressEnd}), a +stream is regarded as IDLE. + +Upon initialisation (@code{BZ2_bzCompressInit}), the stream is placed in the +RUNNING state. Subsequent calls to @code{BZ2_bzCompress} should pass +@code{BZ_RUN} as the requested action; other actions are illegal and +will result in @code{BZ_SEQUENCE_ERROR}. + +At some point, the calling program will have provided all the input data +it wants to. It will then want to finish up -- in effect, asking the +library to process any data it might have buffered internally. In this +state, @code{BZ2_bzCompress} will no longer attempt to read data from +@code{next_in}, but it will want to write data to @code{next_out}. +Because the output buffer supplied by the user can be arbitrarily small, +the finishing-up operation cannot necessarily be done with a single call +of @code{BZ2_bzCompress}. + +Instead, the calling program passes @code{BZ_FINISH} as an action to +@code{BZ2_bzCompress}. This changes the stream's state to FINISHING. Any +remaining input (ie, @code{next_in[0 .. avail_in-1]}) is compressed and +transferred to the output buffer. To do this, @code{BZ2_bzCompress} must be +called repeatedly until all the output has been consumed. At that +point, @code{BZ2_bzCompress} returns @code{BZ_STREAM_END}, and the stream's +state is set back to IDLE. @code{BZ2_bzCompressEnd} should then be +called. + +Just to make sure the calling program does not cheat, the library makes +a note of @code{avail_in} at the time of the first call to +@code{BZ2_bzCompress} which has @code{BZ_FINISH} as an action (ie, at the +time the program has announced its intention to not supply any more +input). By comparing this value with that of @code{avail_in} over +subsequent calls to @code{BZ2_bzCompress}, the library can detect any +attempts to slip in more data to compress. Any calls for which this is +detected will return @code{BZ_SEQUENCE_ERROR}. This indicates a +programming mistake which should be corrected. + +Instead of asking to finish, the calling program may ask +@code{BZ2_bzCompress} to take all the remaining input, compress it and +terminate the current (Burrows-Wheeler) compression block. This could +be useful for error control purposes. The mechanism is analogous to +that for finishing: call @code{BZ2_bzCompress} with an action of +@code{BZ_FLUSH}, remove output data, and persist with the +@code{BZ_FLUSH} action until the value @code{BZ_RUN} is returned. As +with finishing, @code{BZ2_bzCompress} detects any attempt to provide more +input data once the flush has begun. + +Once the flush is complete, the stream returns to the normal RUNNING +state. + +This all sounds pretty complex, but isn't really. Here's a table +which shows which actions are allowable in each state, what action +will be taken, what the next state is, and what the non-error return +values are. Note that you can't explicitly ask what state the +stream is in, but nor do you need to -- it can be inferred from the +values returned by @code{BZ2_bzCompress}. +@display +IDLE/@code{any} + Illegal. IDLE state only exists after @code{BZ2_bzCompressEnd} or + before @code{BZ2_bzCompressInit}. + Return value = @code{BZ_SEQUENCE_ERROR} + +RUNNING/@code{BZ_RUN} + Compress from @code{next_in} to @code{next_out} as much as possible. + Next state = RUNNING + Return value = @code{BZ_RUN_OK} + +RUNNING/@code{BZ_FLUSH} + Remember current value of @code{next_in}. Compress from @code{next_in} + to @code{next_out} as much as possible, but do not accept any more input. + Next state = FLUSHING + Return value = @code{BZ_FLUSH_OK} + +RUNNING/@code{BZ_FINISH} + Remember current value of @code{next_in}. Compress from @code{next_in} + to @code{next_out} as much as possible, but do not accept any more input. + Next state = FINISHING + Return value = @code{BZ_FINISH_OK} + +FLUSHING/@code{BZ_FLUSH} + Compress from @code{next_in} to @code{next_out} as much as possible, + but do not accept any more input. + If all the existing input has been used up and all compressed + output has been removed + Next state = RUNNING; Return value = @code{BZ_RUN_OK} + else + Next state = FLUSHING; Return value = @code{BZ_FLUSH_OK} + +FLUSHING/other + Illegal. + Return value = @code{BZ_SEQUENCE_ERROR} + +FINISHING/@code{BZ_FINISH} + Compress from @code{next_in} to @code{next_out} as much as possible, + but to not accept any more input. + If all the existing input has been used up and all compressed + output has been removed + Next state = IDLE; Return value = @code{BZ_STREAM_END} + else + Next state = FINISHING; Return value = @code{BZ_FINISHING} + +FINISHING/other + Illegal. + Return value = @code{BZ_SEQUENCE_ERROR} +@end display + +That still looks complicated? Well, fair enough. The usual sequence +of calls for compressing a load of data is: +@itemize @bullet +@item Get started with @code{BZ2_bzCompressInit}. +@item Shovel data in and shlurp out its compressed form using zero or more +calls of @code{BZ2_bzCompress} with action = @code{BZ_RUN}. +@item Finish up. +Repeatedly call @code{BZ2_bzCompress} with action = @code{BZ_FINISH}, +copying out the compressed output, until @code{BZ_STREAM_END} is returned. +@item Close up and go home. Call @code{BZ2_bzCompressEnd}. +@end itemize +If the data you want to compress fits into your input buffer all +at once, you can skip the calls of @code{BZ2_bzCompress ( ..., BZ_RUN )} and +just do the @code{BZ2_bzCompress ( ..., BZ_FINISH )} calls. + +All required memory is allocated by @code{BZ2_bzCompressInit}. The +compression library can accept any data at all (obviously). So you +shouldn't get any error return values from the @code{BZ2_bzCompress} calls. +If you do, they will be @code{BZ_SEQUENCE_ERROR}, and indicate a bug in +your programming. + +Trivial other possible return values: +@display + @code{BZ_PARAM_ERROR} + if @code{strm} is @code{NULL}, or @code{strm->s} is @code{NULL} +@end display + +@subsection @code{BZ2_bzCompressEnd} +@example +int BZ2_bzCompressEnd ( bz_stream *strm ); +@end example +Releases all memory associated with a compression stream. + +Possible return values: +@display + @code{BZ_PARAM_ERROR} if @code{strm} is @code{NULL} or @code{strm->s} is @code{NULL} + @code{BZ_OK} otherwise +@end display + + +@subsection @code{BZ2_bzDecompressInit} +@example +int BZ2_bzDecompressInit ( bz_stream *strm, int verbosity, int small ); +@end example +Prepares for decompression. As with @code{BZ2_bzCompressInit}, a +@code{bz_stream} record should be allocated and initialised before the +call. Fields @code{bzalloc}, @code{bzfree} and @code{opaque} should be +set if a custom memory allocator is required, or made @code{NULL} for +the normal @code{malloc}/@code{free} routines. Upon return, the internal +state will have been initialised, and @code{total_in} and +@code{total_out} will be zero. + +For the meaning of parameter @code{verbosity}, see @code{BZ2_bzCompressInit}. + +If @code{small} is nonzero, the library will use an alternative +decompression algorithm which uses less memory but at the cost of +decompressing more slowly (roughly speaking, half the speed, but the +maximum memory requirement drops to around 2300k). See Chapter 2 for +more information on memory management. + +Note that the amount of memory needed to decompress +a stream cannot be determined until the stream's header has been read, +so even if @code{BZ2_bzDecompressInit} succeeds, a subsequent +@code{BZ2_bzDecompress} could fail with @code{BZ_MEM_ERROR}. + +Possible return values: +@display + @code{BZ_CONFIG_ERROR} + if the library has been mis-compiled + @code{BZ_PARAM_ERROR} + if @code{(small != 0 && small != 1)} + or @code{(verbosity < 0 || verbosity > 4)} + @code{BZ_MEM_ERROR} + if insufficient memory is available +@end display + +Allowable next actions: +@display + @code{BZ2_bzDecompress} + if @code{BZ_OK} was returned + no specific action required in case of error +@end display + + + +@subsection @code{BZ2_bzDecompress} +@example +int BZ2_bzDecompress ( bz_stream *strm ); +@end example +Provides more input and/out output buffer space for the library. The +caller maintains input and output buffers, and uses @code{BZ2_bzDecompress} +to transfer data between them. + +Before each call to @code{BZ2_bzDecompress}, @code{next_in} +should point at the compressed data, +and @code{avail_in} should indicate how many bytes the library +may read. @code{BZ2_bzDecompress} updates @code{next_in}, @code{avail_in} +and @code{total_in} +to reflect the number of bytes it has read. + +Similarly, @code{next_out} should point to a buffer in which the uncompressed +output is to be placed, with @code{avail_out} indicating how much output space +is available. @code{BZ2_bzCompress} updates @code{next_out}, +@code{avail_out} and @code{total_out} to reflect +the number of bytes output. + +You may provide and remove as little or as much data as you like on +each call of @code{BZ2_bzDecompress}. +In the limit, it is acceptable to +supply and remove data one byte at a time, although this would be +terribly inefficient. You should always ensure that at least one +byte of output space is available at each call. + +Use of @code{BZ2_bzDecompress} is simpler than @code{BZ2_bzCompress}. + +You should provide input and remove output as described above, and +repeatedly call @code{BZ2_bzDecompress} until @code{BZ_STREAM_END} is +returned. Appearance of @code{BZ_STREAM_END} denotes that +@code{BZ2_bzDecompress} has detected the logical end of the compressed +stream. @code{BZ2_bzDecompress} will not produce @code{BZ_STREAM_END} until +all output data has been placed into the output buffer, so once +@code{BZ_STREAM_END} appears, you are guaranteed to have available all +the decompressed output, and @code{BZ2_bzDecompressEnd} can safely be +called. + +If case of an error return value, you should call @code{BZ2_bzDecompressEnd} +to clean up and release memory. + +Possible return values: +@display + @code{BZ_PARAM_ERROR} + if @code{strm} is @code{NULL} or @code{strm->s} is @code{NULL} + or @code{strm->avail_out < 1} + @code{BZ_DATA_ERROR} + if a data integrity error is detected in the compressed stream + @code{BZ_DATA_ERROR_MAGIC} + if the compressed stream doesn't begin with the right magic bytes + @code{BZ_MEM_ERROR} + if there wasn't enough memory available + @code{BZ_STREAM_END} + if the logical end of the data stream was detected and all + output in has been consumed, eg @code{s->avail_out > 0} + @code{BZ_OK} + otherwise +@end display +Allowable next actions: +@display + @code{BZ2_bzDecompress} + if @code{BZ_OK} was returned + @code{BZ2_bzDecompressEnd} + otherwise +@end display + + +@subsection @code{BZ2_bzDecompressEnd} +@example +int BZ2_bzDecompressEnd ( bz_stream *strm ); +@end example +Releases all memory associated with a decompression stream. + +Possible return values: +@display + @code{BZ_PARAM_ERROR} + if @code{strm} is @code{NULL} or @code{strm->s} is @code{NULL} + @code{BZ_OK} + otherwise +@end display + +Allowable next actions: +@display + None. +@end display + + +@section High-level interface + +This interface provides functions for reading and writing +@code{bzip2} format files. First, some general points. + +@itemize @bullet +@item All of the functions take an @code{int*} first argument, + @code{bzerror}. + After each call, @code{bzerror} should be consulted first to determine + the outcome of the call. If @code{bzerror} is @code{BZ_OK}, + the call completed + successfully, and only then should the return value of the function + (if any) be consulted. If @code{bzerror} is @code{BZ_IO_ERROR}, + there was an error + reading/writing the underlying compressed file, and you should + then consult @code{errno}/@code{perror} to determine the + cause of the difficulty. + @code{bzerror} may also be set to various other values; precise details are + given on a per-function basis below. +@item If @code{bzerror} indicates an error + (ie, anything except @code{BZ_OK} and @code{BZ_STREAM_END}), + you should immediately call @code{BZ2_bzReadClose} (or @code{BZ2_bzWriteClose}, + depending on whether you are attempting to read or to write) + to free up all resources associated + with the stream. Once an error has been indicated, behaviour of all calls + except @code{BZ2_bzReadClose} (@code{BZ2_bzWriteClose}) is undefined. + The implication is that (1) @code{bzerror} should + be checked after each call, and (2) if @code{bzerror} indicates an error, + @code{BZ2_bzReadClose} (@code{BZ2_bzWriteClose}) should then be called to clean up. +@item The @code{FILE*} arguments passed to + @code{BZ2_bzReadOpen}/@code{BZ2_bzWriteOpen} + should be set to binary mode. + Most Unix systems will do this by default, but other platforms, + including Windows and Mac, will not. If you omit this, you may + encounter problems when moving code to new platforms. +@item Memory allocation requests are handled by + @code{malloc}/@code{free}. + At present + there is no facility for user-defined memory allocators in the file I/O + functions (could easily be added, though). +@end itemize + + + +@subsection @code{BZ2_bzReadOpen} +@example + typedef void BZFILE; + + BZFILE *BZ2_bzReadOpen ( int *bzerror, FILE *f, + int small, int verbosity, + void *unused, int nUnused ); +@end example +Prepare to read compressed data from file handle @code{f}. @code{f} +should refer to a file which has been opened for reading, and for which +the error indicator (@code{ferror(f)})is not set. If @code{small} is 1, +the library will try to decompress using less memory, at the expense of +speed. + +For reasons explained below, @code{BZ2_bzRead} will decompress the +@code{nUnused} bytes starting at @code{unused}, before starting to read +from the file @code{f}. At most @code{BZ_MAX_UNUSED} bytes may be +supplied like this. If this facility is not required, you should pass +@code{NULL} and @code{0} for @code{unused} and n@code{Unused} +respectively. + +For the meaning of parameters @code{small} and @code{verbosity}, +see @code{BZ2_bzDecompressInit}. + +The amount of memory needed to decompress a file cannot be determined +until the file's header has been read. So it is possible that +@code{BZ2_bzReadOpen} returns @code{BZ_OK} but a subsequent call of +@code{BZ2_bzRead} will return @code{BZ_MEM_ERROR}. + +Possible assignments to @code{bzerror}: +@display + @code{BZ_CONFIG_ERROR} + if the library has been mis-compiled + @code{BZ_PARAM_ERROR} + if @code{f} is @code{NULL} + or @code{small} is neither @code{0} nor @code{1} + or @code{(unused == NULL && nUnused != 0)} + or @code{(unused != NULL && !(0 <= nUnused <= BZ_MAX_UNUSED))} + @code{BZ_IO_ERROR} + if @code{ferror(f)} is nonzero + @code{BZ_MEM_ERROR} + if insufficient memory is available + @code{BZ_OK} + otherwise. +@end display + +Possible return values: +@display + Pointer to an abstract @code{BZFILE} + if @code{bzerror} is @code{BZ_OK} + @code{NULL} + otherwise +@end display + +Allowable next actions: +@display + @code{BZ2_bzRead} + if @code{bzerror} is @code{BZ_OK} + @code{BZ2_bzClose} + otherwise +@end display + + +@subsection @code{BZ2_bzRead} +@example + int BZ2_bzRead ( int *bzerror, BZFILE *b, void *buf, int len ); +@end example +Reads up to @code{len} (uncompressed) bytes from the compressed file +@code{b} into +the buffer @code{buf}. If the read was successful, +@code{bzerror} is set to @code{BZ_OK} +and the number of bytes read is returned. If the logical end-of-stream +was detected, @code{bzerror} will be set to @code{BZ_STREAM_END}, +and the number +of bytes read is returned. All other @code{bzerror} values denote an error. + +@code{BZ2_bzRead} will supply @code{len} bytes, +unless the logical stream end is detected +or an error occurs. Because of this, it is possible to detect the +stream end by observing when the number of bytes returned is +less than the number +requested. Nevertheless, this is regarded as inadvisable; you should +instead check @code{bzerror} after every call and watch out for +@code{BZ_STREAM_END}. + +Internally, @code{BZ2_bzRead} copies data from the compressed file in chunks +of size @code{BZ_MAX_UNUSED} bytes +before decompressing it. If the file contains more bytes than strictly +needed to reach the logical end-of-stream, @code{BZ2_bzRead} will almost certainly +read some of the trailing data before signalling @code{BZ_SEQUENCE_END}. +To collect the read but unused data once @code{BZ_SEQUENCE_END} has +appeared, call @code{BZ2_bzReadGetUnused} immediately before @code{BZ2_bzReadClose}. + +Possible assignments to @code{bzerror}: +@display + @code{BZ_PARAM_ERROR} + if @code{b} is @code{NULL} or @code{buf} is @code{NULL} or @code{len < 0} + @code{BZ_SEQUENCE_ERROR} + if @code{b} was opened with @code{BZ2_bzWriteOpen} + @code{BZ_IO_ERROR} + if there is an error reading from the compressed file + @code{BZ_UNEXPECTED_EOF} + if the compressed file ended before the logical end-of-stream was detected + @code{BZ_DATA_ERROR} + if a data integrity error was detected in the compressed stream + @code{BZ_DATA_ERROR_MAGIC} + if the stream does not begin with the requisite header bytes (ie, is not + a @code{bzip2} data file). This is really a special case of @code{BZ_DATA_ERROR}. + @code{BZ_MEM_ERROR} + if insufficient memory was available + @code{BZ_STREAM_END} + if the logical end of stream was detected. + @code{BZ_OK} + otherwise. +@end display + +Possible return values: +@display + number of bytes read + if @code{bzerror} is @code{BZ_OK} or @code{BZ_STREAM_END} + undefined + otherwise +@end display + +Allowable next actions: +@display + collect data from @code{buf}, then @code{BZ2_bzRead} or @code{BZ2_bzReadClose} + if @code{bzerror} is @code{BZ_OK} + collect data from @code{buf}, then @code{BZ2_bzReadClose} or @code{BZ2_bzReadGetUnused} + if @code{bzerror} is @code{BZ_SEQUENCE_END} + @code{BZ2_bzReadClose} + otherwise +@end display + + + +@subsection @code{BZ2_bzReadGetUnused} +@example + void BZ2_bzReadGetUnused ( int* bzerror, BZFILE *b, + void** unused, int* nUnused ); +@end example +Returns data which was read from the compressed file but was not needed +to get to the logical end-of-stream. @code{*unused} is set to the address +of the data, and @code{*nUnused} to the number of bytes. @code{*nUnused} will +be set to a value between @code{0} and @code{BZ_MAX_UNUSED} inclusive. + +This function may only be called once @code{BZ2_bzRead} has signalled +@code{BZ_STREAM_END} but before @code{BZ2_bzReadClose}. + +Possible assignments to @code{bzerror}: +@display + @code{BZ_PARAM_ERROR} + if @code{b} is @code{NULL} + or @code{unused} is @code{NULL} or @code{nUnused} is @code{NULL} + @code{BZ_SEQUENCE_ERROR} + if @code{BZ_STREAM_END} has not been signalled + or if @code{b} was opened with @code{BZ2_bzWriteOpen} + @code{BZ_OK} + otherwise +@end display + +Allowable next actions: +@display + @code{BZ2_bzReadClose} +@end display + + +@subsection @code{BZ2_bzReadClose} +@example + void BZ2_bzReadClose ( int *bzerror, BZFILE *b ); +@end example +Releases all memory pertaining to the compressed file @code{b}. +@code{BZ2_bzReadClose} does not call @code{fclose} on the underlying file +handle, so you should do that yourself if appropriate. +@code{BZ2_bzReadClose} should be called to clean up after all error +situations. + +Possible assignments to @code{bzerror}: +@display + @code{BZ_SEQUENCE_ERROR} + if @code{b} was opened with @code{BZ2_bzOpenWrite} + @code{BZ_OK} + otherwise +@end display + +Allowable next actions: +@display + none +@end display + + + +@subsection @code{BZ2_bzWriteOpen} +@example + BZFILE *BZ2_bzWriteOpen ( int *bzerror, FILE *f, + int blockSize100k, int verbosity, + int workFactor ); +@end example +Prepare to write compressed data to file handle @code{f}. +@code{f} should refer to +a file which has been opened for writing, and for which the error +indicator (@code{ferror(f)})is not set. + +For the meaning of parameters @code{blockSize100k}, +@code{verbosity} and @code{workFactor}, see +@* @code{BZ2_bzCompressInit}. + +All required memory is allocated at this stage, so if the call +completes successfully, @code{BZ_MEM_ERROR} cannot be signalled by a +subsequent call to @code{BZ2_bzWrite}. + +Possible assignments to @code{bzerror}: +@display + @code{BZ_CONFIG_ERROR} + if the library has been mis-compiled + @code{BZ_PARAM_ERROR} + if @code{f} is @code{NULL} + or @code{blockSize100k < 1} or @code{blockSize100k > 9} + @code{BZ_IO_ERROR} + if @code{ferror(f)} is nonzero + @code{BZ_MEM_ERROR} + if insufficient memory is available + @code{BZ_OK} + otherwise +@end display + +Possible return values: +@display + Pointer to an abstract @code{BZFILE} + if @code{bzerror} is @code{BZ_OK} + @code{NULL} + otherwise +@end display + +Allowable next actions: +@display + @code{BZ2_bzWrite} + if @code{bzerror} is @code{BZ_OK} + (you could go directly to @code{BZ2_bzWriteClose}, but this would be pretty pointless) + @code{BZ2_bzWriteClose} + otherwise +@end display + + + +@subsection @code{BZ2_bzWrite} +@example + void BZ2_bzWrite ( int *bzerror, BZFILE *b, void *buf, int len ); +@end example +Absorbs @code{len} bytes from the buffer @code{buf}, eventually to be +compressed and written to the file. + +Possible assignments to @code{bzerror}: +@display + @code{BZ_PARAM_ERROR} + if @code{b} is @code{NULL} or @code{buf} is @code{NULL} or @code{len < 0} + @code{BZ_SEQUENCE_ERROR} + if b was opened with @code{BZ2_bzReadOpen} + @code{BZ_IO_ERROR} + if there is an error writing the compressed file. + @code{BZ_OK} + otherwise +@end display + + + + +@subsection @code{BZ2_bzWriteClose} +@example + void BZ2_bzWriteClose ( int *bzerror, BZFILE* f, + int abandon, + unsigned int* nbytes_in, + unsigned int* nbytes_out ); + + void BZ2_bzWriteClose64 ( int *bzerror, BZFILE* f, + int abandon, + unsigned int* nbytes_in_lo32, + unsigned int* nbytes_in_hi32, + unsigned int* nbytes_out_lo32, + unsigned int* nbytes_out_hi32 ); +@end example + +Compresses and flushes to the compressed file all data so far supplied +by @code{BZ2_bzWrite}. The logical end-of-stream markers are also written, so +subsequent calls to @code{BZ2_bzWrite} are illegal. All memory associated +with the compressed file @code{b} is released. +@code{fflush} is called on the +compressed file, but it is not @code{fclose}'d. + +If @code{BZ2_bzWriteClose} is called to clean up after an error, the only +action is to release the memory. The library records the error codes +issued by previous calls, so this situation will be detected +automatically. There is no attempt to complete the compression +operation, nor to @code{fflush} the compressed file. You can force this +behaviour to happen even in the case of no error, by passing a nonzero +value to @code{abandon}. + +If @code{nbytes_in} is non-null, @code{*nbytes_in} will be set to be the +total volume of uncompressed data handled. Similarly, @code{nbytes_out} +will be set to the total volume of compressed data written. For +compatibility with older versions of the library, @code{BZ2_bzWriteClose} +only yields the lower 32 bits of these counts. Use +@code{BZ2_bzWriteClose64} if you want the full 64 bit counts. These +two functions are otherwise absolutely identical. + + +Possible assignments to @code{bzerror}: +@display + @code{BZ_SEQUENCE_ERROR} + if @code{b} was opened with @code{BZ2_bzReadOpen} + @code{BZ_IO_ERROR} + if there is an error writing the compressed file + @code{BZ_OK} + otherwise +@end display + +@subsection Handling embedded compressed data streams + +The high-level library facilitates use of +@code{bzip2} data streams which form some part of a surrounding, larger +data stream. +@itemize @bullet +@item For writing, the library takes an open file handle, writes +compressed data to it, @code{fflush}es it but does not @code{fclose} it. +The calling application can write its own data before and after the +compressed data stream, using that same file handle. +@item Reading is more complex, and the facilities are not as general +as they could be since generality is hard to reconcile with efficiency. +@code{BZ2_bzRead} reads from the compressed file in blocks of size +@code{BZ_MAX_UNUSED} bytes, and in doing so probably will overshoot +the logical end of compressed stream. +To recover this data once decompression has +ended, call @code{BZ2_bzReadGetUnused} after the last call of @code{BZ2_bzRead} +(the one returning @code{BZ_STREAM_END}) but before calling +@code{BZ2_bzReadClose}. +@end itemize + +This mechanism makes it easy to decompress multiple @code{bzip2} +streams placed end-to-end. As the end of one stream, when @code{BZ2_bzRead} +returns @code{BZ_STREAM_END}, call @code{BZ2_bzReadGetUnused} to collect the +unused data (copy it into your own buffer somewhere). +That data forms the start of the next compressed stream. +To start uncompressing that next stream, call @code{BZ2_bzReadOpen} again, +feeding in the unused data via the @code{unused}/@code{nUnused} +parameters. +Keep doing this until @code{BZ_STREAM_END} return coincides with the +physical end of file (@code{feof(f)}). In this situation +@code{BZ2_bzReadGetUnused} +will of course return no data. + +This should give some feel for how the high-level interface can be used. +If you require extra flexibility, you'll have to bite the bullet and get +to grips with the low-level interface. + +@subsection Standard file-reading/writing code +Here's how you'd write data to a compressed file: +@example @code +FILE* f; +BZFILE* b; +int nBuf; +char buf[ /* whatever size you like */ ]; +int bzerror; +int nWritten; + +f = fopen ( "myfile.bz2", "w" ); +if (!f) @{ + /* handle error */ +@} +b = BZ2_bzWriteOpen ( &bzerror, f, 9 ); +if (bzerror != BZ_OK) @{ + BZ2_bzWriteClose ( b ); + /* handle error */ +@} + +while ( /* condition */ ) @{ + /* get data to write into buf, and set nBuf appropriately */ + nWritten = BZ2_bzWrite ( &bzerror, b, buf, nBuf ); + if (bzerror == BZ_IO_ERROR) @{ + BZ2_bzWriteClose ( &bzerror, b ); + /* handle error */ + @} +@} + +BZ2_bzWriteClose ( &bzerror, b ); +if (bzerror == BZ_IO_ERROR) @{ + /* handle error */ +@} +@end example +And to read from a compressed file: +@example +FILE* f; +BZFILE* b; +int nBuf; +char buf[ /* whatever size you like */ ]; +int bzerror; +int nWritten; + +f = fopen ( "myfile.bz2", "r" ); +if (!f) @{ + /* handle error */ +@} +b = BZ2_bzReadOpen ( &bzerror, f, 0, NULL, 0 ); +if (bzerror != BZ_OK) @{ + BZ2_bzReadClose ( &bzerror, b ); + /* handle error */ +@} + +bzerror = BZ_OK; +while (bzerror == BZ_OK && /* arbitrary other conditions */) @{ + nBuf = BZ2_bzRead ( &bzerror, b, buf, /* size of buf */ ); + if (bzerror == BZ_OK) @{ + /* do something with buf[0 .. nBuf-1] */ + @} +@} +if (bzerror != BZ_STREAM_END) @{ + BZ2_bzReadClose ( &bzerror, b ); + /* handle error */ +@} else @{ + BZ2_bzReadClose ( &bzerror ); +@} +@end example + + + +@section Utility functions +@subsection @code{BZ2_bzBuffToBuffCompress} +@example + int BZ2_bzBuffToBuffCompress( char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int blockSize100k, + int verbosity, + int workFactor ); +@end example +Attempts to compress the data in @code{source[0 .. sourceLen-1]} +into the destination buffer, @code{dest[0 .. *destLen-1]}. +If the destination buffer is big enough, @code{*destLen} is +set to the size of the compressed data, and @code{BZ_OK} is +returned. If the compressed data won't fit, @code{*destLen} +is unchanged, and @code{BZ_OUTBUFF_FULL} is returned. + +Compression in this manner is a one-shot event, done with a single call +to this function. The resulting compressed data is a complete +@code{bzip2} format data stream. There is no mechanism for making +additional calls to provide extra input data. If you want that kind of +mechanism, use the low-level interface. + +For the meaning of parameters @code{blockSize100k}, @code{verbosity} +and @code{workFactor}, @* see @code{BZ2_bzCompressInit}. + +To guarantee that the compressed data will fit in its buffer, allocate +an output buffer of size 1% larger than the uncompressed data, plus +six hundred extra bytes. + +@code{BZ2_bzBuffToBuffDecompress} will not write data at or +beyond @code{dest[*destLen]}, even in case of buffer overflow. + +Possible return values: +@display + @code{BZ_CONFIG_ERROR} + if the library has been mis-compiled + @code{BZ_PARAM_ERROR} + if @code{dest} is @code{NULL} or @code{destLen} is @code{NULL} + or @code{blockSize100k < 1} or @code{blockSize100k > 9} + or @code{verbosity < 0} or @code{verbosity > 4} + or @code{workFactor < 0} or @code{workFactor > 250} + @code{BZ_MEM_ERROR} + if insufficient memory is available + @code{BZ_OUTBUFF_FULL} + if the size of the compressed data exceeds @code{*destLen} + @code{BZ_OK} + otherwise +@end display + + + +@subsection @code{BZ2_bzBuffToBuffDecompress} +@example + int BZ2_bzBuffToBuffDecompress ( char* dest, + unsigned int* destLen, + char* source, + unsigned int sourceLen, + int small, + int verbosity ); +@end example +Attempts to decompress the data in @code{source[0 .. sourceLen-1]} +into the destination buffer, @code{dest[0 .. *destLen-1]}. +If the destination buffer is big enough, @code{*destLen} is +set to the size of the uncompressed data, and @code{BZ_OK} is +returned. If the compressed data won't fit, @code{*destLen} +is unchanged, and @code{BZ_OUTBUFF_FULL} is returned. + +@code{source} is assumed to hold a complete @code{bzip2} format +data stream. @* @code{BZ2_bzBuffToBuffDecompress} tries to decompress +the entirety of the stream into the output buffer. + +For the meaning of parameters @code{small} and @code{verbosity}, +see @code{BZ2_bzDecompressInit}. + +Because the compression ratio of the compressed data cannot be known in +advance, there is no easy way to guarantee that the output buffer will +be big enough. You may of course make arrangements in your code to +record the size of the uncompressed data, but such a mechanism is beyond +the scope of this library. + +@code{BZ2_bzBuffToBuffDecompress} will not write data at or +beyond @code{dest[*destLen]}, even in case of buffer overflow. + +Possible return values: +@display + @code{BZ_CONFIG_ERROR} + if the library has been mis-compiled + @code{BZ_PARAM_ERROR} + if @code{dest} is @code{NULL} or @code{destLen} is @code{NULL} + or @code{small != 0 && small != 1} + or @code{verbosity < 0} or @code{verbosity > 4} + @code{BZ_MEM_ERROR} + if insufficient memory is available + @code{BZ_OUTBUFF_FULL} + if the size of the compressed data exceeds @code{*destLen} + @code{BZ_DATA_ERROR} + if a data integrity error was detected in the compressed data + @code{BZ_DATA_ERROR_MAGIC} + if the compressed data doesn't begin with the right magic bytes + @code{BZ_UNEXPECTED_EOF} + if the compressed data ends unexpectedly + @code{BZ_OK} + otherwise +@end display + + + +@section @code{zlib} compatibility functions +Yoshioka Tsuneo has contributed some functions to +give better @code{zlib} compatibility. These functions are +@code{BZ2_bzopen}, @code{BZ2_bzread}, @code{BZ2_bzwrite}, @code{BZ2_bzflush}, +@code{BZ2_bzclose}, +@code{BZ2_bzerror} and @code{BZ2_bzlibVersion}. +These functions are not (yet) officially part of +the library. If they break, you get to keep all the pieces. +Nevertheless, I think they work ok. +@example +typedef void BZFILE; + +const char * BZ2_bzlibVersion ( void ); +@end example +Returns a string indicating the library version. +@example +BZFILE * BZ2_bzopen ( const char *path, const char *mode ); +BZFILE * BZ2_bzdopen ( int fd, const char *mode ); +@end example +Opens a @code{.bz2} file for reading or writing, using either its name +or a pre-existing file descriptor. +Analogous to @code{fopen} and @code{fdopen}. +@example +int BZ2_bzread ( BZFILE* b, void* buf, int len ); +int BZ2_bzwrite ( BZFILE* b, void* buf, int len ); +@end example +Reads/writes data from/to a previously opened @code{BZFILE}. +Analogous to @code{fread} and @code{fwrite}. +@example +int BZ2_bzflush ( BZFILE* b ); +void BZ2_bzclose ( BZFILE* b ); +@end example +Flushes/closes a @code{BZFILE}. @code{BZ2_bzflush} doesn't actually do +anything. Analogous to @code{fflush} and @code{fclose}. + +@example +const char * BZ2_bzerror ( BZFILE *b, int *errnum ) +@end example +Returns a string describing the more recent error status of +@code{b}, and also sets @code{*errnum} to its numerical value. + + +@section Using the library in a @code{stdio}-free environment + +@subsection Getting rid of @code{stdio} + +In a deeply embedded application, you might want to use just +the memory-to-memory functions. You can do this conveniently +by compiling the library with preprocessor symbol @code{BZ_NO_STDIO} +defined. Doing this gives you a library containing only the following +eight functions: + +@code{BZ2_bzCompressInit}, @code{BZ2_bzCompress}, @code{BZ2_bzCompressEnd} @* +@code{BZ2_bzDecompressInit}, @code{BZ2_bzDecompress}, @code{BZ2_bzDecompressEnd} @* +@code{BZ2_bzBuffToBuffCompress}, @code{BZ2_bzBuffToBuffDecompress} + +When compiled like this, all functions will ignore @code{verbosity} +settings. + +@subsection Critical error handling +@code{libbzip2} contains a number of internal assertion checks which +should, needless to say, never be activated. Nevertheless, if an +assertion should fail, behaviour depends on whether or not the library +was compiled with @code{BZ_NO_STDIO} set. + +For a normal compile, an assertion failure yields the message +@example + bzip2/libbzip2: internal error number N. + This is a bug in bzip2/libbzip2, 1.0 of 21-Mar-2000. + Please report it to me at: jseward@@acm.org. If this happened + when you were using some program which uses libbzip2 as a + component, you should also report this bug to the author(s) + of that program. Please make an effort to report this bug; + timely and accurate bug reports eventually lead to higher + quality software. Thanks. Julian Seward, 21 March 2000. +@end example +where @code{N} is some error code number. @code{exit(3)} +is then called. + +For a @code{stdio}-free library, assertion failures result +in a call to a function declared as: +@example + extern void bz_internal_error ( int errcode ); +@end example +The relevant code is passed as a parameter. You should supply +such a function. + +In either case, once an assertion failure has occurred, any +@code{bz_stream} records involved can be regarded as invalid. +You should not attempt to resume normal operation with them. + +You may, of course, change critical error handling to suit +your needs. As I said above, critical errors indicate bugs +in the library and should not occur. All "normal" error +situations are indicated via error return codes from functions, +and can be recovered from. + + +@section Making a Windows DLL +Everything related to Windows has been contributed by Yoshioka Tsuneo +@* (@code{QWF00133@@niftyserve.or.jp} / +@code{tsuneo-y@@is.aist-nara.ac.jp}), so you should send your queries to +him (but perhaps Cc: me, @code{jseward@@acm.org}). + +My vague understanding of what to do is: using Visual C++ 5.0, +open the project file @code{libbz2.dsp}, and build. That's all. + +If you can't +open the project file for some reason, make a new one, naming these files: +@code{blocksort.c}, @code{bzlib.c}, @code{compress.c}, +@code{crctable.c}, @code{decompress.c}, @code{huffman.c}, @* +@code{randtable.c} and @code{libbz2.def}. You will also need +to name the header files @code{bzlib.h} and @code{bzlib_private.h}. + +If you don't use VC++, you may need to define the proprocessor symbol +@code{_WIN32}. + +Finally, @code{dlltest.c} is a sample program using the DLL. It has a +project file, @code{dlltest.dsp}. + +If you just want a makefile for Visual C, have a look at +@code{makefile.msc}. + +Be aware that if you compile @code{bzip2} itself on Win32, you must set +@code{BZ_UNIX} to 0 and @code{BZ_LCCWIN32} to 1, in the file +@code{bzip2.c}, before compiling. Otherwise the resulting binary won't +work correctly. + +I haven't tried any of this stuff myself, but it all looks plausible. + + + +@chapter Miscellanea + +These are just some random thoughts of mine. Your mileage may +vary. + +@section Limitations of the compressed file format +@code{bzip2-1.0}, @code{0.9.5} and @code{0.9.0} +use exactly the same file format as the previous +version, @code{bzip2-0.1}. This decision was made in the interests of +stability. Creating yet another incompatible compressed file format +would create further confusion and disruption for users. + +Nevertheless, this is not a painless decision. Development +work since the release of @code{bzip2-0.1} in August 1997 +has shown complexities in the file format which slow down +decompression and, in retrospect, are unnecessary. These are: +@itemize @bullet +@item The run-length encoder, which is the first of the + compression transformations, is entirely irrelevant. + The original purpose was to protect the sorting algorithm + from the very worst case input: a string of repeated + symbols. But algorithm steps Q6a and Q6b in the original + Burrows-Wheeler technical report (SRC-124) show how + repeats can be handled without difficulty in block + sorting. +@item The randomisation mechanism doesn't really need to be + there. Udi Manber and Gene Myers published a suffix + array construction algorithm a few years back, which + can be employed to sort any block, no matter how + repetitive, in O(N log N) time. Subsequent work by + Kunihiko Sadakane has produced a derivative O(N (log N)^2) + algorithm which usually outperforms the Manber-Myers + algorithm. + + I could have changed to Sadakane's algorithm, but I find + it to be slower than @code{bzip2}'s existing algorithm for + most inputs, and the randomisation mechanism protects + adequately against bad cases. I didn't think it was + a good tradeoff to make. Partly this is due to the fact + that I was not flooded with email complaints about + @code{bzip2-0.1}'s performance on repetitive data, so + perhaps it isn't a problem for real inputs. + + Probably the best long-term solution, + and the one I have incorporated into 0.9.5 and above, + is to use the existing sorting + algorithm initially, and fall back to a O(N (log N)^2) + algorithm if the standard algorithm gets into difficulties. +@item The compressed file format was never designed to be + handled by a library, and I have had to jump though + some hoops to produce an efficient implementation of + decompression. It's a bit hairy. Try passing + @code{decompress.c} through the C preprocessor + and you'll see what I mean. Much of this complexity + could have been avoided if the compressed size of + each block of data was recorded in the data stream. +@item An Adler-32 checksum, rather than a CRC32 checksum, + would be faster to compute. +@end itemize +It would be fair to say that the @code{bzip2} format was frozen +before I properly and fully understood the performance +consequences of doing so. + +Improvements which I was able to incorporate into +0.9.0, despite using the same file format, are: +@itemize @bullet +@item Single array implementation of the inverse BWT. This + significantly speeds up decompression, presumably + because it reduces the number of cache misses. +@item Faster inverse MTF transform for large MTF values. The + new implementation is based on the notion of sliding blocks + of values. +@item @code{bzip2-0.9.0} now reads and writes files with @code{fread} + and @code{fwrite}; version 0.1 used @code{putc} and @code{getc}. + Duh! Well, you live and learn. + +@end itemize +Further ahead, it would be nice +to be able to do random access into files. This will +require some careful design of compressed file formats. + + + +@section Portability issues +After some consideration, I have decided not to use +GNU @code{autoconf} to configure 0.9.5 or 1.0. + +@code{autoconf}, admirable and wonderful though it is, +mainly assists with portability problems between Unix-like +platforms. But @code{bzip2} doesn't have much in the way +of portability problems on Unix; most of the difficulties appear +when porting to the Mac, or to Microsoft's operating systems. +@code{autoconf} doesn't help in those cases, and brings in a +whole load of new complexity. + +Most people should be able to compile the library and program +under Unix straight out-of-the-box, so to speak, especially +if you have a version of GNU C available. + +There are a couple of @code{__inline__} directives in the code. GNU C +(@code{gcc}) should be able to handle them. If you're not using +GNU C, your C compiler shouldn't see them at all. +If your compiler does, for some reason, see them and doesn't +like them, just @code{#define} @code{__inline__} to be @code{/* */}. One +easy way to do this is to compile with the flag @code{-D__inline__=}, +which should be understood by most Unix compilers. + +If you still have difficulties, try compiling with the macro +@code{BZ_STRICT_ANSI} defined. This should enable you to build the +library in a strictly ANSI compliant environment. Building the program +itself like this is dangerous and not supported, since you remove +@code{bzip2}'s checks against compressing directories, symbolic links, +devices, and other not-really-a-file entities. This could cause +filesystem corruption! + +One other thing: if you create a @code{bzip2} binary for public +distribution, please try and link it statically (@code{gcc -s}). This +avoids all sorts of library-version issues that others may encounter +later on. + +If you build @code{bzip2} on Win32, you must set @code{BZ_UNIX} to 0 and +@code{BZ_LCCWIN32} to 1, in the file @code{bzip2.c}, before compiling. +Otherwise the resulting binary won't work correctly. + + + +@section Reporting bugs +I tried pretty hard to make sure @code{bzip2} is +bug free, both by design and by testing. Hopefully +you'll never need to read this section for real. + +Nevertheless, if @code{bzip2} dies with a segmentation +fault, a bus error or an internal assertion failure, it +will ask you to email me a bug report. Experience with +version 0.1 shows that almost all these problems can +be traced to either compiler bugs or hardware problems. +@itemize @bullet +@item +Recompile the program with no optimisation, and see if it +works. And/or try a different compiler. +I heard all sorts of stories about various flavours +of GNU C (and other compilers) generating bad code for +@code{bzip2}, and I've run across two such examples myself. + +2.7.X versions of GNU C are known to generate bad code from +time to time, at high optimisation levels. +If you get problems, try using the flags +@code{-O2} @code{-fomit-frame-pointer} @code{-fno-strength-reduce}. +You should specifically @emph{not} use @code{-funroll-loops}. + +You may notice that the Makefile runs six tests as part of +the build process. If the program passes all of these, it's +a pretty good (but not 100%) indication that the compiler has +done its job correctly. +@item +If @code{bzip2} crashes randomly, and the crashes are not +repeatable, you may have a flaky memory subsystem. @code{bzip2} +really hammers your memory hierarchy, and if it's a bit marginal, +you may get these problems. Ditto if your disk or I/O subsystem +is slowly failing. Yup, this really does happen. + +Try using a different machine of the same type, and see if +you can repeat the problem. +@item This isn't really a bug, but ... If @code{bzip2} tells +you your file is corrupted on decompression, and you +obtained the file via FTP, there is a possibility that you +forgot to tell FTP to do a binary mode transfer. That absolutely +will cause the file to be non-decompressible. You'll have to transfer +it again. +@end itemize + +If you've incorporated @code{libbzip2} into your own program +and are getting problems, please, please, please, check that the +parameters you are passing in calls to the library, are +correct, and in accordance with what the documentation says +is allowable. I have tried to make the library robust against +such problems, but I'm sure I haven't succeeded. + +Finally, if the above comments don't help, you'll have to send +me a bug report. Now, it's just amazing how many people will +send me a bug report saying something like +@display + bzip2 crashed with segmentation fault on my machine +@end display +and absolutely nothing else. Needless to say, a such a report +is @emph{totally, utterly, completely and comprehensively 100% useless; +a waste of your time, my time, and net bandwidth}. +With no details at all, there's no way I can possibly begin +to figure out what the problem is. + +The rules of the game are: facts, facts, facts. Don't omit +them because "oh, they won't be relevant". At the bare +minimum: +@display + Machine type. Operating system version. + Exact version of @code{bzip2} (do @code{bzip2 -V}). + Exact version of the compiler used. + Flags passed to the compiler. +@end display +However, the most important single thing that will help me is +the file that you were trying to compress or decompress at the +time the problem happened. Without that, my ability to do anything +more than speculate about the cause, is limited. + +Please remember that I connect to the Internet with a modem, so +you should contact me before mailing me huge files. + + +@section Did you get the right package? + +@code{bzip2} is a resource hog. It soaks up large amounts of CPU cycles +and memory. Also, it gives very large latencies. In the worst case, you +can feed many megabytes of uncompressed data into the library before +getting any compressed output, so this probably rules out applications +requiring interactive behaviour. + +These aren't faults of my implementation, I hope, but more +an intrinsic property of the Burrows-Wheeler transform (unfortunately). +Maybe this isn't what you want. + +If you want a compressor and/or library which is faster, uses less +memory but gets pretty good compression, and has minimal latency, +consider Jean-loup +Gailly's and Mark Adler's work, @code{zlib-1.1.2} and +@code{gzip-1.2.4}. Look for them at + +@code{http://www.cdrom.com/pub/infozip/zlib} and +@code{http://www.gzip.org} respectively. + +For something faster and lighter still, you might try Markus F X J +Oberhumer's @code{LZO} real-time compression/decompression library, at +@* @code{http://wildsau.idv.uni-linz.ac.at/mfx/lzo.html}. + +If you want to use the @code{bzip2} algorithms to compress small blocks +of data, 64k bytes or smaller, for example on an on-the-fly disk +compressor, you'd be well advised not to use this library. Instead, +I've made a special library tuned for that kind of use. It's part of +@code{e2compr-0.40}, an on-the-fly disk compressor for the Linux +@code{ext2} filesystem. Look at +@code{http://www.netspace.net.au/~reiter/e2compr}. + + + +@section Testing + +A record of the tests I've done. + +First, some data sets: +@itemize @bullet +@item B: a directory containing 6001 files, one for every length in the + range 0 to 6000 bytes. The files contain random lowercase + letters. 18.7 megabytes. +@item H: my home directory tree. Documents, source code, mail files, + compressed data. H contains B, and also a directory of + files designed as boundary cases for the sorting; mostly very + repetitive, nasty files. 565 megabytes. +@item A: directory tree holding various applications built from source: + @code{egcs}, @code{gcc-2.8.1}, KDE, GTK, Octave, etc. + 2200 megabytes. +@end itemize +The tests conducted are as follows. Each test means compressing +(a copy of) each file in the data set, decompressing it and +comparing it against the original. + +First, a bunch of tests with block sizes and internal buffer +sizes set very small, +to detect any problems with the +blocking and buffering mechanisms. +This required modifying the source code so as to try to +break it. +@enumerate +@item Data set H, with + buffer size of 1 byte, and block size of 23 bytes. +@item Data set B, buffer sizes 1 byte, block size 1 byte. +@item As (2) but small-mode decompression. +@item As (2) with block size 2 bytes. +@item As (2) with block size 3 bytes. +@item As (2) with block size 4 bytes. +@item As (2) with block size 5 bytes. +@item As (2) with block size 6 bytes and small-mode decompression. +@item H with buffer size of 1 byte, but normal block + size (up to 900000 bytes). +@end enumerate +Then some tests with unmodified source code. +@enumerate +@item H, all settings normal. +@item As (1), with small-mode decompress. +@item H, compress with flag @code{-1}. +@item H, compress with flag @code{-s}, decompress with flag @code{-s}. +@item Forwards compatibility: H, @code{bzip2-0.1pl2} compressing, + @code{bzip2-0.9.5} decompressing, all settings normal. +@item Backwards compatibility: H, @code{bzip2-0.9.5} compressing, + @code{bzip2-0.1pl2} decompressing, all settings normal. +@item Bigger tests: A, all settings normal. +@item As (7), using the fallback (Sadakane-like) sorting algorithm. +@item As (8), compress with flag @code{-1}, decompress with flag + @code{-s}. +@item H, using the fallback sorting algorithm. +@item Forwards compatibility: A, @code{bzip2-0.1pl2} compressing, + @code{bzip2-0.9.5} decompressing, all settings normal. +@item Backwards compatibility: A, @code{bzip2-0.9.5} compressing, + @code{bzip2-0.1pl2} decompressing, all settings normal. +@item Misc test: about 400 megabytes of @code{.tar} files with + @code{bzip2} compiled with Checker (a memory access error + detector, like Purify). +@item Misc tests to make sure it builds and runs ok on non-Linux/x86 + platforms. +@end enumerate +These tests were conducted on a 225 MHz IDT WinChip machine, running +Linux 2.0.36. They represent nearly a week of continuous computation. +All tests completed successfully. + + +@section Further reading +@code{bzip2} is not research work, in the sense that it doesn't present +any new ideas. Rather, it's an engineering exercise based on existing +ideas. + +Four documents describe essentially all the ideas behind @code{bzip2}: +@example +Michael Burrows and D. J. Wheeler: + "A block-sorting lossless data compression algorithm" + 10th May 1994. + Digital SRC Research Report 124. + ftp://ftp.digital.com/pub/DEC/SRC/research-reports/SRC-124.ps.gz + If you have trouble finding it, try searching at the + New Zealand Digital Library, http://www.nzdl.org. + +Daniel S. Hirschberg and Debra A. LeLewer + "Efficient Decoding of Prefix Codes" + Communications of the ACM, April 1990, Vol 33, Number 4. + You might be able to get an electronic copy of this + from the ACM Digital Library. + +David J. Wheeler + Program bred3.c and accompanying document bred3.ps. + This contains the idea behind the multi-table Huffman + coding scheme. + ftp://ftp.cl.cam.ac.uk/users/djw3/ + +Jon L. Bentley and Robert Sedgewick + "Fast Algorithms for Sorting and Searching Strings" + Available from Sedgewick's web page, + www.cs.princeton.edu/~rs +@end example +The following paper gives valuable additional insights into the +algorithm, but is not immediately the basis of any code +used in bzip2. +@example +Peter Fenwick: + Block Sorting Text Compression + Proceedings of the 19th Australasian Computer Science Conference, + Melbourne, Australia. Jan 31 - Feb 2, 1996. + ftp://ftp.cs.auckland.ac.nz/pub/peter-f/ACSC96paper.ps +@end example +Kunihiko Sadakane's sorting algorithm, mentioned above, +is available from: +@example +http://naomi.is.s.u-tokyo.ac.jp/~sada/papers/Sada98b.ps.gz +@end example +The Manber-Myers suffix array construction +algorithm is described in a paper +available from: +@example +http://www.cs.arizona.edu/people/gene/PAPERS/suffix.ps +@end example +Finally, the following paper documents some recent investigations +I made into the performance of sorting algorithms: +@example +Julian Seward: + On the Performance of BWT Sorting Algorithms + Proceedings of the IEEE Data Compression Conference 2000 + Snowbird, Utah. 28-30 March 2000. +@end example + + +@contents + +@bye + diff --git a/contrib/bzip2/randtable.c b/contrib/bzip2/randtable.c new file mode 100644 index 000000000000..983089d4684d --- /dev/null +++ b/contrib/bzip2/randtable.c @@ -0,0 +1,124 @@ + +/*-------------------------------------------------------------*/ +/*--- Table for randomising repetitive blocks ---*/ +/*--- randtable.c ---*/ +/*-------------------------------------------------------------*/ + +/*-- + This file is a part of bzip2 and/or libbzip2, a program and + library for lossless, block-sorting data compression. + + Copyright (C) 1996-2000 Julian R Seward. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. The origin of this software must not be misrepresented; you must + not claim that you wrote the original software. If you use this + software in a product, an acknowledgment in the product + documentation would be appreciated but is not required. + + 3. Altered source versions must be plainly marked as such, and must + not be misrepresented as being the original software. + + 4. The name of the author may not be used to endorse or promote + products derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + Julian Seward, Cambridge, UK. + jseward@acm.org + bzip2/libbzip2 version 1.0 of 21 March 2000 + + This program is based on (at least) the work of: + Mike Burrows + David Wheeler + Peter Fenwick + Alistair Moffat + Radford Neal + Ian H. Witten + Robert Sedgewick + Jon L. Bentley + + For more information on these sources, see the manual. +--*/ + + +#include "bzlib_private.h" + + +/*---------------------------------------------*/ +Int32 BZ2_rNums[512] = { + 619, 720, 127, 481, 931, 816, 813, 233, 566, 247, + 985, 724, 205, 454, 863, 491, 741, 242, 949, 214, + 733, 859, 335, 708, 621, 574, 73, 654, 730, 472, + 419, 436, 278, 496, 867, 210, 399, 680, 480, 51, + 878, 465, 811, 169, 869, 675, 611, 697, 867, 561, + 862, 687, 507, 283, 482, 129, 807, 591, 733, 623, + 150, 238, 59, 379, 684, 877, 625, 169, 643, 105, + 170, 607, 520, 932, 727, 476, 693, 425, 174, 647, + 73, 122, 335, 530, 442, 853, 695, 249, 445, 515, + 909, 545, 703, 919, 874, 474, 882, 500, 594, 612, + 641, 801, 220, 162, 819, 984, 589, 513, 495, 799, + 161, 604, 958, 533, 221, 400, 386, 867, 600, 782, + 382, 596, 414, 171, 516, 375, 682, 485, 911, 276, + 98, 553, 163, 354, 666, 933, 424, 341, 533, 870, + 227, 730, 475, 186, 263, 647, 537, 686, 600, 224, + 469, 68, 770, 919, 190, 373, 294, 822, 808, 206, + 184, 943, 795, 384, 383, 461, 404, 758, 839, 887, + 715, 67, 618, 276, 204, 918, 873, 777, 604, 560, + 951, 160, 578, 722, 79, 804, 96, 409, 713, 940, + 652, 934, 970, 447, 318, 353, 859, 672, 112, 785, + 645, 863, 803, 350, 139, 93, 354, 99, 820, 908, + 609, 772, 154, 274, 580, 184, 79, 626, 630, 742, + 653, 282, 762, 623, 680, 81, 927, 626, 789, 125, + 411, 521, 938, 300, 821, 78, 343, 175, 128, 250, + 170, 774, 972, 275, 999, 639, 495, 78, 352, 126, + 857, 956, 358, 619, 580, 124, 737, 594, 701, 612, + 669, 112, 134, 694, 363, 992, 809, 743, 168, 974, + 944, 375, 748, 52, 600, 747, 642, 182, 862, 81, + 344, 805, 988, 739, 511, 655, 814, 334, 249, 515, + 897, 955, 664, 981, 649, 113, 974, 459, 893, 228, + 433, 837, 553, 268, 926, 240, 102, 654, 459, 51, + 686, 754, 806, 760, 493, 403, 415, 394, 687, 700, + 946, 670, 656, 610, 738, 392, 760, 799, 887, 653, + 978, 321, 576, 617, 626, 502, 894, 679, 243, 440, + 680, 879, 194, 572, 640, 724, 926, 56, 204, 700, + 707, 151, 457, 449, 797, 195, 791, 558, 945, 679, + 297, 59, 87, 824, 713, 663, 412, 693, 342, 606, + 134, 108, 571, 364, 631, 212, 174, 643, 304, 329, + 343, 97, 430, 751, 497, 314, 983, 374, 822, 928, + 140, 206, 73, 263, 980, 736, 876, 478, 430, 305, + 170, 514, 364, 692, 829, 82, 855, 953, 676, 246, + 369, 970, 294, 750, 807, 827, 150, 790, 288, 923, + 804, 378, 215, 828, 592, 281, 565, 555, 710, 82, + 896, 831, 547, 261, 524, 462, 293, 465, 502, 56, + 661, 821, 976, 991, 658, 869, 905, 758, 745, 193, + 768, 550, 608, 933, 378, 286, 215, 979, 792, 961, + 61, 688, 793, 644, 986, 403, 106, 366, 905, 644, + 372, 567, 466, 434, 645, 210, 389, 550, 919, 135, + 780, 773, 635, 389, 707, 100, 626, 958, 165, 504, + 920, 176, 193, 713, 857, 265, 203, 50, 668, 108, + 645, 990, 626, 197, 510, 357, 358, 850, 858, 364, + 936, 638 +}; + + +/*-------------------------------------------------------------*/ +/*--- end randtable.c ---*/ +/*-------------------------------------------------------------*/ diff --git a/contrib/bzip2/sample1.bz2.uu b/contrib/bzip2/sample1.bz2.uu new file mode 100644 index 000000000000..0464d68a613a --- /dev/null +++ b/contrib/bzip2/sample1.bz2.uu @@ -0,0 +1,722 @@ +begin 644 sample1.bz2 +M0EIH,3%!62936``^"5D```4[8=N[8K7,-JP,#+WT`WUMF`[!Z#H>Z]G#Z!`$ +M``&]F(!NO=V[[M9NCTWNY[8+SDJPX]LV]K.-S+;KAZ-ZL2V8*;.;77MW;VVY +M![U3J;CKVY> +M\YVVWMWO&V7L-Y[M$'&]!PCH&04`HUY\]VFG;-C"?8WPIWN^ONQOM?6^^^/1 +MO*SK10%$ADGQ7`:;'-UKT/24A0V\]MZ?7OC;Y];=[SO;W=U-O.57L]5/ +M=N>K8(O1\OO;P^M\^0LKXN=W6^`!YY0>;#);![[YOO7VNVSU#H^@*`Q5;8S' +MUIUUT((&@Z``&]M7#[83W@`6P'U0KW6XQ8:T%="V!09>]R3<%]5![-K&A-C` +M`"]C4^]W,$;9@)6UCTU="4TB!`$TTT`":!HT$P$TT&F09$PTT9#0"9,"8FFR +M4ST4\`*GY,3*>:%/3313\(T4_(:1Z8B9B:9/13::,4\B/(GJ;31IHF:-$84& +MIZ`@(($@!`D>A4]Z2>)ZC$8*;5,U/4_43U-J'J``&@#$T`-``>H`>HT::`&@ +M'J`````````#1D```TQ$$(")IJ8(;5--&DGH;4/29-(T,T&D>IF:IIIZFCTF +MGZIB&T33U/2,@-&GI,``"9,:$8AH9&3$80R8F`3333$T-`&C33$T&02:2(A` +M01H"3$IXD_3(:!JF]4\HTT]3TTTCR>BFC$/U(]3R@>HVH:::9&CU&F@_5&F0 +M>B::>H`-#0;4`!Z@/4T/4#0`]0>H>H:::8CTF@`(E(FA">DPFJG^FJ>U,)IH +MTD_0--39-$\B:GHT](]3U)@--,RFGI/4]3:*9/R3U,DVIX2'J;:1Z3TIZFT, +MRIO2-1XB>D]&C3U#330:`T:>IM)/4]/34TT)ZC1[13-,U$$B(0(!`"$\DP!- +M&43RI^FD]&IZ:IX-&)I3TG^JFQ,1/:DT\2>4-'HRF90/%/4&T-1M1^I-'I/4 +M>4/0TT8AJ'J9E--`TR:>4&3]34-,AH/4R>HVH:=\9D)$$ZM>S:PQRS9]&G5H +MU[-K:V(2/Y"8\C(Q)9!V$HB&:-'42&;`39!PD30DX(`'VXR!]S]4?EFN`3TR +MZI#2Y485N#3[NW+I^(*P8* +M+%6+"?N\S$"NN6K^!G2+PF?**'^9`UY!,:(7CH3J3[A6#WQZ4J-T5H'2G.&> +M-2=B7#IC:(I<#LF+;AA'-E`S4$.`0-1%;3`.JA(I(#(C(FAB`!=^50!=C)$: +MH"I;(BF^4A`6*AN8B7("'&P6M5@%N,HM`DI;!"0/Q)*,&`L!$0()&04("@A_ +MOV%D2$D5[-%(JQ108Q09(10D"1A(WT%.P>Q6B\E!>^K6O^R""3OW/_[ZS0'# +M4-22"H@",@XDJ31#1\`)/HDQN>')A%TJ]$V1+&-)*&>W?PP0?X?+7I+[+[VP +M3PC6GVWGC>+*F46#Z6^(-:L&)_:@J<*EMI^3EQ&(A^YY(&L#0Q8JL3K^4S]I +M#>_8,KJU:*E_@DB8.E4=-4ME5J(UBE%1&VPK5&,MA1506(BHQ+;+8(V*U610J +M+6*VHA4H*T?UR5$9@Q1JREI2L6L+:-**1+18I4JH*%L6I4%B4=X8F);0J +M5K1$48%92T;0:T4$9*Q&VR5@H)0MHB6+`:-%X,IE6@K2UH:$S/VUS+:N[1$1 +M$14RRB6MK4&,;8VE+%;:E%*E$1JVJM8I6*"4A&D4JMLJV86IBN$2X5:,LME& +M4M:U:WTY`PQ$:E11:J6V5;449+,+\U,1-62]1+/N;K$*VCQEF)RU3/\+6]?@ +M[X)#"F_D^[8!_T6KS/*A2S_2##C82P;;N0TM7XA(!X3^(([YDGIB5D`1#U]` +MZ?3G,`]G$@Y^6Y,_MO@S(;S-8F)M-B(&`-RB0J*L*D[ +MX2=IW3O.[H:?RO,DZ2(2-IU8"))B!1`EM"L`;8H12$%!&$@R`R`L(H`L@2H" +MR5@19%(L%)$C(H2*0K(L"02,"0)$)"2<[:WY?BIW:8'Q_`]W\82"<2#X(X38 +MTW)^-;\@+GF2)/(-P_R>>J:4:4E,.N)1M%VF%>$DEAF*Z&1TGC@])U7NFCU+ +MN>`[7?^W3>OO'<3HB]U2E#[5*?*_?.[/3N@K(B@OW%#YF82H^O80Z.&^PU"7 +MW?_R[Z6Q?@$YES!1'*,-Q:OO\]#N,$&6I9_/F;*6,T@9!,3_1(URE_OYGI_" +MY<5`;Z@-S2I$*GA,L]#XW4S2?!DU_O]QO_9AI!Y\>Y1!J>"31EX>WE4+!V$\ +M>613_ON\Q']NN^YSVZYS[UJ[O+#'=(J=:GX5$K*#,P97R/#:USLO6?(H@>/M +MWIF_9J'IG<$7^F$E]%@/WG=R&)]J%Q!C>'ZU#IS>Y'(F-W92NO[];">J.WPY +M>:CX^4,,2G](D8=DW.N`>)OM%+S&;1)4X:`R3_Q9%63GFS$DTD6#$0!!FTPT +M(C^`FFR:$.)W9]47GR3R96]+1^%[M'![K+?@<:(D`)`&09%9$0UJ0:1"D615 +MD0&D4D0H0&0$B,$)BY6X\Z&:PLYX?M_C>@!&$)"?F4%BD6+"*H*L%BR180%D +MD!@H`P@**1!6"PBD%(I!2"P4$!@Q$(L404$9%%"10!818HLD$3"9@8"6E=LC +M=ZY$MR2016]73O"\R>!Y:>K[G^FHFKA?H)!21$R`"(4DB%SE4]R9>JY?E4X& +MI\XGESTX-"[H/;_T,"%:]7P,3@-S5ZTXV'+3TZX^BX)@?N13"Q]R<6\>WJ2J +ME=AB28A3W4U`3K>S\+9S=EPX0#/1D#A8LBR((R06I(5"%10HDJ+!MJ$4%6$0 +M18"@I%50B@H2I(*2H5A*P%DBQ0BP*J2LA*0@RHLE$*P(LK`44(H419)1JI%@ +MB(R4+)81C&("P1("A*J*L$9$8"?@!^+Y6,K1(3B'3Z'IN*\WM_1.)S9:QJ#V +M.UX(P-9-;H6^$I0T`0W9>9]S#+.@--Q^NL4@RVBR1W]!.:.+^0H9W.2O'GTT +M#,`&83,V914O]3MOSE7G(#1\0 +M*($#9<1&-`[,Z.F3H`4'!R759LB%L+C7R@9Q,?8/(T +MY/?['L,W\PE4_\NZ$[_H=_CG'(`!W4NY[Z>IS^)YMA'WF+CCR584:K[\+[ +MNWNE?U'YVR>\7?&/T?A7%?'#R;1?/H]UW!VYCE])@;%D/K[Q?:R;62DEJA&1 +MU3=%4)4^XQ+Y-(?*ZFZP7CEQ#LZ[L,Q\4L9;):%S'2$FXK_BU^\16NQ))N=?`@(NB\EAP;YC&WJ5^<0NFM$;/LFN9F9L1V!#U:\U +M(5H?SO]&9_M??V\["^4:W!77DH<\;](V?F]5I<1VDHW[#LD0.RJ)L[:*6")Y +M*)DL7V)(\H0#](ZFBD&:I8DTQE#M*^A-;;*$?T`R>72#AEPSH^>V'F0M6#?G +MAUYBGV06[9Z6TW']6,^:-#7U\MGU=F`:BWF+VUA7=.XSX9E2POZK2TLW/+P7 +M;1AN1P).,)2(^DZA\O??]XKL;O +M'&WO(R*^!FM//G(39;-4I:,_"G//K=7/4C3HU>+8F?'6-=3+%/O/AK\5H$4L +MM98SGJ@\'QQT3QR7[D?4;6+X3`M]Z+#YB4C+??UJ]+/:3A%M1]_)N,/FNRPM +M4P:9(^S3['^Q[_W/*+V^/RTK[%(?Y54,4\*%6RA$L@^7C$#X.WK7Y*[PTE`9 +M+A=+OGSTHNWHO,N4].&@X+Y$NW!M"6=?0PGX4#%[]9C_*F?6#KR#><\9^YYE +MU9.8G[+H:;3=/4WZP.V.OGCZN?=GSCB/*R*5?G*J>ZW6'J^NIF`?+BKJ]!:F3M*?2O +M+/R!CC;QWG1>/IPZY'BOK23*U&M4@L[JM0CRM!OE$YO"TF-B'@PE +MJRF\H6CF47?M;OPF*J;YI;I'*2&NIU)!JON`FYA#%^'88!SA&_M51OR0;8[O +MOVSANL(J,8P?'^%@O/4WJ4^S$]8N?P,M*2=CY\F8[[#@2SW!X9Q^83.(=).O +M@)TD"A\Z%$S8_P\TRPQG&/1_?_B^V>I/O.X"LY[`P +M4P4`UUA9ZR5VPZ1?8`P<-ECJ:G1]55S.FQBFIJBK63-X./#&=5)S\5!+)X5^;C`5L?JL-''I3OW]VTT_EZ_ZN;>&V_`N_ZS'Q*DDD +M]PBJ6SH,G]4\Q\#?I^4Z;T:Q>&%@W=Z484,:,R,8?@2Y^?+8V) +MPLF;5DO9+''%(L7O\N3]+^G_$8U3PJ&JU![?#;%:1H/!6;V?!O[13VPM@(XV +MX(?,3\=^;BV;T7IMP'P)N7R-T+INPM9P/H,S:-E#$G2X*^M\PR&YLUOQ.NYM +MR$&BT>,V,S%&7YA2@[F6EE`QRKF]?QY_9ER<6H5M=Y6!T-;8*9,VKTW%WV]T +MV)+@/H=UG^/I4OL2*R(LBI)"$C(DD(C(@V#:$VOH,3<-)7*SZ73W_(['F.S2 +ME*4T>4;QC[/<_EGB#7S_[+V_V78B`B1@?>E1#<^0IFS= +M=/!Z]!-QCG^QZ40T7/XWWC^W8\=4&4(.;SAOK]-IQR='][GO./,,[EKJK?EW +M]?(3,&Z@Y\XED)))(4/^+AQX7\ZTJ/G=Y/U9D_C^WY4^W5-@^-R]9V$QI%)Q +M!T2@C92_ZF^CN9G==UIR5,]Z'XPB,'JG99HL?E.O#:LP[0@D;S7_?OAJH$I+A +MU-&>&;=7EYBT4+F.AR=EF42;C-L\]=Q/8=X.[F?OWM1'.D3$J8AX=U=#R1]. +MF0S\N1TY6U9\L#`5U8Y#*3&!IC_[8/+_#PMJ-*Z3YJ.[0T\H[2K(VNE)MA:T)% +MKJBC*RFZLA&^?=U7@_[Y+2T$2F7UO?#LWI];]3?*&"G4E7]DY%G75>QUD.YW +M1R[G?U_:-)L`:W>%0J\=3#ZD9?=X_LL,8;1 +M&7$_7?\Y?XW!U"L>&GN+SNN_OYW#DFSV1>-)4_]X6SV]ML'(J5O0%=OMQ4*Y;]@F.4,$S"FP +MVF1P@VWQR7T?!JX&)3\:W(\-TZF->+_DQ<:Q))[:!Z3OQR;.I/&M:QC*J2U4ST/Y^3DP/#5+Y>A@WR)7Z:(G; +M[\"U`9="@Z0SW]Q!CO\XV$7+F2=.@A`J^I-G(78]Y"_4(F%"A43=73!@T/L? +MS+KJ"@X*7ZGBD?R6!V[&T0.5C#AMR\.=K-+^V^R][>N[U=QSQG*53?KF\/QH +M1S*ZV?R=-$MWM&=#PHDC;'HMZ6;V%5B5OX)NC3',UL?.X5+KY'7.Y>R:[_-\ +M>K>6^`-1QB]#<>3:O^$?/5L*@S1Q/5&V`&`VY$Y;!V=]H_3^7_O+;)`U[Y6#?M2\YZ*:\[G)8;OX[UN6>JDM2RXSDM1;*R-T7/UOK+$I3 +M0$/66BLW?"XEE-21P+YC@VZRJ(S";ZZ!DF$O61B8-?F,#:"L!Z>""ME>%#BL +M7`QMO4T2PHXL&V?\BL^,[^!T=D$-BYL=J5[>:]:ZJ9+S#JL&,;:$($O_B*AR +M\U6)XZ-1LI*2ILZ5-KN;K.U]R.O4IB8D&Q,$':/W#41:,S)2\++WRK6;)#)3 +M1XO@M;`/\)LUDXLGU;-62J?X[]-HM^,(H1#8_V4#C>D[1Q>6W^]R/V^B#WF +M0UUOASW&>+K?$3?SP\,1'_]"_6'K_0,2E<)2PF)M=L2K`[WVJ".&]SO.$K7@ +MQO>==F9CPL&SS6+QP2_#](ENQ'`=`^5W])JFDWW^U9M.FKGSW^0Q^2"=G=D( +M2H-7N=$PUC#(P!NU46KTLB!3EIU*90#-H$))"$S84]Z:_)SOQ.4NR5$UO^<8 +M#7_>O5]AY=E8GBD;/Y;^Y&K6!@Q/CU+/Z:/T%]0=/N$!TD3Z^ETLDD2.^Q_7 +MC^W:CJY.=\)"27&[1=U'LOD^!!^J[Y_@TGHE)/!BH3J!\O\<%"2W$L^K2Z2- +M06FP'@][+)/XWO8/^%2F55-#T*FTEIS3'KY!6O9,#\!(7-7I_!B:)CSSZIQY +MH-4FX#2TNSAQZZXWK1'T9F!JYT7W3GO2JU/]80%ZA.Z-HD5<>#ASI7 +MKY[AM$6/UZ5=O01+ZND-^Q71\K'STG&N#67*:F5:'S(-"<>;X4TY:%5%":D> +M0T4+,U&/T5&TY_X=CDOQM:%M]UZ$3EFZ7BG-XL$ZF,"VT`R+^4E%E))'416% +MDDHHR%0[ID8PIOPIT8[SQV7R8\&'#!\8FOO\@JAA?HY@R-'P\P'M7\VO]+(^ +MASL%!$)THNPQS'QY\=>E5(J'!""\(AR)W:O?NFQ;"P2_H.AQT5&?46B>>M-I +MUX\.X]/7CD0K_IE_IUK:Z,*6L'CYBL*&!JJ44H?',`5:&VO#P%CEM]MGL7LD +M?[Y#!X>S2`0:@$1I,$>XB4/W['-;EDTJ\0SG_?4O0&IESL!1BZ3!_A-0@/1P +M8B8]6@(<#FA7'I3X@8UZDQ'(T>DT^#FR'5B\W=,5"R&,QVQ<&DJ[[3[/!)2/ +MJZU"8^#DPMH?R5[S+85MA39CH"";(QBM3KNZFRTR@H$X83IK5M=[P05XX5>= +M7?)/?U,XPQ:J_I,]CV:7T8T>@A'`Y*0.'"IGWGQ8,T/`SSL&L40220A&4G+# +M7R9\)EJ,.7B?S_[U@EG,0HS3-R?4XNU=3V<(/CM+V;+/F,O>+#C:?-@7JGZ] +MEY;F-=+0MY>MIDS94]C,%[?FLK)TJ/1/84EG=V$Q$R:ICUZJ_?X8N>X0J(,2 +M'>3T]H2-C'/!0_V?Q*3HS^+9/UK\]-)!9.HJATOT9X8>IT[N6D\UEWL='R/& +MS-=(WE',9&)`L]G4O['P;!^C\U#&]JX7(47EUAZ?NYO27U97&A.F>,YV5]*U +M5Z^=[J%YU].X^\QBE;T8%!-I=C,5IFGP)V]_SF4>G,V:CBE%'/:"K2,?.$8# +M!L8%AN98RB:5,B?S';Y#D@"U**:2I^_2#!`(-7E&O1"BZ6_(Z%7%TZ)T9"9) +M6'*$?J1&ZI@%IDFBB/*__<4V:/F\HCFYNI`V2 +MQT9Z6O=,XN81D3$<$>SOPRLJW0H9^AT()I6"5CXM`.0BD@2:NE*\&4RA`>]C +M'8W^178I+B50750'[[^+O_0L.1\CQJ?+O-ATF4CW4$+45$,BA-@(];ZBU`$P +M2)W0(],.=5WY'LWM7FM&WAWF=]$DR4/.GLL(6GTIWH-$4)H/DFG!%K5B.Y];P=Z;6(R21Y1UUGHG#= +M!62:?,1:#JT^':71*Z9F4)A-X1T*$T)G)N8L](9L03'D;YUFAX#\\N4BS;PD[.+M+<5&PH/F9KA@KA9#NT$Z/>7P +MTV),..N_1(CHNMUD.W3#%JO42$M9%N)1A>^[6[#EY!D\%/F'=9.=@9,<]@/% +M`A5V7OH;==0^9JW<)M)8T9`BW?&3YQKX_6KX8R7#;&P:&-IM(L1@B@B**B*,$145%%T[,0X +MIKRW@E;HK/F&TG;?-O->IL`II,%\=%[<-J;++)H$_I/`[EYG:_(HJ\LY#.M.)1MFMA"YM(_^ZZGVV?59%'SW'KI\<#AI4&O1C( +M1O.'V]**9"#4C3/1#2'E[+Q\[?+_.?;8]+['_*XCI'LONL`X&[BQTKC_%4E1 +M-[NUC+W%U*U=2(,@')=9'!"ZBB/BC$3!]B:-[4"`N4Y@R?KRHZP$98<6^1:^ +M^^E[:%XJQ/(AEZU[\JF8T3#:8Z$I:<.B8IECP3(]$".]XL@6-\KMJ0P1=#&Y +M=3'LF>JM@J<[A.@L;2+0NQS\"+2G3.5W:ZHG(!66U1/-2@#P<52:':)J<#Z^ +M\>?U)O'[A`P>(;N;\07TU2^5G#Q'B>V$&Y6]\-QUH57,?L_>TOS),A%%+1!Q_)QI(GS:89,7-HV"`LKL>"Z! +MABCITF]V[RF1%L$7CVNV;U2O;BBE3-4$0[<^';@O'&-/V]G5.C,RX5NQ$2]< +MN3B(56G!DD[R%[P1A9%FS"Z4XP%FO%5A]58\JZ/9-$7?42KU>_*%\$8,.D*" +M`8P8SX6"N^)RHGPOWCO]NV&OT5A<@_Q.7/Z_*(?(M=?U>&*FF5DHP20>4-:^ +M1(\J1Y/^T'ZS,VSZJ7(\=`U<\0X28SR:)'BLP9THK=[39B]1E?P6M6=T+WC,B&C4 +M!(9G80P&Q#[KU^OW5;T8800\(E"J"JX-'!^9^>.[6N.O3/LVNBC"70]9UUK` +MZ;+E+$ME#4.%;.([)D=R7"IIF]!4A-3HYDMPLHL,:6Q+BY#"%@8%29);6HF# +M)TV!][T0^9M/A-=:D'G1*=@/?ZAX?-M9I]5!#!JHDCBC**FE2TBE9#43SZB" +M==FB;3KE[R\7CG'H=+:BJE:(HM3J]'8JCB+)[77IN?Q^=7M#PS.U.,*!HV^]#Z[_ +M5N[9'OV8R^DON%0=Z@<7C$B8P@5*9@EX^.[5$@9!#!HJ[%[O#&B^UST0_TLA +M>QHW?R(=+U!WC.7H(/>S#+)(H`^N00CN:#GRY!QAI^PJ\50MOOOJFD>FI.)\ +MWUDZX;M7AI[=\G)W]IB&5.UHBI^NI.`:\* +M9;*SI2E*K5/!-M>.I3$VG]/]Q.I.A\_G&-(;H$RM$E3+)&E%R6Y":(!`_!8G +MV]1CM&]]2/Z?.\,"F6(1WF;A.(B$SNN$? +MF$_QOE:'Q/YRQMAIC0`.`Q,EB9!0(],FXW'HL&)6PL!]06*71A"ZI@@A@H8' +MGES+8SC68AIL<4RZHVVVX9C+<<.:C41<-7(K6H]3NXIUM#6Q%Z( +M57PYW4,RL^M?!G"^#QB\+A?!\J43)V;:5@F;)$@I27)",FY%]$S`QJN14Y2L +MB**HZ:]6>6ZB#-VQ446=UO.:>=[NKB,RS5UCJX[5QDRQ=G)GK,II2P(!L8 +MZLCV'7@6;YE=*S93:)P>BTZW*O?9;FB[*V*>#%??>8)'D>GX6@2O3Q_(X(Z& +MOC9])U^EMROT+"6UQSFB6`B>JS81_52!(ZITFM,,4;A593^[(ZIB`T!:(NTF +MTCZ^Z6T_'W&5W&%35H$##=)KG90\J0Q:J#4,+#91.%%55?&YZ +M$O%/4HX*UG;`Z;4]UE70A6D"!Y-+/A"R'CC#7W\+#`MJ"Y5:5=G>LRB!WV6V +M%1M[J9._6B""E*8-,L74UK=5E,R^UT+=9^"\P7%\G+P\Z3*)2\TQS-F:)5C*!"SD)67`)`9S*@A`!$DHXF1_N +MV<#/=2\!`7680(GCWV##+Q#+5K(-A +MUF'+$7Z$N'$WRYP@H=5,UW4',Q"U?85SEG3.!K-%[5827G8M;GJXBG9GNWR8@T4M@8`56/V\EC"R)^J:1A6N!@32Y%N+6O+S4=2]=Q2] +MUY]_8N+FWT)^+8'K.Q3M'Y:&\>3M8H;^T,15I/QSGP]_,]%V!NYUMYMM`-MAU`Z!\.E*I)M"-KI#+R[-:J`H0J*# +M#KU,4<*5@EW(*):G?X[0:6P,*X#PPV.A5E8&.I"@)&,,DI0LU)/JC,V71-HL +M!2&V;'&2>P9`1`C2;F>/5`RH%S0M91!"0)$M'1&F.!M5F@9XR"Y,L2@2:Q6_ +MEI46UT0P,6X1*!$#O&+!U!+PF1WF=#\ODM!=K +M^8"HVD2&W9RWZ(OB*@A$,L&+3:E1F9CET!:$RCIO$#6C(VY.7*6>*)F=IX9Y +M_'OZE.WKOYO.&UY(]TJC>[VQ`@FCK`8ED)([4]KVQ298Y]3+01%+>0[K`7LB +M&[IXE]F]2AB)$H_F2HG%&K6>/4*JV4N'&5B+PD/13=$JP6!.Y&U@E9265((: +ME2V1%'U=EA-LLBAPZ7,Q8+'LA5D'"A2E("XH*W@PY7#3E02Q+(A6`U[&Z.S( +M_:-U*;X:];VNJV%F1$!;+7@:NFKO<-05(%&P#%JDHLX>M18-(4+?"BVAFH"W +M`<$HP(-"`RI:BD7"L*`DA0XM"LQRQ3;&G:V)-3#M!!!4ARIA@F8DXTE2J0+) +M#J:JQ4,UQ=G>(7-2$+ULZ_:OF]GBUY0DEX3,IIXLP.U,V#0^+-B&A6H#:SS` +M@+$76JUV%AS?T_;^KZK`?(/PO2/&=]^G=N>_D\#OJ_3?P]R$Z7:`M+1,O1[6 +M5X]0FT-3`O[B-)%YHG082Q*WP)=TN%-[]KT,T+`$>3UZ3.3IB:.73JD`X(&K +MH7FC%TI*.AA60P/(L]MXN&)"L](/$Q?S5C-R;F6'44PDB(6VGJ8+DRB,Q]J5 +M]ZL+B;(=B&'!P+I06,I4/85-$)()*-H47?F**"]SNQ!:EDN4&'*B5>,/]XBQ +M".C37WXH)6%B&N2(,BG&C*X2\#%6=(WLA9.%('`W!(LJI*SJ1=MD8F]"KV=3 +M!(<4R*-]X\6O&ID2)LB-)T('L!H$,'Q@;>K:QT*@^%31=74="2U#U +M(10@Y7F&*N5R"4)V5VL4`MR\Q2%2U@B%\-&F-F!#"$!O1*DV%65FPS3$0A#L +M"TNYJ.LGJ&KXE05%RER`40KC"8I(<$AH#59V2L*O?->7K+&68`_P_XGI*VO6 +M5K9%8+AX`GIZ/(@J'"FA(GA18@5ZQ3%!Y=/P)T^+P!L,RGQ*OQ(CYVO4T'@K +M`N"(>C@*@H("!"Y\\S/4P$M[6=W(Q9%+!%22[QMZW4S>PGWG>R-9:N^V&[M0 +M;D*7'JO/5^(=CQ0Y.^E9/!^@F*]/-OX>SWL/$[4O"6M%-F#;-0FEU0(26(#% +MB![#D&*O'#T?41T<9SE;K922:+@D@UQ!:)A#(%^$'V(F0P4B_N0#!T(HV.@6 +M.K:@S$D!;T,84304!F2,2$CN5JE((+7"G>JO6WP3B(1-LRH5[H[9(I@X$&JE +M\M72-A-VR;)O#5?VE"PMG#,U?0RUS<)7.O+E#^4F8O(.Z!)A`C,:8P45H +M6&@L^:*CH(!8$/U(J+Y5+0M&2R+8PX)6!!=# +ML)&DC[;VJ6U'A1%%NZ:3(T3KZ9H7*S4Y+!28D`D]<55!0+<1!NL,]?^9QOV^ +M(%07\TP/WJ9NH62OSIN<00W]P_6FL#>738;"0Q6#QUD@32&U@QET2S2XY7QKI\>)W25[+T\DFAG:6<'(H&A#:H8YC +M[NND_EDRPG-2CB/JQQD2@UZ]XZGS/C]C@$DPJN6A&\):,!L9EJFCHO<,^:_: +MT5N2D'0V=.Z2/@?^J\>.3Y&SDJM_6,#!`G\-#D8;LC9I2B'1$1<6+)@0)%"D +M73P!N)"H]Y.GMZ`]!T+B2;2&T#HR0L2'+0%6B=T)G@^^:L61I\V6-F? +MUC[MEZ=XX(::)ZE$&@QOO11BS&(QH1/YUN7`^M#7?WX9A83 +MN`-,,T+UM/-E>DSUY=0[B0O8*##;32"=)H?@_N::7% +MR(&I?)`-RRJ;'>="11B`3#(1!"`HC%%445&%K9!]NXR*'P)-/+*)+HI3+>U* +MDKUZ;PF[25)4+&"QM+TI58JBS2:>:V%8?IN@?II`E&\GH,>D5BMC8=_C:.#S +M#JR5_BC5CO,QP!3\AG"IOHRJU"HEH58QVB?=LR-#S$-4LH%3EB)"697$,H:O +MSGD4NRXF:!W[]$#"DQE42MC'"'>P81!@B$8D8>VT3''/`T(OLD9U)F"7\TPOH90OI(\.PW8O!.BLXX`Q8A"4OQU% +M53B"R4",%(*.7G*N6KDCB)HJU*.6SC"FJ:\._4-+L]G8*`DZ],AL0ZL35V%< +M("2*?T'X,-\XC<\)-O>--'!/MBM.'J#%"Y[]79R/'-GI8?JV'6>0L8/?<58I +M^*]>U-'JNG#2')H,')J:#G#-)8&+UH7_==CBX(N2^D,A^Z<# +MN860=E*]4S*ARF2^/'BS#8LAWX4.;2!8<[V65T8Q0F"+%""@HI(+%@LK(%B* +M"V>^A=]7U.998Q51=9A7"Q42VVO$M^TLZOQ'L=S>7:(G/T=VQW2L4*E&+44H +MQ46I:-54*[L"YY=M2DY0W?4F2.'J!YE);6LN"2=N4^^=%ZLI[*/47-MLQYPC +MVW0?9#2/8=*U7-'LI2#Z]`$LAS(0MO`XB@EMBW$7*LT\P+B@+(@H,Y\YV55) +M`#$#U2+?#LU%-H.1S21E5;%,L9AQZE#=G.S66Q,>43+Q]6458?S +M_AU`['K3N#XTH()E+[P%\6$)&)C;45N069CF.VWF2^Y/L<'+]H42J--^T<+WK(+<[\68VHA@G3_"O&MYC +M\TP[SH8E#CU6'13`)%`IM#:.G:S32>W/TQ`_-6(DL9:FV=DP\_S/'Q6=X==B +MA&\1!'1ZXF-B[QE*PCF:A^0C"W'I,C"EY?&`(DD^0E[2PF]$PS40BB0?<#[P +M_25&J5>BS:=Q7^.S=!F`48]:PW\PD#N]@PS[O+`'BF!_Q_>S80/K.>LYIV6O!9B?2>FLS\[-0+`MO[KAHU(I +M*X\"["_;'3PDJ7Y-%2R86"8IQ4=>7AGNS<7&6M??G]=EH$?DM7ST"*EA$7B#4#.*4/R)0.!TPE!E`-$GL'$<3KO]`=PX; +MPLT]IW\J>*]JWB.FI/+Z3.(+E$7$/!+S=XS2;?L8&Z.K30J;HN)K55@YQEAJ +MAJ88V("(,;F1((P453CBF.RF]X:TTJT$-EJ.+6V[LIQHL51W:@LI;%!8JG#" +MHZ9QA6$1`>%%1&5O%*I)IA59P*E8`LFZ;=[G;Q!?5]0>:T7D[NL6J2=2T6>= +MV\^D0Z1"G/WW#AA:R//^7%9[;-'P,-$N_N5+>&Q;8H:]&36D`%1#7E[4A*8; +M7RJ;M$>7XSW:%TP%R*0#&4YS@SZ)=R=M\7-GNJG->498T5""1=14@K&'B>-) +M)7G-T_MZ,.P38"OT=)2?$5YD.7QFF(I[3`]5YN&[FWB$2F5"LD%P85E;40Q8 +M-781BZP#*E!DF6"6%L;',+9O4G5[=7K3(7<%_35':-F8+>4[V-@=[9/_DS9( +MY7(WE2,\/9T3(!=@.D7(JB^HMDJB;K#9=?%"QU!0E@Q&K\'$V=#-7U._!;JX +M_DXGG)`)-1C@9-AN(T0"**#_LK@=3EC4G9+(&/*_ +M"V#]N(GV?H*D$D@E*+L/NR@K,6^5JWBQ(DX[.M(F[E'I\L[47=MJ%`>APHJ" +MJ!IOUZGX=/I/7>KDO"9CGN:P]S1]&Z+V/@9)HUSTQ+P,,VYSHN,8!2.PP*M7!FLNF-UXT#9_HK%UJD: +M&9F?(_*"JK!DV^&?@]-?1TLT/Z-DZ*G1C^9I_WL`D&GU'"*:0V/3=CP-]U+> +MG"`T(45\*I#5KWEV85=HR*%6-JF,Q,#;&^QY'U&WGLXRQO*GSXA+U+CL8.&] +M41S9XQ9_>C+[DS*B6I$(E&9?JK9@T-F('LO$4 +MOL>8QE&.CY$MQG?+Y&010@2S;T^HW&8C0T,('/;0'^4ZUG+,@&2C`U;0JM[\ +MPU#74+G[;UFSY?ZLM%.:4$8EI4%N7!7,ORM'I7>MS17ZL0W#95M'4.J895BN +MBF3/3T-$JC*2[_>]/P9*6=.SFZ\OJJA%)JKEXP3$XXMBS!7FU1F@=+5WJI*O*1RJT1OB3@T6A.("1BEF0_9=U),-U9>ZR +M=IR(+//G4G\JPWW4"U!V<51E)/.H\UJR!G_8G`HZEK]KBUD[RMBK>0! +M%!I:V!6^]=%J#:NNZ)W:PD9N-5.!MK>##J30?]=6-B-3_#SI,]OK3P^Z[S-> +MJKT9RPH_3M`5#RH2D3OI][250BZ4T+8<2>QJ9-"22Q`"(T.(L7.3`:I?B6

)X\C>$B*QGS/!1U)@O&1RM>28%^ +M7ZO*5#7]\M8KVK4@YK*-E.$(D&`NYWA<,4+#0,&Z)>B"D/B$A8BB-1$HF6N/TES(L1!RT5!B5@F3IXQ' +M8@L,.>5GK*"F)JM5*?EWKB2]7-W1H;#,X2=-*#N#%$FJES*C;7BP%S($,!F" +M"+-)*[I(:AWBK2<^F8T\F!L=G3IE\\SQ3P9]4R!UB?*>L)/>0DB@=CKW5$[T +MJ=Y?6.N0U*7B*QIK0FZ2FRGMU4D2W9^%SQG`FPHF:.6;"N0Y?PH8@V=?%79I +M9Y*OD][CQ2QG6EV7V4#0F9;'-<:E1!DRML-4JBKPU +M$CJPJAJFG6J,5)C15%`=1NG"."@C1E1;:I+;!NKD%!!$QM2L),%*QA%TG#`; +M1)^6BV[@D2#3<#J+R_0N2UG,MS,1$?6]%:BG"!;-!\SP@W@[[?6P.&J1-1_0 +M>FSQ;S.Z34]FBQ<)L;4M.I%_TM(4!5&,4D\'4'L]P4]52+%AQ.Z31F$1/_(L +M=0M[0=Y(3[6_'\BP%6**1$%@C/5Z/1'VCMSUS6ARGRL;2M^JP)S5(HT0VT%! +MQ*Z+,Z21B;$KH')"?W>JP/+,\@#4)0B440+!W$TF-+32*'L`YQ.!^-A0RS1' +MC5=%E"H(EIF5F6E9MNJKK3BALA^T_B#C^6/H+=-T&&;+.:N!_A3_/8;5%65B +M\E>U2KXZ!7\RI#3L#:]V\*+]/\V+>=:A+#%(S`0,`O-:"PR(@"P<5-%#?O_8 +MN/T7SG?BHL++5!#:;#=[,2,4E"%56Y))&.A8GJF$!0(0R%A<]=B*5' +M:Q3QO+72PN],XVO#A5K$U>=G:HPTUS*]BSII=*A/Y"'`1DC^$@B1A$HJ,44< +M+G(D\[52G3J6=="<7;.!!=-;=/&'?H\6I@H)$ +MK\I8UXDB/7%:9=:P%@X_6]K?&?TIRD#\O8T;9^C\/@=!*XJH&7/N=>Q/2AEUDE?P/?]K`V1>J,K>J8)BL59;6(BJ8A;4_"+F4K+8 +MT+#63&K]7=86<@=W;JB^QE<&3;%AH3,LF,FHDU>>4-=;K,-C.?NKSD)V0K:$ +MJB8*]/MB["A3XK1#]#6+UM16+K-TX>67.)1BZUES.V)89EAD&(2*YCH7S**@ +M,=@<4K4/.#M:SKOQW_C^5(+UUM6Z>J^SI-'B]HIGDV?`@H/3&Y)K5P:`E48Q +MHDK`'@1+0R8'%W:IX8;RX^0AA-025]SDATLO=,94E[]8$+"+?@;,\T#ADB10 +M614B+G$R85LA084?CI@S$.-S,MI/CLE=:*`8DJ4,$@('`$.TIP^(?KHM&AN4 +M9&4!>B9W4Q4L3?@<';7$^1F!G"S;4PK1G?T*9-(*-X32'#"<(`;XE%E+0H6F +MV2C(H@K';555BBCHMK601;*"B:RY010L+85WE9EE(&C5DP,?L2V!FRM+"H@9 +M-FB:D=!:,*QK;!+2JHI\:DJ%I5$$2&].4A+`8S!D%-ZIE1:97NEIUWT=C1%K +M%`@J8H=8#HT"FHJM*L]]GU+TZ<<&%TSDF!%- +M3UJKQMD704#;9OUI)>=)RVWOJ"$,QC":AF8Q)!MH4,K]TK.$X*RF&-Q'BVE'+6 +M"\-3U.F;-728\:,AF;89E9;BYAEN#3%\&FM88(U;1'*LQAE>F33(54`TXD%E +M9,4J&N@;R.7W.X3OVN4J^_A[.8"][SOL9V%$MZA.X6O2E$6':/0P,PA+AA>Y +MA=:Q&LG"!B9J^>C6(A2VVQU3,@KZ*&W0,=;RAB*+SJZFJFYK2>IKKDF8R<57 +MWQT1N[=6HID(2"B`&1`3H:#JX1@32O`%^-L#7$L9"H%:UI[;SR7=WXY\0]W2 +MCQ]\GX/RZ](5/?%V=@C!]@Y!5/L]M!CRC`&P%!IE>X4(#"?RH'GZEJ,>N4<5 +M-K_DQA4=-53MS2<0FZA?`1EDQOJ-%=>A`Y],]MF)I1BE5$D)$A%&0A"2,&"*K(&H>GQR?Q0]0,VTWH&&X?3H6`D +MU0IH9IDP9G!M68@?-9UBP-FJXU!2-+%;A`BP9--E&,VJ9!V;![EX[]>D:>YD +M_9JP[2$,@=Z105C0!21KYY`K!!%D%@:>4.KJ=M45E.R>?Z_SY(%D!-T][0H, +MT4#$Y:7$(A%,^'K(P/[=W*-8.33>_B1]3KVEN466MPA(_YO0Y::64$VBC6ZU +MP-318U+@KN>E.B>#[B3&"G1B^UK,-%I,.W3W!WO1TG:4P\4-HLZVD!2*B'+[ +M$,PX//7*`T7"61!Q]C+5'$^7NR]U/>M!.Z +ME0#C<-'J&J,#U#[9Y6,<,J\CJ8,O$W?$-YY<#+G#:Z=/=[SVWGY*>#%/%>^EB=+/,++/ +M#Q_-_-_1>!V.XE*=O4>,3JGV7=,9IJ(J)2^8KASUZV;E+(T<:UH7K'>VZ\D2 +MVUJ9#"(F031IW/3&1>P\1H'=RLVQLT-5;!3*)2UB`>V6:("!.G3,Q-U43,DR +M+`$>ERXUFP,19*!20+4(DD&$EDQM(]@0.!&)H0]MNV3$QZ,[OJMRJ58DXE"[C<8@/QO2@CPC,A?FGZTSOYO3.C28CW>'BSHZ3*900R&NW9F +MRALS:X&C8IE'0:*.")F7?@@&3O%=/&I!O032[7O*"K#BB//RHX\$38'>1?4* +M@=TA`@-K3;0!XB>L91L8B$ME&9FL0JI3-EYSR#0102$P$DWP"GNY)L:[RJ0;9EJ+[B7Z"5EZA3V^ +MD,!X^5G6ON&Z4B/W;W.I'(_0[=\OZQQHV)"*M=NT*O&9ZS<;#\9*ZX/]7@V/ +M\&U1#=*>-O^O2OX-I]ZV<-F0=H(W[?'+<>9NHP17OX-G?=DB$KRIFNR8Z&J. +ME&GV%S-A14]+0"[DR7&>_OTFBM1P\Y$.LMO)^AH3J@Y!-"\$;AA`0Y<2X,.? +MGZ!W:H=;-GOI![4*I=NU$:D$S2UP:9/O]D8XCB]W59(!BT49ML*5A1PUR=#F +M;?K;^]X\NW,)\S1PF"ZM8GY_5@_?6320H]=0>\\]"%+B&V!AH..\0,_SE8&" +M/["1%@:/N67G$Z[H,W]PA"5FA/1"&T<0VS(I&F:QPR`W00=1,Z1)!A$D1W16 +M1C:X8F-A<2IF9"&!%".8@+`_FS6F0#0&D0FLN]1/#Y"%""+#7$#0A&Y>$/98 +M4 +M'[O[`$EP.I5RW='\]I54O%G<,P'K?MPB[V +M(4N!;IL=X,H01B&!&(A$CC[S&E#SH4\T*.W;O1K#2>IPU"GQF?"3J1+S]GKC +MZZ2SZDL`6!#AHA>,,G1UCO/A$"AX-(V(1,.#,G7775#U904R8A9UC1YXIZ>7,- +MA2I:VB+)Y@^9!]8A\E#N8C`BH$%)TL-,F((HGS^[NZ:[%T:UQJGM0/D=9S,E +MC8Z@S^1"Z"IO+G)P20D^>>$:"?V]#3B%JP\+B:J0@B(]6C8]HS[%%CTG>7FU +M5N[.U0^NA7O=<-%&1L^]CP:TTG>;*6XH+8:9+_10KDV_1TGU9``J,%8Q17M^$',M*4(6D=TS\K`E&2P9M<17BS\OH9\'HQF6QWD= +M7#,F-A\F*LWV1]M?`RPZGJOMR3N.PQJ[)G''@L892ZNL*:3C)K87;J"9;K]U +M9H].CCAY.(B''RU'.8+W^5\<#AL!C&A4+<#"25E&"R00*H2K4B:COWT?9S># +MF!W,GT;`/U">]).X@\6BL9(/%JDI!1"0AQ7?-Z!4-`,+[7CDT.&DRR>KRY'E +MNKSNF:LH,HA=V!EL%A57&`1@TH4I:8X1,;&D0LM$[F0D.]5(<(3L99W(10O+ +MTHI%/JD+J!F=*!P]6FQ@&.)#9ACU0T;BQ#65M-R$,Z`IQ$ZL=`2H'>DAY.#( +M8PE!.YA8.J'K>-`%8*`(K)$>?"F#$ZMAU\))#T^K(2B1&!60J07ZCUGL(\.+ +M?:RAM/5G'\[Q=SL9NAB$[>U!C4,\'7&Y%KA7-$D0 +M((*QL,R#6UH`,^MR>IUJ]C+MT6'3333A2MK?2F"8<6H,[IZ0&>[(>'0Z.DY\^QK2"BO\EA0Q_6YF"/)QXPT!IF +M--(G3"O&CPWK:;FZ\-&"LTV&D^(AIGP[YSG"CE.69$%^&E#HP +M-^*?%`9@F(DP$8$E0OX+=*M0)%(*L2[* +M4C(JK`)0T'0#%%9A^7`H%+1U,?2>/R<-&&E"SD)!E/IT:-`:+H(1ZY^9E6/Y +MFJJ^X@J&7N^@6W5I`1S)N6[A+6YLK1B]3"JEPE"3\CPH7SG0WH4)*[7S.CJ` +MX-1:8I,09X5^+1+,65;?]VE9U>XL2QC;^!ZB">)A#3Q38VM#D;]9Y'4FG:BV +MC.U-2`\Y,OS?.Z)YL,GXEC=7!G7*SER5;]J!ZIC5 +MA1L-]N/HIX%*E)7:EDJQ"FM@KHL4;PX8W%KPI"PAF`G3 +MBID%)2T%W#0H@IOU9QX<\[5![#2%EV=NFD)(0H!LVVOR2O^E_X+1022.D`3) +MEP&;$ILL7RB!NF=%[1#&V.GY]2"ZH?.FX/1-^,:&%%PE[%&`%1%*U1E50+)* +ML8ARY<.)*AA;-I[]YZ<V1XX[>J,"-E8[LD$2DE.0 +MQ]*A;49:/URREEL9!G=;?HDQ7LOCO=0QS,E5?Z:IWZ(O'$I9+IRLTCA>2+:0 +M=F2BGI>R(@D9[(N&4WLDFR/!D%6RQ=W+M!EBDJQ=VU&;S&ZO?N?OO5-]Z0W! +MG3I79M=QNI/*C[S>Z_D]K@#RMCK\HXCR=(8X\,WEI1%YY5JD(22"*FGG9+S# +M6K7Y?164U-F164..B.OF0+2VR:W#<\]K3E40)E#A118102R%1!-NLOKYH5*VT5(2S0TX]L1N$!7P'`%B"\,0&8` +M'5;=936BUF.MZB46]H""W-F+2M+`B4 +M9F=M^'4"Z6L/*_X)UK4+MAE'.SM6(]'#\T8\E/8!S6QDH2KA2E?=#JF54B]V +M5F7S^QPM+(8PS4PU^R"3`AVAU8'">N:>=4!#R@)`NJ5:S65^6"T1PY`*$H?9 +MFU1>_#06H=YAG7]%=,:\\M57-?"2M=S;1 +M@EF?7M?Y")'R1M4#?J.8M9!IY\(ADD,"-NU*G<7P?QG<_79MI^><#S;JM`SJ +MHCVO6A1%#M:'&%/989TT8G3K3)FY,,JLWS?W8*FM6TBQYGDU%1]/@-%W[[3A +MZC;UG7NS;N?+M'6%ELNC"0(^L8KVI!!AJWSQ_)V<=`[M@0G5D]QFD(:B`L4] +M3]PR7G$_:N?/MZ?&]D*=)ZXJQ/8/E\6'P%"U\W/\',G4+N`:$C6/H1"CA$W56["/IB['XC7689TF+[-^8?]5ZL1?(G47JBE3+<1E-*+[-_DLH_&:.J +M_V'@56#F.U2F896VU;0#V04VW2D"D#94W1C^2P+Q0_9LA?(AH)":/I8-9O;I-!:9+3*]=R'6R2&O^YZD<>1:Q2*.H3-D?6>L5PH$&(DZ=H.[,\!P$ +M/-N(=.2ODO`GM41E'<'0;WY-9O@WF]J=FFKFI*^+A(,\-3K4(TR.SF;%QAH5 +MV$MC;/[JS!D6+JH]Q[VM37W]?NK/X%.TV5HSB2.(`#$:':-NAP`3%4)J5B6J +MI&RC9E`6!XMV,@D03<>I0M8Y32N&DE8*'\\\`&1L8PU892D,@Z)97=`-&6`8 +M(%/_HU8MJ9N)?5,8DR"Y39HYV!94"0#7 +M](B"40'?.&Y&0B&ON6"W&'>?"CF]?K3>FO\S02SE,%DI'L`F!N[[AP"18"4C +M6BV8;,_9X6#.245!L%-?N_*)!E60;"-("2YMW:EJJ)*D27)@*94M!Q(6J"+0 +M0I(D`F`DN1DUA#>9MKLU%Y[Y2)JQ896UTHS1(9P:)G\P_X1*+>+!K; +M%3BC?]/OS5%$$4&(CY\4Y,Y[9GQ_+1T[^W+4JX0,R:F=$IFMIN]+.[?H<8(: +MC'-!7&X1YC0N0/%&,ZBV;HX(0IW@ZHTVW"F;`HI4)E&V/JJ'FDVIV9[/=`TB5*%H<]X +M=J4"CD:A([0>>6L0AC3-,$5F4UZFV.VL\/,S55?6'XP@QQN[O;L\-.T:*-#9 +MD=*5F0Q&2$"##!@ZU(3D:;0QK(0F?`.^MY'R7^^/H"MRE/=LA +MXL=-9'Z6DF*:Q%LQ1%A*\,QR-K#2\.&#`&V4"[1=Y7^992 +M"""0(1"-@G;J*BHNB#!MC(R(RPJB&MK6F@(>W>R1"4=0%ZIX5`'&8P"-[/2B +MNW[W'ZGB46%A(P%+T,0XPUNAI(+(TO9,8`*PQ;8*TQ-*AS)W["B,YLS`D\T@ +M2D@2(E*#V2HLG#VR@J,8L%'BE;UMRQBL2U3O9SS>Z"G`<-UUWJIZ9-]T3-G1 +MR:W>L""E;46%`JVN:O-JK\-J#WR)(%.Y""N%L@VI;)40"8DE$EWW*+`FH>*S +M,E5BM%""A!+TT;'CCOV<2>SDNGO2%5"L[B'1ZO@DON7@=3D']>:#\@T64(S8 +M48X56#L:?`1?B.S):DQ0>?;M-\3X>+>>4F!G:%1:T0&C>7IA6)`+N&+JSQ86 +M%CMWZX6R&F%UAA_@:S0D?L1H`XOR56PV0W[0F>`#.ZRC&"(P=4BPYNLT`];+S3#+HM +M,:W])..L&L;.2_Y4;Y".CD%NW[ON)_48<>&:5I("_EW52(0:1 +M1)_H)!H(HH)`76G&CF5LW$BDL>O!=]&D+!:17N$F:TFBR6'WTN']F4+%V%B] +M",71U] +MUY>,^UI]-.Q#J_9'K]P\D5]#1^"W":/)41?;/`-=>R>3`IN>6U^:*(S.EP58B>EH;:@C:(O-NL2QC3MAGCSG-I4L9N>X.CHH/3"`_U_ +MLN,P9F-\O=E+HM&S46!>@?P>CPH-%R#&!S*8TT[G +M::LD\RU1C[4'DM?XOMX1_9^GC-B(AI0H#TJ>A,?&?#Q/AU&HI1L?M.->N2;0 +M"[,$^)7'[@4XRB+T/7&FNT0VD1UWN/+5#^J1&LK;AD@XH5FCY3GT*?5?>7\Z +M]>YY$C/T'RK./J?5ST/0CO[!F>GIZ2QE +M$I2Z^^0/`Z\\&I'I9/U22I5$8,2Z%_\V]6]3J*6IQFM.XO!R9(/$;CL[_=V( +M!ESCYR!KEO)BF/4N/90N$2)R,H#$:@;L0((2P:4"P09&#,.GZ3PIL.4)S^XT +M>7Y*<3JEZSQ]!.S1;T844$@Z934^?T*\,Y#&NUBB6;N.98;3$V\;M&;Z?QN5 +MA%UY1GI,4@'DO#&4SVPF=7)>-$Q&(89H,#@;$`D5:$2E#(HVJJ431DS-4A-7-550, +M%G;NJM\T7,D'"W!"D8A#5E0/!V16I(U8+.9N&$$:$R@+;D,5E0FB"19%0L2B +M6!?#3%%@VS,30ET/&4Q;2Z\G!XM3A^`.1D.K[FP>OV&+Z;X&G??_A;ME?.E) +MO.G!,$_%`-'\B?7V=CM+HUWOS=C^OA)XF)XI>G"$^#OIX%!1FFO3\ +M^R#YX)A,)A,)`$GUM?SY8C]BR<(5:8=-H57N?']'C9@T5-\0\K!J]S9^I9)( +MR'\DA0`XC7<+Q8I3M###9B-^&,8&FUW(&H+&UW.Z\3FSRMUMY,$N[SE]P@>' +MM;6U.U*')>7V%1W!QB!D');WNZ^[!/R*)F(:4!_A&?QHHB&>I1$1+`$\$\K- +M:+H>(M38RCQ7`VE3M<:&KM`&RY^B-WKMQ5;Q[H&""S7P2[@2;9Y8,/[ZV?Q% +MJ.1BQ^U]R3EI2,BD-VZ^^SS^=8>Z\PC`J2"D(H*$4!8L!9(LFDDJ`H5@+4%! +M1M%(?X>OY_61OT(XR>$DDLTW^TK4N=Y#ZLN/].TT^MKNA"+*[Y>7:[:>8/^- +M)T819#S0GT3+"(`8A!9`46DAL20V@2YE<3]J^_?P:QLN:;B!S-:S3Z79OQPR +M/"T2@*,`IFHB!I%6"#,4^Y +MI@5-KX&$<&F^-W=V"(K"!:VDJ08YQZK@EGQ-A;[C%FW]SME?;124**R*(22' +M?2P3!55"9V0PRRZK?%^K^#7E7YF74CB&1V]N9S.5S7US.]0[85ZL=D=6EJ+O(_HF#'.;"J-BL+-MGPP=2*I5?9 +MRSVF5FARC(89)Y[51=6&TVPZZL\,&1-533*N%OI'][Y>O6_`QX`?KG.(XLG: +M]'Z]/1LW3&D4'IH0PSV5^0BS#5-,[WM$WX0(^TY9;'=LVUY)6VL+:_YCM1YT +MEL[).(>M2$X5E;HFKO>&E(-E9)IN6?.=]"+/DKN>M[!7Q&&S&%):]0E""^B7 +MERBK,R[,7*MH**S:TC`=:Z/)%;;NUA"_;@;+8WO5;IMLXP2;O4)GZF&7:39! +M:K;OV\-RM=9-J?FID@G!B:4'_L/2@6H?JE/@Z]R^-%#.]6:>^V,IV<7K'5-+ +M1)-/!_N3MM/^A];T!/]I!\?S>E/A/HOXWZ^7`=VX0-UCT_%BA(HU8\51FKV\ +MLQYSUP`/5\Q!2FPQ0"C":D]-W_BZ[H\OU>PKKT9HO/".*J$16`H!(Y<44#IH +M-`R\8)FZ(N9JY2S$T(.J5CLHL*)%)I*A1"I!-6%-9AI# +M0AA2KGD3I"2)Q)W>@TA<6.@)/"J1`1N*8F`[L,8+`;NB-%(0U@G`-S +M$:#`1>9JYZ9[GY;4A(2--,P(4@(JB00@"L&#$%@R2140$5(1!D1&""V3H22. +M@`Z7U5DDQIL8--CL'RB@%>OLS4-]%02$L'&*DJ0+V/1$P;!!2P52V(B2^C"$ +M6*((C!&(P162*([#4"60U`$)KMVZ20-R!)ULE)J9H;`54$5@C(P1`62(HB+! +MB(UHE:D5C!61140A9!A6R0+"L64L**#*$^#X6>U$D@10@?!))$:Z#(PX<$[, +MWV`<-#INCQXWV!4^A:DZI8&+KO7OL>G@V*V(J]/#5=Z!R2(\7RX<^-2F.^6. +M\8\]D7[%&?<];[5J;R-G@'+?2+$-;V*WK+ITXTP=_+SL%OOMC$NWXW_?=;?1EUQ)WEL'QW6\]3:-[1U5$Y' +M;5FG#N[O-07\5O+[_%P.SS\AI'(+(*'TPWQ[\G;+D4[6H(@A\"`VQOBVC@(X +MB7%BJ436M$58=(.NQP$O-YWSLH#I$4-+%*XUY2@VQ`605H32B5448P@,C^:2 +M0DE&$#"#"Q$1&(**))((!!)K9<_977T>D.KL+5MD822+&,&#V3Y.XYLT\WVC +M:DX9:GR8A:AF&T0/T#1A!$($(`Z(!2(&@/L[HV;P8*,_(#4S%@?3'2(`0T*G +M"1J:E-'@`IEHI#&NGZ/=5:LX@-/Z+34\]>;X3:?1O+G)'G>73E&FG8GV;R44 +MT[.+35;XC)K:^@H,"M8W3B[#:`J3V'NKN[L$M6>W/6*^O%&ETP.A*LA/J8)" +M/'%LJ>"3X5!+SGS5(^MY^WT_0G=`":_70(H-$.^L#GL$993L4M5J9;LG5JE> +M7=[*F"FL+`LD(JQ476D2O8MFQBJH38@?EFGYMT%K(*JP;N=TH%W;O7>W7Q`3 +MHG/%GLT4,4J5/)@'*`9SZNF*:D)1(#MI_VMP.FD;\7X=_3Y*.9SL=P?A1VY? +MNK=T@]V\O'T/#O?L0J$`D`>@V]#HOL6.W`9KP,F:50^20QR`6&4`N*"#6B4_ +M1T%1RS6-/2F,#G>):V/19K?,?:@9:UK-$PW3IIFTP@C'?.F\S%-[.A)TUR\5 +M3CFVFKLR:T@=#(9&R65!)B)H[$T(9*=%051,`O&'L\J@^9=%T^L#"DR=LL2E +M69Q`W6W2@HQ&J@!BSI<@-E'&-_6ER)G:TFJ6K- +M=LUT17`6W6MEOM>K4H][UO14M4G+NJ!Z'P@%S8FAN0^.BWO>K4\W1QZM^E9" +MJ;<,.AIH^NF#.\Q4\1;2-I@1'*IW'3CDQO*I>][;R.,#WQ!,85Y20KH=LRH` +M'8TX!H+3:+,BZV\8[M$GO902%#'&,,4*%DHCIU7JS1>8Y;)@-MV:31Q;ML:4 +MD$%UN-O!Q8 +MEN2I%C4%]WHVY0D82FD>?"U-T#$PB%AZ%JI%_J+#[*,DBT]=%]E@H8R%5DC!/'OS6L]'ENY[WUY? +M:&WGPYP\N=(LS9WI//RY#WN58+*=IZMTM5<^&XVBU*01)J:5;3"(46%&-*,B +M9E*&;4JC2'#FLSH9.._?;?:F'%K*^K0F>=ZL&=4!48'.U2VF7P\-:+`#FS"2 +M2)-,(B79&7)L&5G7'.]^9XHST.==%A&+4Q.P(%$6N0@2 +MYWPQ5BA22JZ!81@.4E3F,N\$LW/)HH[&&3(8 +M/CVN:U=RMT=Y/;)U\CH(P[^W7D377J-WG!FD#LP\DTZRE-CX.*1YYN,UF-S- +MM'33PNDTE8+I%.N/H;SN@)*(`Z2Z1,J<"*H"34RE``8L"-N*@57+$ZTF2J(8 +M@DM20C)4\NR((S;P;;XXT@-EH^#3RV/0=_59:7!1.E1!O3NG4UP;$P@MZT@\ +M\+L<6J%Z&NFJP^^,$!2&0R8OLCWQB1TJJ@SLE>F1V`GM&]85XH*@-YG4_@,N +MV5':_JJQZU#Y+$CU!A!?LFKUM1A$[,9OSQ<7I$`QK4-(&:T8WUVL-/A^%JY% +M,T-`-"VD8@#4#&V%O7.V:4#[[)D`-)#/"7+F.6^AQ\>UYO`QC=/6#411`',] +MM)Q'(B^KU-R]-J$,J"40><(G9[LRVJ>;-%$JDP:``LRG#[M)-)*RF8021)JT +M2CSRRFM4[)+T0V1%KE,4\V=7:*046+O>!9??Z8=YN<>-)=%*D66%COU?/AK" +M+6MA)F_XWXX_/5ZR$YY7G'FEN:C +MP:*)&D?J.%N#VE>?+,P)#NE52-JY=9AKM/1>MC.5V*U2B#,WB8"(36=F1T*1 +M!6!^0O4WF(X0;B?A"ALI`8#NWIZQ*;=5;8\<*S2!&^D.\0\+@0&#@JY*0H<= +M[=KY[HP.]?IJ5S#.](TIE2`>N7:UHFTT9<,-U'5423:11`HS2!!2!JN4RR*. +MJ"82&"*)1D2I2,'FJU7H?$0O8VQ5,QA4/#$=T#=(KDK*[Q<2T&;[[X(T:*;3 +MH8G,9E"^(@\ICM*X(@`XSXNKWE4H,;)7`]4YOG`MC;`Q`2Y"]+8A.*9^`\_J +MDQPE>+$>>NE:HADHC4R0@T17P$W`Z*%4GS=5B.O%=9`NC("=O5WQS;H-Z\0@ +M#VKNU-CG;W4S=Z;LFRPBH+IMT2Y#T:UZZCS)1@=FZIMRSD;F^LIR;X`)V-#7 +M]!9`\5II+77='8\FU(@)BM58AYF-E>:[6MBTT$3AF'3&E9=**+:!2[7-4'9! +MBJ6Y:M=14*!DZ,PNB;0*MVG/1%F<_1?X=!"KT@(;&-C8R*;C06@XI?96Z&]% +M*Z"C+I%L7*[PA7QA>-%GAA?K"`32T+91.R"#0Q!S.VS[-\6V*Q[<(%VVZLA& +MJPN=MPMC7:U46KBI'3)`F+/]WTU?P\T!-\8V9:S..Z,NWE5]P0T8"C!I1!09 +M57ZI4'D.LN,12FQWPE;GJ;5KXVSD;>)\^>-MSK`/OG//6TR""-;+45NS5"HZ +MRA@L1]%#5N^._@UPA6+)5"#"*5)!!I%54^^'H`>Z<#?/35OGEV::Y0#\5$FR +M;V[EBF0ET3H1Q+,R*;*:NB[3CYW3#+9^QY#VNV9F.CQB->W4'<' +MG9`Q:;!'9*IAG/#89I98,E51]L)@M@V$JZCKO1!?CJ5`O*@)9--8VD;5"4)4 +MG*0ZJY=<1UO:;#/W97.M<,+8E8=+5F'>Z!25#'6Y<$:&[HE:9WTJ!2B%`;LU +M6@GA9S9:DS1,LF>PC4.2\IGA!LV=TK6\:X06I;;56%1C%"L]BS./GL*#GZ*! +MH-!0C-B-[.*J(2`$#;[\7%WD[B3@X@0(@BZ8L*-/-46)JKH,\\FD/I<30M1+ +M606@TH'1`:4))H$BKQ7'WM-IQJ;B]W'A0$UB.$:=A/%W"ETM`=@MOX5?'S7J*_/$0MO9Z=4?T];^KU?`Z] +M4GL?Q/,]LL\'GGE0];>NQL[$!J[W"_/GY*V],D>%>3H(U1%U(ZKFO4.OU_G; +M^_-?-;)!`-0ULW@7%:RRU'Q>_4"X)O]OC]#_R*#[$!!P$D/I20YKLL#B`0Z0A$(GE +MQ..[WO?@BITG/H/]1`WW>0^"9%%P+0XB"1C?A$1Z9#",V1(7%0OS$7$&@+)- +MHC'..^Z,B184:(>9!STU0%K!&('4@!L"GJZDAEED';A0&3H=(9RW@UH7N8?, +MRV#03EO3SJ$^.^`^`IYJHI2S(4U)2>9)$O,(?EF1(E%6$\\\/F,/A?"MMTV' +MT4N!OOZOI5##>`AIQE&W?P\PG1?$VZ:K$Z12[\Y1D=KWM/5'C!I:@M-Y?/U[ +M8&XN$%?J%\5ZLU3K6;P_5YSL94XG\?27$/DYM*""^$7`51)#U;FP\Q>Y:U2L +MVP_W#N:*-)YHMM!>LIF+(IG9L*)M./9*VFTO7=L94.]:B8M5%L3!.5N2 +MWCT]K5U5<[JYUIEVJ)'"!,SMS=\;Z:-0.)V2J2]994B04RH*S/-LG&(C`6AV +M:^)"Z'7=HNF>-*PUPNWU3K6EJ<[5=VP/5"CI>S&5TS>,I$^HR)KNLXZJV2_2 +MO3?',/G90J'#\POH@9G:\7#4@Z1%;";6=5<($0X>RTVL/57RO$2GAL+SC[M5 +MO2=)5=L)8Q^'7'X=;_G[H+RM_SN7\[=O7H/;*56_?,W8KA&>#YE_&(D6D=?- +MK(\V<_H`/L]O='LFU9G-5QF[>]J3=^(C-IM)O[Y_T:OF(,SM^J] +MZ6V+1R?ULT%>;#1@/F(9]+JS"K/2D[#*.W7BU"#DK,EN^IA@5=G'1KT\>:7& +MBO8BPWQ/Y3R0QMGXI;YYI\A%3*;60]+D_?!8#.CC]ZFJF\U*BS^\/QV5ZZ7Z +M#?16/OT^3C6#`P89S3FL3\^2B;\4H!$;#A2@CHM[A,'8[M`*S58H200"?$2MPAJGI49) +MP+Z*.EE&4H`E`!4WWFX%!I%4"B8Q0091=)%]>+XSOLU(Q1OA-2'X-%#T*7OZR&V2(@ +M=YBQTDA2A2G.#KA:C)H`;H/M#:WFW[Y[Y[^I,XZ;,(3HO%T@YRC#KUQ@1U\O*O7"09[& +MDMV?10NVEM'3[4K'5PQ`S\:"V-M>A0X&B,[5\FU,;FIQQ-&H(2E!11:_:JZ: +MB.!:L.!3@VAE2]4CFZ]!U%N>E6Q,L+5:@Y\BE.J-JPJ8I0F**+JT`20,Q-=> +MMU/6SB'J;ZD*3IDL`A4L*`@RE[J%;HY8)$`8%!@BE=*EC@F):Z9-[0FFO<:QQ2!?;0&QF#Q-QDZ66K,*EL +M4X11EE;GVGY+R4TE1>H:PA_N*E8C^]%RKCWQO\0EOEJYGCH +M++:;IOTF2KB=POSK`,`H@[@=<L9$Y&*CH&2I#Q1,KY+;5*CQ[+\<9&PR*X1"-T1P3 +MEN_JB5'+M=QAUL`+W..:7*BS>EL"E,H@R(I"REDS9W;HH":'MMQ5(I;N1CA< +ML+5HQS#O>:0-!P3)Z!2"!*('2RTJ0IH"=I10:%R*("!:U2(WOS/8R)ZEWLE5#QZD7VX"W +MQ>.T?3I\53:U;XP9B):=X570XO-=WS+DA;>9@YV==;KNS0V%SAY$.& +M;97K!K?"D5;2U?CMF^R2!9.40,=GZ#L*]%6'TCRX8-3EGBIO5JJ$+34R% +MS4LK%L35(FI:XRP1D&-)9D+U?X]+=^U>%;968:,^^J,+3VWHS5$F>*L-V0@2 +MK$=SR7L$=H45="`H"**I#29VVN02A.D$%T74M-4B2(<$$#" +ME3+BFGF0Z!EX/'A;4=!`;A>R(AD+/`LGEEEWXZ,,]"\1CW[4 +M><,@5KT-L7=X%-'&Q%D"V"P`;*9P("("%3LW2,4*,HJ4YKZNLC1R8$1]'H[+ +MOF+N6!6THB?"B2BNR6U*NYTCCOZGQ6XNG?$+1T%6RT2UY_.&S`SLNNEN/9A[ +MY0'YF=\;G#6;B[6$#S/JMF2S-;.$0CZUTSB>TUU*XBBX1B(:P^I6#:<=:WDM +M*L&O=VP5>)7QSA36O%\Y#1OB`W+MWKC'!X/`N]D=510<%-'1ZB-1-[O]OG,Q +M:^E0V#WQBVS5KX+MUWM35J2G24]U`GK4Z+%$*=B[YG_I?PRJAQ'!Y@B;GX7% +M;LJ9)_X)M&!K()K(H:#S3U7G];#'OZ:O^CR6HGSZ7CU0CWA`/06*Z8$S&H[D +MLFKY%_EL[,%^@-R@8>1ZH8-T<_+$KOM7OX52,NA\N@U@&8@`2!DP#OSF*5&\ +M$/C[#MNG_A\[=L78?L_\]2&KX#%\SSL"EN<*EY1MC^TN$#!DFXYC,L##-Q2$ +M@00DA!`.$8E=[9WCLCMSK/V3YE]Q>[ZREV^RB)D;,\;F]/Y6]ZRG^`HC2SM?D=%_%])D*!?1`M_+NA\X_+@'D;T+>O/6T +M^Z9[_W1_PVEI,D,#"5O>P^'XF:I7M/7=`83?>]QP-3RJ+@Z#]WOJQ3I^VS-K +M5%H0D/)`BTRENBU#P?KU\C7WL..J$ZJGH*A&Z`J;+>5.UHH&D4D8&622P8`L +M"`,@)(!!X^UP^[[/2\T-M[58O-BZ?]U[=DB*'"YWIT)O49>+FA`1D!R222RX +M@7\N77FVIV/"5"#=.^X48.JC#A=/&%@O24G:'8P/6&.8#[XS!VT0?YLDT691 +M9Y)RYQN2@&3%#@H(-9*P&)%!$J0*DJ`L"H$&*D8*0@I2(B>0Z@W'VM-O. +M=,QX^K[NO@7U-G#7PAW(YVVIGKL1)P^\&\F9[MQ_M=^_9^*_<<3R,\RO"9YJU,[RBI(_7E7XD2$>ADC-^Z17UM=E4UWY=21X/0UD)""\0Z%%/S"4RA41(/ +MS_VMQ404%/RO_UA].PB)!A'7(P3V]'\K\;G`2<1^YPZ!7WLO66V7#6*:A(JJ +M:DC>;$L"93&MB.=A&$B<2@3HBHQ'-A +MYWXJ<2:=T)*`/Y'%<6FZWF'#ZY^O4K\Q]/D+UIN\A[7(\E])S<\\:`H;AM^\ +M%N!O7'6M>!]5,&GPW5+"A_W;))]X,)]X@L4D4D%""@%0*RJ1"I`*D`J"@5(+ +M%B,*,D*0"0`D5:*$3LC\=V%LAJ]E*_6VOR3;:BEJ72C\"2@R;^-B!=FLX&63 +M`ZLM6CE31ZV]_;H->V7,RKKJ*U0&PTP,\\C8M>')[>W&4/,306L,)'L0/=OV +M=-%#M?NW%VNS^I*4LFIG0^TJ=WON.H_@#\@,L8J*3VK! +M446A;&V5M&HT%1@(HRJ((6B6K1*UK6RQDHVV):,2E:_D?DOX_X__7Y<=C^;. +M.QGL/U1]W_/Q3])['QO9*"YR8?'''<<9V'5@&+RN.`,Z<8LA1`J(R5E10BR0 +MD6!"5`;_(_YP?^1^[$5S2\IYF7-?E.4GUGVX_]"AW"=D2/QZZ%1\ER*@CZ3O +M6UG7QY[+NE,M-.SKW%)(YBP]F6*5=-M8=O+$M)2VC'Y?W'NCJN@L'VU+_V@J +M4+Y)LO1_`>Z+OC\7UD>Q)/I>K_%5C%9]'0W=T>=.)%XJ`2#Q<0&2$$9`&161 +M82I`M*18!619!%96!`=,PD,D`-T1L*4^QX@N<)H;\_+>WW0;8G]&@:4Y#R+X +M(2[_RM2EML0[SM[XP$8"!FX&6_//Q_X8I];YO,G.HFHZ4G]5\ALW(#H.9`4< +MKX)\8G@2T>.\UK:C8$;X#A\R:3![4`9$2?6MPD1UD7T*"-<5!*-*B@JT@O:B +M%]%44MX>'=:"N;BE`[3I?HTY7V7.?6XSA6'K"_/%PLKS]LSS8!VV%G-[SV]; +M[QO1^`;CRSFG#A0[?[L4-\(9W6XL?3Y!I>S=02`!,9Q_-L+O>['-5X1U +M_1VSE,YU56VO"NLZ5O6[,#;]E\7>/\L(X/C1QQ*7O8=A"+KL-+^3^,#J(RV" +M9']V?7^OWG]_U),8GXTX&=^._)'R-GS+S3^][UCS:E7]/VTNUCLSOC/:&^/" +M,"UW7VCK'4NWSQGNT43>KL/H<+UOZU#S]E+?\6FYKW:ER/4URR*1.X(`XY(1 +M?HE9)&E(LA"L"H"P`K`K"5*0"15I!2I?![G@2IMPT1INOWW?6BPZ9I?I5P^A +M\,VC#!,^3_I1.7AS\"\(]5TKUAF%4#3X<.P>K]-=O5NQRE-/6RWS7^<=8M'! +MB[2FRH4M3UZ-3O>NV$Q2QCO&\DGZ$C,TBB?Q/E9J+#:.CR#AHMC\+3/N>K^R5N_CW=?>-_M>?BL-BH4=Q_PX5!'5KGJSE1L6DT($ +MQA1JM;O/GZ`Z;^:CYE,C_3[^?\I/9[J;/G?'V>RBS\->6B,KN8\$ND:0DD-^ +M],VR&9A)B1K^1G;Q4^T=>R9[W'P#4:OCI_P?;X?11/D'$8]#5I/M#&\H60+P +M&(#2P%#$D$#24,9A)F/DR-[)R'X]#ODAASL,%@(QZOYG6^'+"$-E"X1C]SX6 +MVAOZV"VU%6CD_Y+<PH<,*[+@3I*9WZN)\X?A7.P\_S-F8!-?XU$[+/]%[OMZOW[:^XS2& +M/_N;0^1F)GVW3)?_9,CJ?,A%],5ZI6ZKRX;`KQ^R4V*K,(;Z,@O$EOCU#?,X +M(O7&I3N+30.D@RM96[&_-)0)/\49"=6$!810*A/^FW$`K +F"+`&FNP%5J%=[MCO,A9%D0D'L8&%51TCE#9?_B[DBG"A(9GC:TH* +` +end diff --git a/contrib/bzip2/sample1.ref.gz.uu b/contrib/bzip2/sample1.ref.gz.uu new file mode 100644 index 000000000000..49ab65ecfaf4 --- /dev/null +++ b/contrib/bzip2/sample1.ref.gz.uu @@ -0,0 +1,848 @@ +begin 644 sample1.ref.gz +M'XL("/:]F#4"`W-A;7!L93$NA,_$ST0=\,%= +M^1&7:'60%:P"]4'=6Q4!E2M>4'%U5UVKURO*Y;X_W_>=&]\P +M_OKQ"VZ$)Y;$7L2?Y^'/S?'\-_?-W_S<9]?=>G-\+?WS)T]TYIO[=I2.OG3) +M/__[Y;&7Y'+TWW&9PM3<^'E?NMBNM>J_]HHBVUUZQ3=VEKU*X_"L5Q&U4F/] +M!VVYK5!J?.V[C3EP"GZL5 +MO')IVFG\6R:CEFO&GCKK6CM#K\C-Q<;"3RRWYK?6?]`1?OV6^9MB'WY3.N>5 +MV_#TI&OY>:]3__6LV&KY!Z3MNO6%53]\-3STA3/6'3WIM-^N>G/L!#@I_L?P +MC]U[6=5UK&(S\;T]N^W9QET35CE;OVTD%H.7/O727QW]JR=_\8:Y\$N5ROC8 +M(=^>A>>N?6/&3Q>L8MK*I*L'Z@NO_+T#;[7GWGGTU=[G;SP<6PYOX'_)3*$\ +M<>02NV25*ZW[)@@57[RUTDZH51M/+FRTOC2K^S&\A^5Q>Z,8Q>7&.7..U85W]Q:=&5B.WFD<]V&_<>9/',"[ +M]')RNU7,B&EA-S8?]N$KLS0A[/V_?-N5GZPM_73@P/S_?W.H_<_0UE9$/;3#'7(H8G?CVYN;STQ^::ORW +MR_W&LILJ92M32=?KS;F#*XY<7'7RS]@JX5MC5F1&VM,14X[0= +MM#6^(AU"40N@Z``4I;)=@8?HF&UXM6Q?5W7*!*S(6&4[5W6!L![X5F443HB@ +M$?RT1`,V\(KMY*XG"'VPS>;#7J7S\3W3HB*G.X`_KUP35E%FX5I:`)I3E#;C +M%!!=%'E\U0'<^@A?E?9,BSW3TA:5QL?Q;WP?[M&2D1,H0/@<&IMX#C@Q@8H$ +MW4[<]3U:6\PB)*XKLHW'/V#/`.EZL@1?X'9P/U-$('K#8P$*BQ$1T!IB6EJ^ +MR'7.!'YQ[:*8DK9&SK13!""RW?AU[_<]H,;9:49>2@(:JITG5Q:!.BJB*HN- +MKY]"WR#\^+@]HVA7YO'6BI(@XK>/<87AHPMS<$FG5O"4Z$K,C0$F'("YUD[< +M]J@E@(UK@K[,R.FBU_CIW:Z7KPF`D'&5<:TR[^\`VH1K$7U5K;PM,L!9CJN^ +M](IX:Y%M+<8P4GFR\7)_&D[KP>:SOD$T_>T4#S#1POGP^>]MA(^`7/1#!`;Q +M#>`^7V1:GT`<$V(0_X+5D0R4$8EZQZ7W4FI7 +MBUDQ\:5/*8Q*OV8$<$$";_F2R`Z8K>JWX)KQ'))DF337CP)4EIGT;50`N&6# +MB$`"U>3+5L%/&8F4<:M*#*-TMXI\Z677(?KCLTFC4IABG4KCJ1R1F9M+B?%U +M8V-CPG7HOD@*NQXM"/IAU;U'YINI6.SHZJ\^NN/F&*A2^H_U[=KOCC=/_-O8 +MMF*CG:N4O<8[8MG6S;&J8/U>7SAU+LXO+[O\/]]1,WH75$MY?*P'B%U\VFXG +MS[ZA9(%V.:,BLJWO[;$S%LAN_)1$GM\8/PS8@GO.PK$;7ZM;C:_$@/,:__E0 +M!MFR[$D@%B*4NP\C9<*5M?8B(Y<:9\_;C1/N*!.%P8N@A/'LKO7.6OT?":Y< +MM?5$N0C\M_@TP(O/N-W$7760.H)D3F/R#."0HE=I+3Z-S/!TW:W190CD1P!/ +MHF"`3]D@`@`:3Y1!IR\[P\>[%J@*LPTX$_S#]11$DV=D@8JLFB_I:04*05CJ +M)O[7'_PJ[`;Z7J+P>Z)L`)'V2]"2:.$NK;T`"%QE!>#W)"//@XI0OO\+)64:\/&SIE0IJZ&[I- +M039#QJ.M"(L`.7Z+)E;CQS$EI5*`-D8NTD1*`>B`Y?7(52Z>WCL`E.L<0*IZ +M82H8H!O<1(#E`4:$Y2`C`-Z%MR(M+FT^_]K;JV6U&AT<.`XP>OIU%H&!*(2/ +M%#"EUN!NW<2;/T]$4$)-O_AT%BY.CL!Y>)LP+1D91`=HB1JZIDI,`2K +M)20=^)%PAB@:=8JC^GE&D0(#2;R=^-CG[9GF\]<=MMPJO=(A*@?3H2;HELN- +MU]Y!?`3&6.1!U&LI,0L'+@KP)`B:/@6S1V=D`&;$.#UI6$7=(6DF)G"@*=B5K4=<'>$`ZU&O +M@*!;3D#D0/HMN%&$GLZ7Q2>9).!'8#BKHZA+&UQ2B4?-^?Z1-($6'<4\D";B9-G0-+-Q-_LSJ/`=OCPT+HF6 +M\#R#MA?:9RG-?K`.?(G<*$B%@'-"[$QG+!I,:.ILQ^\9+YDSV*-#542(W=*( +M3Q**B,7SP'#G0P/8`5]I=N3OJBY>"7VA696EH#U7DH9/"X@*%GMX$@4GD"^: +M=,3VJ+?;B5W?V,SKP3(@6[QJ?AHNO2SX$"!%P&7%MVAAV*:(PG9`;#44IRC! +MI9`O\5&`D?P,>`+]#*WMU"$UKS%(J/B`D"Z:)IL(%?=L(*.DA4X"D!#K`T&T +M3E("M1OZ"\CMR!S$GYG*J!-5^.Q6*ID-M.>WF(NR`7DQR2%QU>OU?\!X6#SV +MXOZ\]ECQL%VQ6&^8+1A_RC.V8(ML01;8DFFNZF9E%'Z;LI20%0I0146)-%7`WJL*L%OH*'J*5R"X-O4LWN=9SBJ6J(/:_4()Q%%#+ +MOI'**G3AX&DC=>"J^3:$)XUI!%J.S1RRQEDAA6P(24BVX!"C"B)4!6`<_SAV +M(-5-S#T^0UISU!J=0209W=Y2NEVM90FE'E08(`)K%AA6YCVT%N"K:[TIDN=P +MB6"$(Y>PP::V#_DJ[7AI-$>H41)4.2`I@>8\6XI5(&X7;`X4UX51+S>*.$$N +M!U]>R5-%-1U^4T84$QRM@'86L"(X.GEEF6M48/1%R:-V_$T/YD@G9)3IY*?% +MU7CIMM(;97:F!%H5:$0904Y6!*#MNBI&;XG$`ZM+BT8QW,8"8O:`RA4\;'<@ +MQAQ6@\!83-#MI/TL:1QX(T?^6[5?88#=H_T.%-0@C%QORG*%T0\2#078GS[P +M5OC&7"#EZ07&!5V'!HG(`VWH*NL#I(%V,O^;V4Y@42!B""76X,U1M)=C=.0A +M])D-'-RJK[]6*4XQH.P5(!CK3W[RYK#VB2AU1N2@5M5"QJFHZ.W`!N>`2.HH +M'"ES"EQ4=0WD["D0II#""4G=^(]_.52>(Y,P#Q*;S+"9A$(`:,:K@EZ8`G[' +M0`$H0'@83J^4L_'5)`B7%JZ8DC[Z>3D\E"(LI1X!?1HFHS_*J.R[BX^HNQOL/XJ0CL`8'-PB7D/!UZH/0R\* +MV:1-O6Y\ZR=)2Y<`)LN5.OBP`>/HP_5G"U;L:/UIRW*J#6O,,@L`.4\+\"QD +MX%DH`]2'F\]4.9`!`"(/@90)E*$68^@CZ5#*.SY*L7T0RDI>Z,BM)4?FZ#JC +MA)N2"@SPA\J@ZSW! +M*3J6#>GE:N7^@`T0%O^$W0`^5F2+`*P;`:&^TK%1`(/"B(\B3?!(E@G+1 +ML(\R^J-Q$_5`P;`M[(Y<,=5!@R?KA/RE*>(>E"1P%6C)N4P3"\]K.RTL"@BQ +MPH4(1LK*G`#2WK,6&F_3KF7$LE\2-1G)@BBG]S=%4Y!D0F^9>6DH* +MI^4V5,,>V"M9>*LJP.[.XCX8)-GB6AEQ@!EVI[!K?$`%U66>"6*PW-RY9?T% +M]>:IR\[<#X!^XN\U9_:A4B<3^(8*\)F*?C$R!'M-08A,+P,81_*A2^+]MEOE +MB;7UYNDGORTU+[?2VQ/C]>9?G^+MUP)`Q7R2+[F/TT"D/DCYH/G%FDTJNTN4 +MHU1KR"HM-S>3+ZG3S62PQ`!#%H+<$[N(,J"F%)&*&I-`A"\I8,]P#%\8+-[S +M/XS6.XDG!`<0" +M4KY1BQAJ8$,=#M5._G&71M?_)8M%ZP'0KON +MX?TL\?AIH$71Z%^B#3)BV.@3LT6*=Y-@H5O)`]A%YIZM&/L(\]/'%TZ[]S/YT._ZO?\]A*=!'[$-Q1`0S +MQ8R$*VRQ7;ZB^:?)TVW`>4VI!*#A?73#VEE!N%;Q#ENWH^USVNV?W:_`(2I! +MW6"YOB0&LC"W*@5.^$CGUH`)9&9-^]O$]2P19O.!\&BC*P2L# +M4:N1D%3I)GY0#?2X/B=&N%7Z``-$\JU(R7!<"H:VR,U1#.B1I%UYV)!O$,]! +M=2.F2:EAH-J7MN(WX_IE91A?GE%8;#'^\AO##0RG.&"=ITSD7;X^+7>%<3`Z +MQK`)"\RJ-FUD2.^07-I/O6\_L62Z,!GSF%#NP9QN^I/,JXYI\^PIJACFP +MYYE:0ED$520@%!_+/+K1)#Y0QX0`8T[5A!VDX30E^^GVTM.S%]=(@ECE#AJ^ +M``6F!S$`'?`N02PYKT$0BZ'@1DRI`3&$AC>*ZH@3K#5S.SDZPR+1$F!"DD8T +M%C;I$94\@N>FP-$7%"#MPD_&@/HOQ$"9&X=9WUK/9MB6=\CHQ3B]B>QP58-< +M$;$-A'$^9+5LZPJS\%4,@A,)D!(Z`_PICX8T=38569W$),8U,=6K8^2)%Q2;8N^=8B%$\B"4P/ +M"N6W8<&CA7C1AVTHV@-KGF/BF-)A1ZZ=?-L#C!]MZ02B3SH=+?J4F@+'6+)W +MKD/6*@<3UN)DG7%-AC1E&VFQ+2@O(=92>D-[AB)CJ=J$6SA5ZH)JVK50](JC +MT2@D*RKOZU+88(I88_M1VF67T4$D:];-K84#*IS!6CJKM^ZX=$TS +ML:XI4,9@!=(M$?"_FE\@PQ$4,]6Y"X&T_&1 +M-U/X)H8="A@WKB@!!6NLTT"%L-5=>M9/V&>VG&**'0'0--I%+'(@CTDHHZJ% +M[#DD6EV@8T>>T$H>9),'EJ:)^-%M1!=*MQ/W']UM#L5QN8BX`*G0A6=9TF0.`&(X&',M`%*.B'I)?T*E:!5%?V*;?8DG--^-W/KOS,K*_/_$@ +MFM%W/JO,Z-!]!%Y\J&:A3_2QA..8A]2L:N+L';H?DZ^DSS2(',]`0J3D&&$7 +M3&M'UQ10L#5D0*"9,%!8H9%7D#KD(U1<96'DW#NH1F1S,W'G[7A;W<2=A[@D +MQM0Y885`?U8*B0N>4!)<6R2%4D7)1PK7A@H2]+4,B%,\".Q&%ZD.'4U4^MWX +MH4TF,XL.==X4*#""R?S196!(?(&4TQ4S8&6YAARXX*I2MA5!>U1>8[P5'4]0 +M-H;FFH(.Z2"MM!,7O#U#Y50DN0B\$:"YM+@B))B-33I(#\RZ6-DIIZ-R.5_& +M"T6_+)-!^Q&\.DS7PY$Q1JE#T2$2)CJ8!&F@9;QPZ!&]TJR?&@:4%2[0DJ:VI(:;4.D2&LP8(-4Q!SX`BD>WI@D* +MB-8J=Q,?^]T^#%LP8ZR2IM0,73!-2R)<4$@%KEETV(GNN78%R9_4CTXYH1K2 +M`2Z23MB=U$"N%$KSE,*?'P_?1+]R8\-"7L#":-.$CPFL/V +M'!;>P;EF)!:NO>:P5N)L,I`5#U_;*7P8_@[2"4RB7?@XFD_@7A6ZSG;BPU>A +M,=-1!K-*CS$Q$"T#;7=(A&-Z1;IV(<4![8S567A>:9_`[F2'**?<4AXAWA$%4:"\L6\*3^:$HX&P"H"GAOL0198\,,B9.N(0ZNW%2NI +M]M)-S^'?0.N5-?AP#].;!4^'WEP72]/@\RG:WA(3(LQE;K\828G5:]M+?GCU +MT1//6I7JA#M\_-KXV&)<]-8*^O^:^84E[WG^Z,B59SWU_M@R>&09%R3[M0N^ +MN*G>/.XK2WK&>LMFM?=U\>>NK:HJ6_9O41>(0P"\Z*%?PZ4Y')^I*I4=I$B! +M(+)>%>33E+$6=;9D\"3ZPE,"E(0QE(A]N\EK.U?2*.9(DRT*BRW8!95T+EV/HBQJ9J*;F+V`"5%.2E1#)*/H?1\ +MM&:LI<4`\X=7:'`A!.$$=D3NH\7`F`F8&C](RTG;&)5!4+$;?_\K(D4:RBJ0 +MPRJ^)"78N$2DQ9DRSDOY"'39-;XE;+$:QX`N@.#Y:PW?IFV_NY:+,RG$-CR +MCW)U0CM7:3SR#;^=_-L8:*<9QVK<')MJ?/^CR&F-A\#Z?$?,;XS%0!'Y]853 +M?W`UK7/OVO1X<\5[_KR;RT>^D*.L+?;7;=$5)(V[)JC8_Y7JE=Z6*ND7K^JC +M9;]P%$SF:GXZ]4(5IBHA%W7BIIQ\GNH_B/&"D"3:^%Q(2DTPH8))H_:#HHR. +MSL\T$U?>!F;E4V@*M(L$$G&!'*U\"A[7%9`?F^J&W_VV9)0:KJEZZAK,E/+L(4L8=72 +M=,J8;E8Y@Q1XHLUV'M.6<9(E53:8>G+P&3@&0?OH<,>A[7!\!4V/CX!)`==N +M)R9_RM2E,;V/K=+2JI1.!/#GIMSRT$ZPJJM96_2B+Y)QRO8M+%"8GU_X\]N? +M/WK<]\7-NXQPQ7[)"^X>K]>;R7?YO;1JFXG$IRUM1++\)RB[B<^E#VUO)C[W +M5[T,%1^PJ@R,"SM2$*7KY\DIU2:'9#KA^-@<)9/4DESN%.&Z'%PI%MZ/L(26 +M1ITR5(P[-#%N/.(4L"@E&U1WH/:\\0C)+1?MTT/;>PJ5-HJ+C*>K454[&9-E +M=&.A-J:0,RR`=J#L?TB!!(\B8[3C#Q^/QF-5UP>SM@Q*F`Q^1*6C4O%$V9*S +MJP9^4V`C3=$JZX1.OT[``T3J_JQ,6='U$'0U$V<9UP#F`2>:%HW1-ONB,9!3Q4XF@[Y+U +M[`^>G!M9.`Z-DN5BZY_YGPLG +M7/$MO.QX;,G"GTV4:,Y=QFC)KMO +M0FDRW8->Z6!?M,7]S;)`O8L``]K6V&I(,@S[S54A)[=^4H_@T?$G;]T1"S>` +M5RH33RC\'DGK2'+R119;O_T8D60\Z5LT66>`K+=%&%V'=.5CF*L7)U)E/R`4 +MM+)R@E'0\T^"=%POH)WKJB86RT&E4-`)-U&A8]AU'P4`8+/9=ORJ\]GP4#EU +MBE:]I1G?^;N\IY(9R##,2$$4;1-H2\[)4D:7&G"X7V%`;O$AP+&=+3+D2$(` +MA"J^:@+YJ)/`%P/XV4.':R<>>$J1'+!46)^SMD&RU;6[PJ^^)*.C+XJV#1Z& +MRHZ.5CP%3RH%+'T%)6@[Y;]'-%XW\>@S2N.)68D*2W)EK>1"=PQL8;7%K`[I +MJR8`,2,\)RLC8H!:`[3A,A1`'?5#>,"[_/)[`Y1<4GBJA0+`+5!J5/$ +MKHZ@L*3E@#M(I`[`413HVD2$$JVM28+U!VQ.UU_!/#ZIJ&-`FJ[?=GK]3USO +MN+W:>&QEI7771!6][&[RY]_C&KSC1_W&ZI]0(!#DPU6'E7QH'O>&"WMO"J*S +M@3>3O.1G_>VF(M3?%@0!30*@(+C,!>X3]U:IJVCU(5YM,YEY*"RCVO`SMB6I +MPDCXB9H4,7V#]Z.*=/`V%47*?BFG5K`PY%`M,27J-&/>-OBE[&D[>=+73$X/ +M2Z>IN):J&*@1T?*%CDOH3+K1!^?X8E^FSZ#D8C`R9%:IZN"P*HO68WRT%"E2 +MY&`RIX<*JB3=M<-MQ7P@X\L$_,`I-Q..D8XK7EA-JSXGB4$[K5U3X9IQK(0S +M*9GDIZZPQ,@=4\E-._15O)/.Y(F^!DX=N!('BL"6_%K>#LOA\%T@%:;Z +M@[<1NY6S`IIT-"?\W?7<[\`AA5&5=I,1$T[5$J@P9;6$7Y&`K/2U%E+$4F4V +MZ3Y3K+W[.U,;0SM3#63D5'*M`VL-%.O]&62)Q6I[]PXM4:,0#6L9AYHZN5"- +ML^Q47,#6E1W[X6_79TMAI/7H:5/^"WM\%O1QGO +M%.'Q+[T;+F27KU+G:'U6MVEX_NQ2(N7PIVESG!2 +MS((78G_P[K5HNWSF2&_U]DO%I+]&4B6G;^1]:`V6KLKUHFJV/%79FT:Y4>VH +M8+GOH_]0LASNISUZPHJ;IS:&XWX%9WSLX*3HH5X."OKP)2;Q:,MS4$`A^^JC +ME(BUE$V;`:-0(%A(9*J120%[<(YCBZ=5WKWOX7!LL>)<\""&%SR>V?7MS86[.85VA=9USJS<#C +M++C`5PF*ET+-W!IM'=-`@8E3X'L\BJ1(6W\U&*I9<5Z@"D%IZ$PY0WMPDL^[ +M?,S^2#E\WH)SP>>+<.7)7@^]T[(].HAL+EO(.S-*Y:K%/E^\^]SQ>O.ES??" +ML:ZF#G0,0F(2WG05AB('FDS:\3]NSJ%U;_)B9++Y'$/L/Z0X.`?N@C+YP`R0 +MT9X/!BUD`P3*6&>F(@C`LQY_[?UJ118,6)T"E\'E&:%>EX3_0U!U7IF;S$H< +M3LYJ>>'_$..-Z(6G\[VU9F4$-R8A>Y/WZ=,4#G<+J.#:E0W6$1ENKA1 +M]*C?-%1FPX[EOTP@0PF@/D-MZG6G:!IK`CGVD>4L4",,0+@8)NK`% +MSCA`&<>D@#+/Z$P4+ZX\."E[K*NX@53K1HIP10JGZ+IH+@(.7]J[]^#D$,Z! +M,W!*P9D)E$ZH7Y=G3^%Y-)':U**`DU1"KNA`VGA#_;9S+WD.>/&9>\!DORGV +M/\Z>._JJYV+G;(C,%P,I]$"NCM]W[OMV;\.&>AU'D>VZ]YI[UX*=__\^^3?>./CBV^ZM,* +MA`=RS>1/[YRKJPTO@JWG%W[YGM_QKD=CS]Y=?7D80'MN?.R.]?6%Y;'C^)$W +M@/"/C?"_$=J%HS_+XMJ?_=@_+V["@RRYX&'_`2=7OVG)Q=_9='"N#6#V+A+P +M'?DN].`#KI.KM&._?;RWFOXI>JOO'>NM65._*?;4/5]?K#833W^PMWJ>OJLW +M1WY_1V_UXJ;>FG9\_8\7\>&#N6;B!_^$'ZTYYH[S0KW^TG_Y&K].`-P4>WSQ +MQ_`,[+!8%7]YD[GP'EYEVB[/.KY=UW]8F_8FN5(%B&S^9U$".^E',P!+,_'J +MOU$;G;3R!-Z(NUNT7:48Y.ZQ>G/9+=_I781OH*`?@"\LZ(&)WM0WF8/E#P`_ +MWTRN_Y5Z^67IC_++:U"BRK!=$A8%\\WXH5\<\VZ:YWTYRSV5;7C,0H=V5K`\ +M6-QT\,*N@HK2K_HTP.O+MMP(IX$KP=/@@Q*?@K^&GDT>:WLZK8)Y6U2#!65) +M2\][PLICLZ0YI8%D+3#$U'T`R=*?7:XA:2/(M*T8"HQX`6!P+Y*29H=UH1U" +MNZ(&1IQH(V"X"$*:[2/9"$!C:];0Z54)^"4K@S$/$2D42/A`;('%/RM#$Q2\ +M*9QBHTH#:=R+/92(@`&67GV[CNACHX$N):8X63OQT"D\*HKMA6HYK$!26%[#"49F8`.'$OPP9UBH6J^*>'-<0/WUZ"OT0?FM-BAQ:.HUU)RESH"S>3B:`3P'4$:6'9PAW'BG\^LE;%.C=C/#.'PQ*Q<)*FPYWC +M&U,9(Z!%CS/Q/+P/+47,M?ST;M?5C/8/K2( +MG4JZOK`B%@]#LXZA.9JZ[>[&P^'HJ%^;>&PC+G'$R8E"Z^NG6'-.06`WPLE[ +MX&H[FP][:FCB4SDN\O&I,_>^"3#5'MLDCN2,+X9SW]#MD*$W3,!UZ8L+N+[Q +MTR]4NAMIBK_]_+ZF^`VJC;Y#;2W\J"P?JW,))`6&SG2"G&O#J>*2@J5]W28Y +ML*\SX:)==LR[\1O>-UB"&@IHA5M8U0P@+*AF`QOCBL9?IPZQX=S$+])Y*,3I +MY*E^0X*.N^%]JJZ6'7>'618`W&'/Z#:*P4EIW?@''D3'-^C&"/<+`A=2?2@W +M"0XP9(W>)F[D\G2)C*B;VKG\B9)ES(P\0D)GE/OZH=J)TY>K$0C8%"6'-D49 +M\T,-20Q&7(%$#)J3(S9V5FR_5$Z::FG=$16$P!0\X?ZN;F+/34$YB:Z"IN9R +M%HLME=)ID&/ZEVKJ"6N6-Z$MN4C<$* +M5,>UL'%7AB8'Z/XO7,IT@.$J%\:6\+`W9HQ6>"1@_/Q(U61_]0:'0K,>5="` +MIQ048'K8E%*D,2]]8C72Y#A(O]'"GW:R]%5,0;(&X)P#>"=8>@V:,E3'GJ$T +MQW!F'BRA+GV5:4HR186Z+V!G)*I@N-;>O5RR.I+75X,A,DWS%-E$4.2AG.=F +MR[W10WC)5D7V`N,%_*67-3\'B+[_#_P4UH!MV"!66V)THYBB_ZTQ_[S&VD__ +MKM]R"[UBW@!Y+J[9+R[BHH'^;U;/;9CSU\"W.3$G5M-7`C^'#_5*#)G:_!K8 +M9[_:K][_/:Q""ZP^]]PUL*>:@]0+^9[MQ,+.0_1U+UJ[8BHGN*D82644HQ@X +MI"';A+<\60K-',-,;3F-G^_U*4J("UOBXJV;1^E=3.N[=+>'*PC"B>6F?9AT?6OKS?///F:_3(P(WV.RID6)ZGF<`FJC<+""<*%[#G! +MT*&L9ZI_N6._F[SHD6ON/:^=O*RU>):X]SQ!_^_M%\%/YZO/,"S+B80\YR"8 +MLXI2&XTZ]3)0+4KCC`:+T,X?&TN-C8VUDX^/*SXRI3]J*#>WWQMLX).F&)AS +M/5R(5$:=Q5)`FJ"H"J!P?CTP<4-J5<&!MFIK$MB3[=BR"#=3!A8KI_Y4IB`( +M2_294P--KC25D:-4&-$WB1&4D]S]V:*\"4"MX%&%B^W$Q\X>K'O6,RX$:46* +MDW94G!0?I^)M&6DXB@S7#+)C?3%3S+TQ'V%]9%#53]W,GD85U\[9=CM^YW+= +M%=ZA>8B$?FE0*T+B/..4,T0@*GVB^R5,#I@,PJ"`-7J7-%$OW&&@2_5`A':4 +M"$7]H3POKET$"C##5TAKE;7&F&3:!<)?=;*NI2\&3??8D^ZJB5[#BPZM++MF +MROC)@])T*B;#QCT#.AN``Z+@7;O23L8^'K3NE+'0%.MH3(F,A?Y.I)1\ +MV+P+07VQ&*PL8(D^Y=CL<#]:OARIU@)::R9CUTT%8X9T5=(<:>&^5$$SD3X7 +M!TB@^O#QAPHVINAB6"Z[[,+'/'X+Z^_4[()36)$)LX.OJ-1KEI&NUS86M"%2V9I"=` +MPTC`([<3SZ4HD]TW@PP=$TQ"6K4N4`A0#1C*QL<=#>F%)BRP_5*`<'*4QIIA +M`>9SJ> _IF:1DK$&V(0C=^U3V8JZ0Q4S2MB6L!-LC+L;<8D>E8!UAE7+[U +M"IKA\8%5^WE0R,"@:IU3'#;U4X;&=W$ZQ13V]TW90EFI=1`?R-E-9*^.3M*)E$/8<[I"=VC+E"):DW\>TI0\ +MF$75TW@4.&KB2SMQ_6XK#XHI'TFI8#34F!O73G63C5_HTX0K,15^/,<-9_I*$#1,U[1D(JQQ'>.YUNVI!DMK">J"",):)X<5R)20`!HI7^Z +M-:[$%,+^%J<0N4C49B\5F<+L3]08LO)"$C8RR0C=0-.E&!0[#?3\!0=^P/%E +MSQ(#DY+#_BHF%7][5CA&K":SJD0]?1GIPI8')]N);UZ+29L@TWSW>+V=?)?/ +M4[,`>S]/S-GUBL +M-N,_.'=@J35:HNTLTVPY,T +M36+L%C;=J+H@*E-\VC1P7;&*!G\3AZIFQA*"H;\5(&4*QK0#8#E% +M7;'UI].,_P/ZK,03PU&U@3#$#FI0B?T1,C6_4BM+G18269\'5V+L-?+[$'17 +M*AU!SS11';'F(>J;2*Z[DA*)3*^1,89@FG@8EAQ"AQ263N/+5[/D-;^+@@Q, +MQ$UH!HOTHB-A#TXJD'K455%K)U:V^FN*\3EP>`X,A`MXR),,`8/>V(:PJ`Q4 +M@'8"T0=AAP23#Y&&Q:WR[;<")()OC]8:USS?9W7M="H2V[\:=C13[63F\["V3\TPX^: +M1+C,.%=#6)KPK:H&%71>?%S1)_4V&'.+\$]I/F*ZJ:JLA*ZB;";0[] +MKR?-O,G(%$XS899^#08V$B#[8?_"]0*;%&9D*-&IVM%4FU'0-Q+.O^6I'+.= +MR"X)19Q@0]W\QO4RYO=N(-/Q7"65WZ5HKH45[E*U6`9&C4Y&($ZU3$_U1>S- +M?)^B[D#I)C?\<_,,DF;V,F&!NY +M=:TKEK%C!K:D?N_9ZW13B&Z4PKMVPLU0G6@EK;(V$%E35'-D94)#QW2C3M1N +MQWVH<)\GB',X&9%$4QZ: +MP1\KH6E1& +MQQ;OWKV1*;;R4.YLL*,.Y<^6W/=W:/KLWH;Z;:^XM0!BZ?X_'"IX66R+7+KI +MN4M7Y]8``]H@+J]O7O+_6WL3.#FK,ET\5%5`((*@N(&.XI+.4%VDN[-U%/DW +M"2&!!$(Z$9'@M;JJNKOHZJJVEB1E]*HS#E[O2.SRLXMCE1H=<0$5QW8#'=$H +MBN,:MQ&W."HC\YM17*(S7C?^[WK.^;[ZJA/N[\Z]*G15?]J[Q<$4F;_1TC@&*:#!I"27`)!"3>PM7Z[B[! +MJ0\U^V+&Z,\O?1T"F1#6/.807QX"V$!@_6;C://2`.IA_?%]-. +MW'^+'DLGZMW9BL#F,BD3N?2TUY-I#W]QL)9:RTH?6R)[T4U^^\T^WU*@^A&3 +MC<"6?DDR*&090_TM<(E:X\P(GI3)C\A+<-FI3+`#'HMO9GMPBN42^L;$+I&\ +M],8H^Q.AERNA-IG(WN6)I>_BL0>C4YJC5AF/VB2.42E8LKLJZKV3+97XKLE7 +M]E!*)2^A,VN\PN`T5[1(ARX0C0VRO)CBST$L)U=DC9.3,R=][$FI4(=%C=_R +MO]ZZ^-)_@W468VSZ6)NE+D,RN^]\^"A_![\_I5\+7;QUQBO^$+[I=,APV?QZ +MA[B"/_M%O_K("G_@(YR5$[`"*D2Q^D4TK6F;@F05&%X#(B"C<*LZRT.52L26 +M9#T*ZE,I5BMES00S,X6&\R>4"@GY-@AWJS5FD+]W@[\3^?'Q67Z)#T!S7UE@/+ +MA]!1-9*0_IS7T%("H`T#&UK/BJIW\T:TV +MFLM*.X29(DAB#*6I>LN,]$.WT]8H>#K]LI9T:LNSDV:-G$/*T8]BMV$Q+%0_ +M^MQW>P=QS"]]M%//_K#G__H59E20$.X'J:3%"J3`._(PL$P(28Y%>W0L8RH5 +M*>1EI+<35V-DBDA(R+:A*[.3YCW8$5!J5<629_+0B$J11_?2:J'F_RL-B-/JD_E*Q_<4E%F4:Z&\\TAZ"&(Q<%5$ +M7`*<,-=T1XL1<>0[LHP%=!3Q1!0"!N1`P-5SC*.A*/.?$2/U<^(G6CN)@C. +MDE?.T]0'J+<77T'8[BME!-X\Z8-?OC%."3;-&:=:QR,?+0DA\2!-`K@\@G_L +MPM7#WB7S=AZ9A6U"4:D\$\.LNLGQ]RPZA;TL.THF_H4P=>"CM>9%J0X!`(Q) +M\2,99O&"W4WACB%'5``7PIV?9NT9:BKU)3':B7_\153'E#,(V!V.PY/!KXQ7 +M(E;8*:+*40-?@FW+^9HL89`Y`X@VT6CD:I%EEL"[FSS[66!4(YV`"K9U<)!K +M+),,/B:-7ZE6"65C.-N9*YC_&VYHCQJ(>>W4$V\GOO,['=B`#!4R6 +M86T&CAIB>.V\L43SZXY=M\Y1)I%&UH.@J;Y,Q^>EYWZ+K+'H!@=QPJ"&'I9. +M8=%T(-?U.T=V6X,336;\T1W^KV2 +MJ\+C"H"I'1ZT36+9&FKGG,<"]D(`]\YQ[2?"HV\ +M"XH^6BH$=[`;M)UXZ)^E:\:F_`6IXC!IC#:OX`X6RQZ;,6W#5K)".+_W)DAY)[H>9'XI\^Y&4]5!R/#:/_%O#&P6*% +MNVIK@^'FZ"Y`J)@&19`0#`N*SIH!8N\PBY*I$$*:Q55FCOO]/=4SI;RV)?B. +M38JT$S^?$B0G]W^;6D=<)2ZK +MOD-1$,J7D:U6U[\9)2NVB$JAQ?.X"%09ST,;P9\7(J^;-7I$(!.(U6EU!LG: +M#5OS;2>_<`.N<"IG=)04+&W-42]4==)@-2;B\H:IV3)X52W-H9^"/LME$)C- +M%-->DX2M-[.FT>R3MZNX71GS%1.-:E.0TN""8(O`LN4HC+1]='CB4.OIGWC! +MC69`5+J4A86T:D5WQ4P6]J]BS)4C+PPM,80=MN"VJO&A>X:T/K@\N?H9&(M- +M:/X)<=_H:U>%A7T"O.H93IKU!,AHY!R1NA'AWTX/D3K-'*E%HH;UC#Z$W*>= +M_,"S>C5>4;'%$@G-,OY/&S%[)"+W$[:+-YNXJ=+*KVHU*JLRL%FP^4F!/L'*V0E37K0B!\.D^O +MHJ,2*C&WD]_^BV6/$H%*A\SO47\G5T>J]H9K]K'AS\9>718:(0EN1WQ2T;C! +M:#.TR`+]7,SAU7/>Y0.'NJDWYV-I6<,Y"G`FXYXWK%%#EIM[1*R%Q(2(B4IW +M0B@6"T'MIC8,1Z9PH^-Z;-*10]SZ,&%"#E2V/(^QK+:V#2F+L4TVUPR'E,D' +MOB+<>+:5P('(?=5S_&:$]="&F$041/S=9>FX*7B,<5$X*"I$PL6B*=JF#^WK +M)N\[%QZX,.<=386,D0<+9Z1[=FC:D:K@)U-E]"KXUI;SQFI]BA@SF2H"2'O: +M'?)$+VDX]L<5TM=Z^.D_?*YRPZ[!7-]6;`2[<[306;&Y*CD^>/%'(=JU1?^: +MG__J0_#NEQXZ_`3YZ>+64//8)U?TT0 +M4*_7>!3:!!X*%79L1X#"ZIDCNYW8\%/4Z,K>+81V[85J[?B,EE;$;"?[;4K5*"Z29O_F#?SC.N[QELODD^::^T +MW=@.2G3>>)Y'UD8!'ADSEK=M/[Y7@QG-$+N_#8?:B<_W/(%4LW[U:I'W +M]JCI^X?+49"+#MV^WWF/J`\J:T]8[;@P4FK:(H:F;1]UX%)VW4@"!\YP?VBO54)L&YV5!5K`8>UF_S9$WU9-ES,=#/N +MP"!ZZ$HY'G(2A:+W#((M:H1>7OC44,!7:\\\0NJQ4]/$M[M@(7P9,P[)\S>! +MM16O)!;2IM"NL)Q?H-/8JR)F*UN>.2"5C0M>'.Y)\\>3-&5$D>+,-S0^_&0[>?N_6[7*:E +MOSQCH+RJ>_:G_OL2/++V9+BC'L- +M!1AYSQ0L6@)&(H;SR%&\)=Q-#GV\[WJ1LSEVYV7,5G[LM#DR:1:%3/XD-B#[ +M/5;/1WD._XF=NV(LEE%VBN#(Y-2A,VO!`M$6_&S=>=92VB04]2I$"/&T4E=9/ +M"2?M\VC*H[:3[WI&B!B&MPRO%*P^J%9+D_&)P4?*B^E;8%TOM)ZPZZW$`R3W1R%J<$5S!;I`:\7( +M`\CX0S\XZ]X?XI\>E_K>XJJ`-%>1N`J?EC]_\?.&\//I]_[KHN0HDH.+/I4Y +M"[`C5B<(B\L;:S4-B:!ZK23>H8#-B"$&&54K,Y2!BBQ5&4B&.;53K3F?>FB. +MM1P\5#O<07@*3)UCA%8]M)^__'P_S\P`VKGG$LW'RDK9YUM +M-4`#^)&R&`,>/)/W^[\M6L`W[NW4#]Y/407Z0!%&:GC;7+BQ(/RL"/#EZ'JF +MAUH'!\41)BI>=8J$)@)8)'_S6N\(C.O&H"72Y\#G.`AFGU7D",::,5<7"R6K +MO:S_4L*L:F6&TEAP4[JTSH=EK6HGW_HG%V2*QNK55-%;EKH1(=JB;STM$5.Q +MZKA&2*N($*&H_J+AE*!$[?96)*>=^/P3E8>$8O*E?&!7K,]7R!2$=IM?Y^JG6PTS +MFS)##BU'BZE_W-3QO%ELT)%31OK9">,7VT.JR[,FJ4U:8;;2'W+/I56%R`S: +MB5<]8-4/N`)G1#W3ML0H-J(<8HN(YXC(!..<30T#`AWDP(4C(;)5;W(3WWZK +MG\;05@%)9ZR=JGTB!>U$\?? +M[8MBT2HJBMCN`FF*X713QP8Z5_#U3?>(%\+P4*Y.I=NIT8V5H;."FH=K)+JF=4`:TG7KA6TI%(4FR/'^TY>A018A! +M,=]AW;Q\"K9#F?),F5*19:90T\'+!&-M&*O&5,,*N^$. +M57J?L:`Q14+FKUQ^8PON6VM,.>)]=0IH4:6>=VN8)Y'INJ1V3OSMY3"V+2PG +MASFGTB1BCEE3B-9:3:[28>U=_S746E-!2L^1W:(G_5>_'5#]V56A-G*5+&)2 +M?W1[*U9[(-*5`LE">;R5 +MZ'Q]D0L.)A;'WZ9(&E7(K'@6JG&ILC +MG(+>P2Z%^I/-969+%5X_N.Q9?AD[$^@4:\&-"#KE(*5X%.$T+LJVE91%F@PV +MD8(+5$Q;XRB)1&FEVAS5LHO9DO`*B.)Y&&2C^A,F-+RW/_JT +MRWL'YQK+(EBJ9+U6ZS\5>N%8/<_!U!RL!>H`-56CB(D0ZC!`N!<3R3FA!R6A +MXUZR2_!4<2Y?-_6]+_@=(Q![#?`"0N`%N_N;4#)Y-K"CL,I1=HF&"^8LIJJ% +M!;'B8K*S)=>R*Y':)1&VP%3C"E?PH?.#IKE8UKX`C_F1;EB9K"\07(T7$@8@ +M.0%F((C+8\%5245UTF^76^U=-)35D9WSLLE"B#OWA756KVXPI6AZ_`6 +MBQO;R9^5/"`W9C19C=C+I!*`'KY7+8`/(PX^.AVQ:>DP=3Z>,"6OYWIJ.K": +MB;H8&!_6@AM8+)P_PUCP)"(Q""2*IRGT,T($.TCN78=89(JG2?T!0Q3N03+8 +M@Z08_YY><^^ZK!,J[KSF4QCAP=":#2,B'"SP9QX#?4Y>AIBW<'KS^!MX$BGY +M$#5Q,5^,CB_"MIJ^G;LW6VT]_/*5*)-((2)F022[X#-@Z`!@86.%0S&V$W_> +MW"`T*9_!M`!72HTXO$$$;/GGS=S9VN<;Z2Y\PYTQ`5L5*S&)[#&!BZP]W)1T +M)Q$G43OYX9:++:JLB$)Q$+RTE8UK>G*W2%J.'J33)#=WV+TW1\DDC]XOQ[>MKPPAGL![Z\50#_!,;\(CS0/XZZP\1X)CI)0U?Q<3S'RN*AW5Q +MI&^KHYC\4L549N3>+Q$8?#N5^B+$FA/9?!""R]MQ@L_]<;*%1WK_?$6S]Q7; +M!B@E82^B%6\!UIAF(<1(72*9<]I*+6G2P[HR\VT +MB!,BD65"]!A6/5&$4,;LZ$.#)\@NQU.+-G1EA;^9I]B)[!-`<:A4.'GR2?+]JV +M^XY,,G%LI9<@#4FT,O#5CQV4HBBKC$(+8;2*8ZM+XZ5C<-,\!^J( +MV+GH)GYYCLTOT@8(6+;*;0"SX@#;Z'"5>I;=!>+X0H['.0S=I-J-QSS&;A:, +M3+Y2UKA-%V+:\IOZX/D?G-$\J.T_"_:[*'<:-1*$15,[MYD;-7[QF[//6)!QVVHM"% +M7\@H8ZNO#RN"IRG7N-H4JYA&?9`]77\QXV,#\5J3$E\XP#GO(FB&>(RP""]_ +MQE^%H0(U/:Q%+3?Y@M?UL!;R%PFRZC>O+BJ2W@58+F,#-]#8Z6:B%#_XT-`:P_:Z?>T,1[I6W+ +M%1^M:S@(>SOQBVS)DP@K87\Q]7_!^(4:HJBOPQ0&J;):>B2E/KC%P!$XCPJ+ +MM56:2]/TIF6L)N0NYSNZJ?=](SL7Q#TOQ)S"O!['E%=KZ*]L`Q.">[#UK19* +M(LUA9LI7[$-,VX(53.RF+IC4HI@RO9L!OV/=ZQ-:\-/A%N*V"JU*C;2N/([* +MO)7B=,+/3>S*(OMSP'*?5FWDL4"!53%T,:/K*XPDPJB65O:)&7!?V:S< +M&2>7E7O7Q!*X07`E2.X17!!P);K);^_&*7G:1VKSCQJT#6WO.I-$(-'1D(:V +MCT[RK!\^#XGY$5+3>_!U4V]8M32M?$WD,ONNLZC_YAH;IRT[/AD"_36=&1-$ +M$NP0BU-(?6UQB2'%BG;RR9=E:WZ;!$.XI4F"DSA;&U.CJP^U+CCK>1`S<(`8 +M85:Q3&MDX;%&GY6BE/J,F+@D?#_U(6M>W0-@MY-_-%HTI?8`VAB-JG/=0FW0 +M>5]94/OF+W/=';TM&*ZXUU$CX[:Q\=AZL;;54=USW,NMY+$?^E6$RB-BS!Z`(*%D:L%B51GT6<(".=;-"0DC5\D@J +MW6`ITL?==^$'CV!5$36V^4AY<5`5G6SE1HA=0H,C_AJ2V)+'UDYN'<'Z.PWD +M7(>ZJ\4[(F"=R2K8/R1JE>83$%Y=*3GP\&\-=BK;DYT/M+VRG +MWO!ZA^:RM)!&TS3HWYL&.E/;%-9`$%9QM09X/_I"R7/<_8:QI+:REYJKR`U# +MT@Z9&9V^4%]:._G7#WHJ-P'I=S`Z7FI-@M86<36JM/7T_I)V562B0JN+TZ5^ +M$L"S+8H-9"=XSQ[BRU3LK(%#F[,@D7XP&PG8$42#&AE#43A?L?,ZIG4D6[K@ +M;&DW]?[O2R.F2Z?YP"_.E2WT[&0AI]BOA9,P6@FL.YJ%FG71TE$:"WHY71]4 +M?BE5@CE+=),ZN)N8!!0W)"Z:;W-ZS8J-4Y$^3%)7^'7;@@-7X+ZG+#>::+;* +MUNH +M,;%O#Y,4$1Y3ONJ`!6>,OT9#=^XF7W%K'^&-">+5O+(R73;8=ZQTG>5>3]1D +MH];31FY@*+`?.5MFFT!>MLO*AA'@O,C;B;ON/Y'A9B7C!?TS^=W(R7'7_8)G +MX]5GXZQ9I836\]SZ'S9IA/NV&3AYD<@B[2;>=T:T$\Y$JX52#.YIXF54<&P) +M$"G1Z:@P]".TP1`V<#@I$E(^Z8""CT.TGISN50(71MPQ +M.L0M(X1NHAU,CM)-O&H.AB/@P7B$3",6[+)$I3TDIR.=Z9;5K&3]2UD6N)F[ +MB3?\;8S:WGZLAMD64A]JC@W1F-F4)JO^R!O,'`2>GZN<<>5P8ZI$YMP_IXK> +MMJ&VG7S4=]Q"C_%)3-S"1FAU*)M+*SL\LPRDX=04A!]M"C_J$2H+QE^E_2W/ +MMA%(J]BK=>TX94DUP%H@]9S:#% +M7O.9E/A$F>2WZ"4%I'JB<:G0(=NLA2K>?0L)CGNRO%+8T_&!!Z.@_';R;<^E +M,)5.8LY\(ZF;(B.;&&9D@O&*#5B\8S<.>>JES&MSII"3`0Y5FM&:*HXRVQ3V +MI51Q,ULI@<0$4\8C%J(!U3#Y!)*4&3,>G]WJZ95#O\BO>M4<\JP(ONBEOX3I +MG?]!N_N.P/ATMXJJ3'M/#9`R:$3UB+39^T$P^^N;=H**1>\YHH%JK##O-)FOX)Q4P7KK>S5Y8*.RS#I(G< +MWYLKE@;MUD(K@^2E4LVKM1+FNY;5%.'^7?A#A-0TC2)J<>IN3"%=-CC-*J$Y +MG!F1K84C5R*15RDD..X+IASP6D_^]]M\E\IAG$+J31/4\CW`D@->2&!QMS"_ +MK67W/675(^+<]T30_.*WKP.!7D,[\=EU<616D3:3$+$G"59T+"*(,S)YU72O +M2BJ%+M_3H,J@\VR>8^65F.O!:9U"R1EU6Q`X^VB:SE;R'_ZZ]R7)R96$)NY- +MN>2&]8=:3UVV_,9TFW[E0;3B-H4>EP%RB%5#_4;468'LK$L%J)((4M-^JWK]:',H_S8IX7L,R]^-!!FI5,+1TW>9EV\G=O#@L;SE8D^O=-2<=_,`T`M!30H0V?06J]S1U<@@"7O@TNBQ3 +M/D[4[_#DJ=Q':\D(AH`<"Q]Z>->EB[`GIN]T^]QOD=>\K+;KOY3N4@E'0N"P +M(4%=*1UI-#*A^H;UDR5-K25E6<9E9KLEKR*$Y;#N]FRZF_CVSD@6&6"K[)N5VJ[D]J\L)>NN.E(.?"-,5H%N*EA27(\0A +M:8NWFBO/=),/W;RMG(,#%&RKC<=DO+KXUA]^W;RW,]X-/G.M(77D:)P;&=>39.A->&(QAY>%NF74MTS;"!-1*X\X;4;1'<$"\EB602,8PC;:`C@QCV0.'7[JW&,9Y+5[ +MNG/G:*&]_%^NVUJ8?]I'LOG!<9C3H7.*\[]\)YA*Y+EECTM*L_31P`,UJL[2 +MP7;:]N\O7M.H=I<_MKP4NEUZ`Q:80A%FG(56B>6_47(JJZR>&_+P.KY+W$I^ +M\LQP:YIXP)\\DY?;%&LG]902L(_!H?CHM'?3S5O4T]L2]*HV:%%`8,-['TB3 +M@V48CDM^\Z6L@^@H"%RZ_^FPCL>=\OCTN"]A7T7W/$;)[>17O^&VIO8@#%). +M5`?EJ]^H4G,*'=$=_]SUG(Z0!+.=0UN2"S=Q]LJ2*JI'^@H5V@?H?C3I\F+R`9N"HS7V"-T$=;B +M:'JA@Y@>E-*HMA)?_H_>^C+\T1?;Y>`HPM-/'_AGLW$G,]&F9GN%@W)92S48 +M-H;.%8)C;^_I$PQ$+U*R&##<08S2 +M;,$#^&=QF)OBHQEN7H:)SR]16LE(JR;V'CB#Y?""LQ56GL;6A'!C+U?OZ5MV +MF,65G&*J$)W.L-HYT]_U0M(?^(K/@3O#4G_HFH5$XYVRC.PL#P*L^M6O!`>QX" +MRLI;*(1I+E`I7]&U8>E2@F-U4S>LZ.\]1Q#&O;@GI0`_&$676;)83/7#']#Q +MS`_&8R",%2A6H..>Y3[78DRH;Y?!B=ZXJG$F*ZJ5J'L!_$=UZO- +MT(+2@@S)W^K+NCC+9E-)1LW:OYIK52D;%S?"X;KB\3<)Q).;1PL?/6&BQ]A< +M-?E3EAV,)>8O:Q":<67-NSTZ1P7K6;H,KGC;83T+D9ZKP.W`DC/8$2];JSAL&I/>DINY&JUH1M?]Z*R$5U/BA[&(&E;&2RW,,/TW#.!@-'+EM.9!?#3\`EX;HY +M,@[O?,,$O+;1%PY"H5G\8=EW+WT+S-G0C?#_2:+JFP^_[6+4*-Q+ +M_W;WISY`'ZZ^L?7D2W\]#O^KW[OGX?==C/1L>UM_]8J'+J8_W?[P7=?!Q_:; +MJ^TW]^(W^4OW7GK[=?K)5S_UCI?I/UP&#[3I4C+(BRI)GOC^!7ZF[PA>/1!J +MMBQ#@^;CK$J@@^8-+:X08_^">Y`E[5'F4EVFF4`H5?*..5"M'^ZY=NJ,&R6* +MU(5E?W`$1CE@=GDT*L1#%LM9!MI(Q;.8O1@>,BHRH"GX[[CA]"0=61596@9-4PB5+=%R\B2>=<,P7EBS0UPBN +MG0KODIN2+."*D\L"?N-/2S&H,HERZJ]S=+!)-PK..S[.=^,9]BP.^KTP_N84W!01H +MI[[JKOHMK5-&/J^W/]1ZUO$/+JXBF:)0Z(CX+T3]^0321DH//>MZ,&(M0Q@F +MB>\(_94Y2&QH1ZZ#?WS)XL!U6Z_>LLI;T_Q>5?R>JR,,D&/C"VGB%D9\)+?2 +M%6T?$59\)5;.'-POO#I*+65)92P/AE00VJ[G$`&T1\91#[-G92,(\9QG^CPB +MR65W4`4G8+$*$^U!7!`<-29P4/S$DLN41!U3NDYVA2),KRV$@1+28S%+_1BL +M(.SH3=@GS7S)=I+XP:RMY%8QY::9.O!N@IC6#2)0!T_FXB/7P7]@PV>"1><- +MZ<$?(<5*F[!,KDM?I@;N.G)=*S7P-R*#.T[_+#]?T,:\'.451;R=N+>I5%[B +M"$DR@7'^MB<5U/M,DG[TD'AVX,Q-#6L6W0`F:QMXHP7[@XJPR--PXHLKU,=Z +M-6X;<@?I=GN@!D[ZAJR3I6+I.[N5V6+=MX^TEUO)NQLZ5$K+E&XG[WZ]$-EA +MHUS6_(A'_A2'77Y[P8#OUJF?V +MJF;@7O62A;!BQ(/%;R^Q/FD@#G+;I6"=/&60M*'X5,2I>C\W5L#:S[DF?G1N +M3Y-5OUO3U/=,4U3ERG=[[241";"@>%@ST;!4>EC(K04NM8]@,.6';:=N?G<( +MG;`WG`[&G@@>N?#H9X(=E+>P%!=$$%;@\Z]"5*K,721X4+FO?3,,EL@(M9*U +MH_@*1DG(:D?'5%R(59>)LSBGLB(>GM9*C15,/HT_[-O8Q:._7<;WKN^(ES!X\@:^!XC$]XV;1-**!)0SL"\2:E$\18QL3W^25S +M^FF-M&*T+:B&%D4;,!WJX:?N^;#V7)'4*3$I7'M?13JL[AR%?_C.^5/@%,L7 +M%Z\I(T+BUMVL]U0M3&%KCPXHHX[FOWC'7`/)#V[=W1_!$?0K-MVZ&P7L`RG+ +MS)(N0844+L4$!6`VI)L1E:9C`E +MC4"GU.:%HPQ293Z59J`Y]>!@"`[E[<0T.D4\1GV`2+3_UB"B#IM@+%C(9..: +M<.!1,)3@BG&87XA,1/ZX\1EC^O3'BP;O%IQU6XY.2;%QR`OO\\I(WD0O7:S!UX7 +M(NJ29U+;TTYM>QVN`^E"`ENV=U/TG6EX+@QMC6B)'0OR7E9DTGY@6^[\"$"? +MP5ZPG=SQ[QK7&I%&%.Z]:KC3`J)EV@&.[94EZLIT5Y&$D%`)J]"2=:JWX`ZE +MJ#=E:ND6W9EU*W/B93HZ]L0K+B&Z3%@'58;MS6&Q1[4VX6/)M.%1:ZN-)QH\ +M5U&SZ*YYKGU-UID*;S"F,4V>,.*2MI-/_2/:*9H`J\-6\>=`J13L\N:C#"Y3 +M]H'?MLHB$R".P9:BUBRXOG$3W#RRL&$_@]M4\)08'+`#`P3L-0OV!R*\$T,R +M**G_U/:\/TQDE6DL*\SWUAQ4`6S.U3=PX]`J\>@HLK-*7FK%AV.))X1GW;&` +MR3LAR.VAW[F%[/MI(WC!0)BH$YIJIRU\$RO&$DBVZZ,YWJ +M"]FL6'R/F-RSUT<8M):JQU'XUL^%^;TBG8=>)H&QAY%NUM@[^QJ[@KE0>6YA +MAY4BI^ZZZ`7:J3._%"(UBKZ$3VGA[7HG+=27H<86*%MP#QA?'0RO10<&FO%V +M>_:@`1!-*9?$))VTX+KNC:>TQM +M-MV%OS@LE[4X9!FJ!7T+LI0'N("?6K<@EM_)AM#8A!XUJ#+5DU<<[Q"Z*O"[ +M6F)^(QJU,5)_&7D83;FV@.EMD'E\,VC1B +MKHUTJ[+&!XV(#`8&>+:OWEA#Q.5AA+V(FP;N=Z:;^-C9N[4BP,9U0;OC*3Q; +M,8GDLOKF:8>ZTQ2#K6T<,`['1=F2?%'21O(`XT@"W$[>N>C`(U51L27;K.S& +MAJB]$,E"<6?).@)-BNX:VHDETNH-1+L0L_Q^8TFD%0>C[\[U[0A+RZ`K<5N6 +MEDPWF?K%;IX'F7M-V:G@54_<)E&5@$DL=R5K,L7JG6H92RW!E`7GWXPL01*]1,[2%@%`L1V\ARX]=\Q/HPWX-`Y +M18L#XV;?[P_/\&'72DU^40+)]UZ0CGT`&)#;3S(61OU-+'A4`M7G8&AZ]#6X, +MZ6;V!`A9K=X:MWRFG7CK9S1I,&$J*`F5)Z8-!4-FT3!/P(&"2-#F8!'<3VS% +M+Y90)A?9F-_Z&?CW1TNYB9N+<4,1Y;DX+`X+.1BA[(18,B>K5OH\='W13S"? +M-[@"@E_^9E3_*A.(IK*X9X[;1+4>M,&;%08$:982A.@#3&E?>3A-DG5]8:'A<9R*M:"`*AI8KI2^ +M!8]UU6N8^\=;3A(NB]]4C.=L&!(6?S)1;<1#&KOD&,,AW*]\:D?$HF3+W=3< +M_4KACU!VB6)]*:^LB.0HV+C`9&KEP`?LN\[,XI3/>"8OV0F3^0I0O]##?-9. +M?JY,XSR)+%^:.D1GS%(X1L-`&@9!CM2F^0RHX> +MVRM!L=J).WX-[V<=&N_L)*!D'OXK*T%%`X;_BH(-LCB2J&+TX`JLDM:SS(J! +MI_"-%6#3G&`^=GF(:L&U$PD;[O5'H[NDJ;X@66EVD)US0XQ4R$O=A9]2[0[9 +MI309V;/J51]V/M13IEUWV@VK=JBTP$U=EN,BN?)VQD86\]1/J,V;G*QEDQ75 +M->_7PLN>$NL1:^)2P>U<;YUR4(]BR,5.B^C.O-!\A/*Y0;Y)3O$L9[?\-A(' +MOY?&,R\@0^*YB!2=?T9Z)4^E0>8Q0QIM(@;YS'%"`W`SCB#>K./13>S_G',! +M(UZU@&&M$G.UL$\(??EY=7&+VH,(%`^N:%X0!_ +ML)?[WV:9<$^*?54P?#MI_LYFRFUJ0Y2V"9!L;$:=X?4DRFJWOJL:*KZ&^*QA +M2>`S2C&"5>0US^0DTI,FL'P)+*N2,>/47^GJ+YHN-7Q=D6M&A38JU:&*`Z;< +M125=?M24+$>M8O6&V?MH)Y_PNXDBGI=%!'IHUQRGE+C,$[)0I2)Y\RS>])PN +M_)I(#B@0U!#_];`LX")R +MHU.Z>7\X6*:H+IN7DNJ)XCM4K*E*4D[Z32T\GEM1$4T_84^M?*7,6--O_[(V +MYP5?FN-B@N^<"UJ64/'K$;3IC3>,WQ5)Y5`/^^-P\@X+AKG9;N*;RV<#!L%Z +M%>L8_95P%W!8MMP-*JQU^!(2(\CTN)!31EEJU+S&=;9HZMJIOWVU2GEXQR)1 +MT`K1FJ7:\=-!!LLV +M9YMQE"7U\Z%@AVT&RA$>\42WX.ND6="%?SA9'^^42S&JC>E$ +M..52-'?6/4$>3>491MY^B*3OL,%&,ZCM-]G9N?B5S5SEZAK*.C84Z3BP)%X/ +M(W9P'.C8+,TA4%U4`JG[N\@)&(3AXB9NAMC[YZJ:+88G>].#?I[2TU]S(42H +M#L->8B\F7@#7U$Y3U@@+G)T27\+OL#+1#BOK`6J5ZHY?>3*:;AT'/8*;]+8K +MR@2-Y4PPL37XA(*2EG0T +M&9%5]`FV_:7^2%J=':>@M]UFB@Z+7IEL)Z[ZQB-4;;_J&U8+#U_/>D-D6E#H +MD3``GGP'BJA28<$:Q+LN#191A"I+BM>1*K=E=]Q;#C6'L#W`,_C"3#?YQ=_L +M9KBNAV_2<"%H2FY&5J>`LQV;,YS(DW4]PHV>(BL8%,<3P>,-EK`LO<>6(DV> +M"1%BW]NP6*EVD]^[`2%9KLC'"$0RI92OHT.RH'13Q%^+N#_O1H,36==A#T^- +M3(7H2%/JCY>]R5699TI*]0KHI(2M$F_0B=Y-/+!(80Q:OWW4E*DS&TL!I5CQW'\=*R-DJ,MPZ.S&V>0AS* +MU"KK$8FC/.$V>'7#.S`^)V"+\2$"(I^0M#9=G-,V`D$:X?72MOL"SG`\"J1T +M@HZIO`6.-/93//VKGU9&^C4(:=@6(HN=G!]X()O3I-6W=[ND%>Y,CV0V8`C$ +M`ORNHR2S9/F_O1OVU)VC3$KNH!+P/5,]=/@)/(O8/845>QS8?NH&VG_OE=%5]"NN_; +MXQ?]M\^8RW`,U%@;/W<$H;T;FSZN#5Q/$OE,\:Z/AL082HH!ON"%/RPJJYAA +MLSZ85[A2.=V%S]WK$KFZ([NME)<>MY4U0^GS6M8VQ<>G&]PQF"P,8%H+%YN@ +M%/V*W-)\(N1"=JBUG0A5:X9P.][A2#Q]'9^G3QLRXAQ>FP1:L/UK>(=NJK$5 +M3MF@4K7$>OCC$NOWD&'#E:8K1!&)D@8W1#-6$"Q8&MMP#/Y;V2,+DL\TPW_6 +MR67X__P/2R'0"8\'4?/,>IVR?A[QS'K-V.^O=FC%J7H)RV_R1C:2JRYQBRY: +MLW0POF-[E%!%?)^&"<%0'2`]#.O#GI0JJ9PHB;MR`/7E.1)XT:';5SSIOWW0 +M=>+^IV'LXP-`M7F+@,(L>F.(!,\P_$T"*$T6^(AZY[,83X'"HU/E-5`LM%-_ +M^G0V6%*<&;[AP"4LC_+H['ZOHLQRT%BO9::/\++_!"Q)+BT:0U7Q(#DB<91%@,S;HC9O#J_C/,+$O;>:(X91C7 +M&GY&\.7$UJ*LSQQ:"PMB6X`+,;X,`MAF.W'7JSGH]MA08&QMWK36A6_D@T8, +MTHK8M04LRTA_0[&9Z2FS9=^XI$+N( +MKKTC>2=;:L=D8]"+.H\);(Z4"G7D)=Q!<+;B9#/"ZJ-IWL1GO[1$7J6GH53[ +M*/CRB-@P0J[M)+N=`+52_B$1JRT;2X')ADX8ULLE(*,-F+PR#+8VHD1@B:GMMQ& +M<@)D)M#F;KE9,*^$.+$RV&$N*_Y3"#P48N9P-',3#-3`:FXW9;Y.3GZT$,&% +MMXRY6GT!JTFO3?G2U!K(,;#@R;N2;7M$K*P01CI*,.*C;*>2S]LO^C[9O":0 +M/+TXEW%@Z=^Z87X6)./"'WOIBJD*MH>,X7(*T:7MA&BM#V>:57@NLCQ%.YF] +MD*G3F.,O1JG02W<8E^SHP@\]T!*C_*2]/FP,@2LYH\7BR_6CM1 +MV.IWQUF*'RVZ&I^`/_"RE%$>H:6HT0(/`4EP/;?&JB(6I_T#L"3:B1\N%"ES +M%^)?I]9\F.&)L"8,WJ/HPG_;"S+0SX=:F]FP*A-9B)NR=&+(%&JV+F$*\0:1%I."WB?H>@/-%N.?'V?)+.A'5FRBZEPC*_ +M17$0K(`;<;!P7<01HWK:2*&E6HHOO4\81M^LD*3]X:?]^WIZ@&^N0+D&P9?W+,O1!BKWW[)JF)#,#.(0<9@OEA%F)]-,04] +M":8>O]63/&VGGOTY%8W+JCA<1P3ET%R+IK3Q%*4'!5^*OPT+8]45OZ?H/S?8 +M=$9AFKP%O_()Z"<7F.Z4FF=LJK"5.OP'6+5<%">'MX=;*H/?&8/_NHW5CP./ +M=;T-'X5THGN:7#CJ+X=5L$RSY!.7)'*%)43,Z +M:[(SL;MGP6;ABJA2^J'M#;^+K3+97?[4(WUXYL/<0C6.!GK4EHSPIRGKVVQ( +ME]1SNIATG7KK7+Q#_5&:XD>JC(]^W^DL>EI52Z9:*+^("!*J;(6*&R;"EQU] +M^K0W.=O_$J[\A%($!>&L*E?D63B0@5BJ@UO'DJF)2V=Y-'4P3`_X.H-WY(=M +M5$-U1^T+M?=&64?7IX(=25/?[P%B'\GN*^V&383:YTC$;&M)'FR>TX^SM<`! +M9'!+CK7^\M-;GK\]0-F\8&#-FJ`D!;;:JCC(]Y%2<1)NTTV\X%O;*4RF=4+> +MT$2CVEQ9.X'MV`0/`^"],F&EG&@W\SV+5[=U +M^^AP]E#K@D\OOQ&&9GA((+(EVX??Y\F*^2S/Q#@=%/NT?&;7Y=#:P;G&2U^* +M7BMA$37J\Q^/'R086#^\(0C?\?#C=CQ`P1I/!C@C.]Z$HX'\+A1@X0/`OU#S +M8;_C-%3L#JYM5-R!I)&1`$HF+3%S("O+5+6MSU*V]^!EBU^'G2HZ*$%$\8]; +M,[QNV_Z/*9L)D;$QJO0MN(U>FTH]-E-Y]DDE*D\Y[]6]FOB!2_\"__.&9;>^]^:OPSJ[X,M@E^8_O(F$;P[A!__ZCXG+X5R8?FVV +MM!L_QQ5'GYSRM+_?O[4P_]2KLGEDM!Q\27'^5]_+U>$!;SMSV3)8,B_\TD>/ +M[F0CWDIM?\J6/_Y1#<9GYO>S?LDGM&"SW?Q8_OFOHR +M^#IC]]7FG_9`,7_BR_W@MM\O=;D_/^KN1W*Y4YY^^;\M<;E3QFY_EW3GYH[6OQ"Z<\_\5'1S-K +M-\3]GI\#?\S_+< +M;+TX>FQH=/V)K_SE2S]P%"Z]/O;2O_KL3X\-KUY]"'8/O/;IK_K\#W`KG_B= +MAQ^?/SJR=C0SO#KNK5_TNB\-#0VO'CFIUQ[.K!Z*?^W9#Z\;WG!2+SB<&>W_ +M?NN&ULK[G7FL]0.P3R=^O74?G3@ZO"&S?EW=\-I:]>L +M7AWS8=PKCF9&AON_X?KAM2?WANLSZU?W?\/U(_"&\'^'-WYHA&I07R8[N2+\D"X'%\EW$W<. +MKYA"TC7*B-\SFJ?O9.?O_0I=QLS!MPOPU%FLR`0]-Z5_7H$_Y*H;W!Z%OY!T +M.X=?Q]>%GY3G?W3^E)F;QJ>@>P=,]0)W67C+;OPSC1=1O,ZIYCA!V`KP5\:PG_HB>7.0HG+,P/^J/PE"P.BLO7 +M',T7\X0$(;#AOWT0F>K@CI;A#F<8(N;S=H-KMG8-LBM-P>P:'GNT\'12&QJY +MN0PLFPL?K]JJAX6EP\@O+),T4.9X;15=/=D@ZSNNSR+"\G;J8GQU9FAT6#OD<%K +M%B\4=*T@K(@T"^8-1FS=FD%OI6"E>IR`Y<$X1("Y8&CUQ2-#`>)\")@CMQFG +MRUPSWD[M6[XF,Y09R713^ZX9TX*#[;=R<):I;'4"H2P>(2;2!C$FQL50LEP$ +M.#*GA8!00&LIZ#`/T4XV"Y*M)^)65\0(Y)91_+@3)*':J53EX>I#JY^EXLI> +MLP2E1ZA>R-TK]"R#%BE+D*5<44J#7\UXN3UN/3DKUR@A<3/XU46'%Y8REH7! +MTGL>P(0DO5:N0EED*7(+P?P4S[P%NLN/9$XCE+K-=N*JR6)9U0Y]SARL?%SQ +ME)QD!6TVLP4_X/XLE-2[:I*[N;7F1^5[2?,04>^4E`P-_!4M!'>/$RPA1ZC% +MJ31>$2/M00MWT2YJCTJXFYQZ*\UYR-KD/*H;@:NPKO!,HAM$ +MBS^\^EEA]4;FC8:IM4-$0:F69BB@'$)"@YH`E")]OK4&=]`0>Y3D?Q5:@S@! +MIU*UP'FK".V`\2NJ/8)!&P\=?GSW/12H#FN@>@GL9&;<]PGW,6YMG9\-^I-M +MIT-9E263,]1LH[2^8/ZR'N^W2Y@:05!>HLVGWOJ>@_W)N1V)L_W'Q[AK;Y7B +M+ER[Y1H^_#^UM0=&>R]/^GD),#*KZ.*L$];;RB,Q[H^"/+&7JF\G5\ZXDKT5 +M;>@H6F'2B+:`GFHM^$%X/(RFC_$C+X.>05;.F$_S[FPI930[H&'5?$AZN2>#/9BDYW,0$$H\GRP4T@9@(T& +M_$KGS,Y-YM#A\WY[#QFWR[D1O)5HG]//06J?LY^;KH6!L\:CY;R*;+@U0?'. +MAE"P)H+?LZ-+F7^JWX-ALKT^%NL_B=RZ=WZP6+=#W`.^I$XN//5L^PCO(A2S +M%0\&X>E^#.U +M.B3MK5TJ7*+2[IUNXKM#(KF&HQX"GFD2'I&CS`"H33J6K@`+WGF>?$G@3CD* +M?J?46HN4M@=M_T?D\.DFS[I8H8<'[85ZEE>/MBT6QS$K8A;%^S#9DJ?"4R=\ +M0(55G\CCS$O3INN=L8AX&"T+-.:JRKK;8YQP!?3$-#G`#VAM$/"0ZVFY'C+N +M&NI""_%,S*%AET;T#/+'JYTL +M_U3`*_0,;[!OWL-T=`A;('7^P.LRTPBTUDZ=LA*"H:(4\VP/J![G:8J<,<"G +MNJY@GP*!S.:H+LY+/"20Z5KV"9CH-'+2X9[*5.E3K&UE0@Q9A%UCC$_3E`A^ +M1-Z!V5;6UE4^WW#U5!J!HG.$)X;Y;$DU-U3M+_J=$.65==O5C-T`V2;"/N96 +M$!=:?(\R$=WV0Y$$-8LZ@A4D"*83K_^,&>..2XU]-;7]F)-+;?]U9BD0[OYI +MUEY^RZ)NR)CUVK,E;<^CZ6E3$_DG6T\6S/$`]I!00625U)QG@V9H*PI\*^V` +MN'%RUD1'E(>5UBB$A6R"2$>W75"4BHBV<7._.VY\HG93H%5_N""[(;>?_Y)9 +MA0T,Q\$&*'@[=/@<^=KBV*2%Z7:3AUY?.(#]LPX("ZO`-O38/@U'TXGTO;!O +M++-X3_G>BE";@3C(RRJ=3`4*^)/:2C5?W@^GWWRY,-P)Z+<'2V^JK`N`23&! +M$^$I7Y*,`;R/)@M<7H$R!'Z1/EM;D'5^:K9O-6/UJ?K^+Q'[>0'WK-V_>K5A%"EE9@M +MSZ3IWQ#3;52Y%XNF':G,*W^10-L(IN;XET5JHVXJ/'2:(=4[RF.L70W_EVDG +M;SP_+,_H!DI3-528(V0<]];$P"32>)UB[`!0HJA:UCAQ +MFW`?'%)/69RM?[:+>@9J,(-7]M:]D:7Z'",=]*Y[Q6.+MHSCRG>,A9\]L +MV_F"M)'^=?`N\I7&`E;"B:>4:=LFKTZE_BU#LX2I*)X###QDK* +M=.#-2H%M3+D2((;=5U5F$<%[/\09,,1((W&!UYQ=+10&70-H7[`=7J-G,XQD +M1C+!6)E'I%H21$@/.Z>WVO0`B";3D33\E45LZ^K@H1A60-=#N@7?"5DI,Y/& +MORGF#_UA3N#@N^`5AT9@82FT0\EFAS>0CBF;#&,Q2M1G#P;I[^^L\0*1Q:Q= +MO@%SB.!Y@!W+&3.\EHPP7T<4BF6C.6@]6`M' +MV(,TN-:)T2U_6;.=JJ^G%'FSI]102^MIWL39`LP2"9/.'! +M1^IJ8"#ETI7!-1/Z2*ZQGSQ^3QPJN?=ZXX97'>&/:.60HXX:R5 +MH4,?!?834H\1VD=XK4N2UH6/Y`%M&WVSFUJ[M5J`2*<0EC.0!C0\\BP-2&-J +MRFOIQA,>7?W)4`=XO#O+@RY)A#"8E"=-\E:*!^?=O(:2'>R#$['\I@J6'FKS +M`P]0VL4YWPK8??$G3K*:A]_DJDYHB!4:#\N3J`G*0N\JS'80BRL7A3IPI$>A +MNA1RH/I4Y=9J*"UO-_GX%XB,A^,ER!-C)&^NLBL#D.JS\9B&J$LS.%!T7.L( +M'6L2W8J8!2&>I).I1C>RH#KO;+CVDZXW5YM.]WK8K0W*4PC3KFZM7B`G +M9T>15`3VH"QOW@N9P/8SP169@WY>4>A26@HQKY4K3F:EU.PFM[1JC3F_AT=Z +M$'G15JI-UXH3P/^M?6GY]:9=,/6X# +M'+L"X;5`2FXLB>3*5&^Y)(Q.2H$U"*?*2Y4SS4/\&=XD1HD2^+(E:D%%8<+H]8/1!1@B5)-H2Y$2ZFX +M9T]()#1BCASYN79BL##A`H4FL-.BRP/#<])%(H).548B]S!8JAO*]_'T;-SC +M[9S$]0\Z$D)5@N<$6SFGE$S(;1''Y`R[GLXS)RC06_\/#YIQY*>*O@Z+V)+; +MWD[>=[9DS7LOR!&FDZ5-!^`R-$2B$%:1U2=`#?M&%39NF1R:*=F`+;BX[&"_ +M@<-Z.)KW>^^M3)`BT8@KV_O*LPO,LE,504KR\*@BP;,#P3(64X-*2(5B`>,_ +MMT:#7+0,C`M?:3!XGUI/XTC=QO&C]^T-PH/8V/A(QZF7WZZ=_,5'/7?))VJG_(,(>X"E(\\> +M"_^566W9ZN6O7ZI"ZLT6T<@GKKB7[['B`%.T4)+36E;/JPRS)YS,,:OM^E7? +M9O`I:A!,,1>):9G\`EV'9A&,+S6GA7KI]G4L;4^_1!(6E<*-RDN;H\PAO//A +MTQ[S`$%9EVUX\&N'S]C^%8*R+COE\)\&+_D6+IG3+_W3T/S`"PL$+6LGCJXE)\VF@QT, +MKGOW2'W^+;NGBV"18'XWOA>UW>;'[BMV!)U73@=75J;+\/5J%M5P3WUC'7]; +M120?K*%K"'E'H+G:3!,O@-$HOC_U?Q;G!/SW@NSB=?@IM8+"MS.M5'+'6"MQ +M?X4[JF$"FH-X5#`:\/Y7E+*S\S?OG(`5]J/SLT:[JNEGV\KFV/!P&=S2Q^\9 +M;\)5#':I0&<1W+4RV4VN^U\[JPOP)?#.@^SL;+$\9;;# +M4Q(U1>UHNIWXXVO'P66A]Z^"&>27_Z^GYRKI8!,[2V[&ZA_ +M,S0ZNA8\,7C333OD5CNK#*I^\M4$S.&IN6&L]?#+JHVIT1&<$/C6]D*99@0; +MJ#^P73YM$+1P_B>3]&ML?UK^P#]L$\C?[`*B_#P8(4'RR"R*^PD#*AU<"#*D +MW\(8R4OG`C`R`7PX56LEOW\WMPC`@]2G"^W$1W\);WWE'8URK@[V!%9R=*2Z +M\!4W6&`-\KPCZH6J&8.]"#'<=+$._FF]406/!8*`R0+7'N$6L%;A:LB^<_5S +M-U7F8%=-PU7*N,_*L]GJS%':3E>`Z>L)ZMR]&R +MLZ*G>,YL!1<&'OL:L&B%JCR\/S"UHYG6HPZ]>N?TYE8J^`3M&`+7PK,P8C/= +M3KWQJ6P]#!E"G"WPP6BLX/4L4#08SQ6)D2C84R;]>30BI[Z1WH-==;F]9.?` +M,&%#R8/;BZ7F1+8\$UP!81HA7\$=LP2B25O\$ +M'NAL.^"//[B(I4EPB`UZ]%1T(.`M6B]$!=,A(1LMB"!GY?4FD?3M22^G;CJ8 +MIP489.I2@7'C;CI8<#DR8=C^TDH]>TW\AFDG=YV-*8'I0G!=I3I3FZ[,L95Q +MFP0VU:ZSLWKCS=EZMI5\X#?73-Q4`+N4JZ-]2=Z]9PZA?(C'73-\<-UP.MB\ +M[:H],#)X\,R!M8&-$=#.P._BYB`+`?9@)AT,K3\X-!I<`X_[H_,K$[QBY&Y# +MHQO69O`$&Y^CT:']SV_[?)JXH%K*@K&[>M.X&1[R)VS3IO4;9+XV02A:J;<3 +MGSY'YH;_`'/QATWCZ&S`,6%HX`,:0+N4D:8$'I,_Y\P=$CC#GV;YZR0YHB\9)3!XIG7JP#XL[GW^[,LS5V:"JPN- +M:;@!G6'Y=(`7S!=I8*KIX!CM6'!FD5#@5^_87*CEJL6YNCQ:U+#)/3%K`1-5 +MF(.9RN`.N!K3[+#X!K?RF-U((8/:DTZ"`T]#8^K`G+H1+#3P>PC:," +M=(&>6B??KM?1(6\,MVRUUGVL5#C03KSO6K%=\!,X$RF2HB5)+LA63)'2&,/[ +M_>9W,JQH&OJT-/C@?./6:=MY2#63KS^#K$3FZ:SI=E"M=:SX%KPG1V%^C0$7Y42_+VIAK[:@>\UYMK) +M#]QU71'/J6!'P13J\!.T':^X*>QU@"E?ON?7/"-@/=15Q2\N==[@L*5US4\O +M8!L&_+0CL]V"A8_SKXT?-/M!$_<#7'1WFPX!&!ELM8=E5)EJ!MX\;LV6[$1N +M$C,+`2A:^.?#GFJ_$+X`6V%YYZH]M8XW]&&C/B\':G@SH$@1!BO$;`%K@;[, +M>O/D&M*L9N5BBM:C-2(O"]8C=?#QN(#P>79G@FM6;JZ4<5D1^0G&&%>9PCXB +MQ$-"9!.Q*S@<8%OX3-S?2K7_HB>!>IA@GLY]^PG<*/0RO[6?7.`*V?4:V3%X +MBCEZ7[@]3=T"3)TA7E'\_E@3S-IXKH(+L,1%GBL;I:;;3;`83F3]_7G::DW6 +M./D'O'MP5)$?XI:/;V5/#+O:^W)1O`K*`=I#P3=<37Z2X[:C&`!PBY[]&>/75EI5,NX +M#5W]PT-#*W:.#H4'`R&AE='?77?[%`;L8S#SF*!.I_P@7!];,UT +M$P_^'OM^P;U&UD-X(W-5!9^0UL\5J-5<[N!`EV$?T]_AB4\_]3+89,&T.[+3T;; +MD=ND2DCNBT2?:JI]PP`7CS,,\-=9Y`[^CWO8KD*X1=8=XC(T]SNR +M"WBZD%-&+QF(3U##G_!B>>2N;C`V:U>!/@6N7]K9LVGT;#87XQ]NIGST-SPGUSGD=T_&Q/0O!+GM^9AJ%EL7E//UO'MR)&;R_/723 +M%#@XJ4#N+LZ=YOKHZ*TNP!L$=7ULL7;X:NW$7WYS"Y)R\;Y:VN^WDS+/E"L&/^GCL> +MV_KCVU]0P,65;08T44C3<>MFF)<%>.5];(&Z<`4Z.@,].`UX?)59@\NZ29L= +M81\T9@4AT\0%X"_$C=U4>X"B@SGTD*WKXSKLR#B;Z'@'=K1-SV@_ZHVW]G'R +M4Q\XA@[B-3NWKQQ=8\<5QFJ-/U80PZ_V5EHW:=Z,*VU!IA@LX]M/98A%89!Q +M>":FK4]CCP6WQ8UF->D2\(R;D3XW3P&2GF*TYSF@TB[%='OY\3,B'O`N#+=K +MA2"+87E[^:\.[.ZB2SQ7S-$1L\4L843A[L?/&,OGR=Q7K$-T79<\,GC#4@$< +M@O=LWAGQ)N4XQU>G%=,TM,Y6P_6^=N<6P^QYTET)'VQ8'US/#8E5=LOIW6?Y +M*CKV:#`6Y#T[O?X(&<`#*,C+^9.:X714VGT4FCD<\MBCCYR],BSB\]S1!ROE +M`\/1%$+JKG-C4@CA<\E+*FWDC^`-9W4"IPOHYJ%T^Z63]0J\MX'K%G.F``-_ +MVLICE%HX_Y5VI+S40C=U_KW;9N=XQW'"T7@)1X.#A?8N\*UK&WX$0[4='9I* +M.1URP"4M>>[)I26ONZA/6O(6RO,>O>'*'1O6X=C^S^SBU9B_*Y9PZ6Z&D_1M +MYU]9X<1.3<_2,3S/=C1SU>C(ND4T[X)\2XTT^Q^`)YCJ2C6PGOWEQ*"')J]U4 +MS!1,/6VY8+O1!0-N7CT3["S`$JO!T80==EM*E6HQGV5[A%<6:XZ;8'ATW<&1 +MU630-ZR3I0YS<0,,-WOB\/T=[(C@7.RDDZZ;>.]V^((S6,G?O'%G0,1JL*(* +MG`XJ-9R-Q;PG-V)S5R?Z-LU!\N\*A?C4(UQ2W)/`.B?R_#:!U$Z=\YU=NP9' +MUX[&NBOG?"?JKG1"SD0H8,67"84L%+#"R?H=/CUH;O4)O.PB#M95X#P,R6#M +M@H-OV;*K8'V0=2MF$2WTFL]>F?&B3CA37_-9]B\4.Q4*/0[&\_(TQ^/&[ +MYK`#L4(BNW#FX8^M,RB!M/&3)SK-SA=A-Y`Z<2!*Q>793;[[:]8%\7P/$^>L +M&))$B?5%>D_'Y5_=!2?/+GJQK842>6`E77JA4Z:5VO7S8YO),$Z"8:P^?B>8 +M.?\\)&#(VM&8-?,-/&]]""01'HP-')P:*WO]^-\PX88'9;Y]B(;.@?@S=#*3`??.8O^XI9B&5\?_O<` +ME20@E*=#=\S@.3)/YXB\IQPE:$OX,($SX-1_.!O/@.1#[XP]`Y(/_?"1GP'P +M(^\,"#C1SNDVW@[#WO`0!YH,SQ6%2G6*/$GP"Q.[WT!4:;!%OO&*8UN*U5J] +MN`*39O+H`3YW8GRM;#C)/S:%D=..40B@MD!YO(W%U]M9VZ+;1& +MKRX62L12MODIDB/:FMF5">3/<*2^[;4CYJ"5^)>`/X0;S@1:DTO<.DX$[A%GN@O?CI[,C9I6HWKH +M,4R5SU+51J0+]ZM(/:YE3=^6G9O&1D?@O:A:1"ONI#RL72G7 +M%4NE;NKB=^[$18=H`-R_I^4N(%3[#\J5R>*$.4J!93AV-\B>10L4+)FKM3DW +M':Z!K[.E.%F?EF>W5@Z?7@Q=J&9P@AQ&&JW>6+-Z-(T9G<@T[MRT8;V\TWAQ +M%A-.K2/$[M(DRU6&`%?6>&_>9E,)VZUAY;[.;,%.27'70_0DE+[!B&_)-*IU +M<:H%NXUY>I/?S&PKMQ//G^DMZV@4&2H"Q>37POYV*_'6KT3\;;EY9;*;VO7B +MS07X7JX$(01\MJ\0+N>F5L_TY"+P+II,WLWG>;'*AP8J1X:<2T96!`1^F+-7 +M(,:`(=\9ZZ@SMF;=P>%U:S/!Y:62Y,JP(1JBO@-<#PJD:@W._Q$R$6PPV1`'&?.C +M8O2GY17(P(A#TD[\.!N-I3NQN0OR1-A8G-K>5@YZ$JOF!&E5747^]'>3_]^S +M-S]OD_\)\)0X'+#NZ=#:9+<-!?-+R5N?-"5 +M:KTB)^L`KD8EB>W;MN]<.3H2&RV,C*"WM%:B8VJJ@$UX.2=_<6$AMB'\SJ;W +MC=$N825Q_=`:[^6IC5[>',:NB'K%%WT3_DI+.@^V\KJ/TVTMPCA[4ED;76<4 +MA%@;O-'L)"P.PE8(C]."F]&:)_2G+BTV6_!F[=3"#\*5`XCN@X_MR-I<$]YC +M94WKS9[GTH*?AO.6`3OM);? +MQ)7N^\5A5/39L6E\<'1X$/Y?9%+7A":UE>RL +M@K_.RZ0N?^=M/2"++VR/6.R-V`3SA<%K&]ERO5AG0SU6JQ5JM5D(H8_25\+L&!HQHSNW +M@]-]5=IH7=ZEI_W=(9@G>WKOQ$H:G(3=Q/M?=5W@P%#)XX7QDXW5,&H2LGRT +M"OD*.2[(?SM`,"H2!_"]L=YBJ%I$9CXCU[:;?.-C;41O5HCG[%U]%\7QFX0EOY(0W/2>\X?6B=_;6S?&U\&9O'YM1FZG)S.C_?AP7H!-`(^]O9[/I,TF#IEYQA>B:X2/F`)7&+HO06NJU@J5I`?+`A[L!;%YZKS=?H5: +M+%.P_9;#?SZ^]I;6G][[FF^-P6I:=ON91W??TOI+8^SP*;]\^/)#K:0Y_(*` +M9BN'7?[H]<&]D`UK/R?B@^UHON4ED`S[T*'7_7[9*3.?.>5OW_#I"YZ#R;[D +MOV.J[Y3W_]7;EJU8=FXLV^;QH1_==O6RT!_KH\?3MW]P_HO^'VO-T>.K[A[+ +MOF?9J?`'_$\J-UM==WS@,_]R-5Y\&?WGU-SLQ(&AX>//KJ]X[4;_YQ,'1H\_ +MJ_+AO[_/_A%_/GK\R?67[_WBLM/@WT_3)UI__$E_7K9RX[(SX`]G\#7KQ:'5 +MQQ__H_]X[H'07^OPU\<\^3<7/M__*]Q_]?&S3_G'GU^U[*S)2?H/_W7-\4<_ +M_<)TQ_]NK0G?77'-TW_R=_XCU)KKCY]QYMLFGN=_=18?X?35A5NK_E=GX6E/ +MN^K7+V[:K\(?J_#-4[\;O&V7_2:^Z_KCR_[PP<:Y_C4+\*C_9]DIK_ABXD?\ ++?_\_)"$UH(B!`0#- +` +end diff --git a/contrib/bzip2/sample2.bz2.uu b/contrib/bzip2/sample2.bz2.uu new file mode 100644 index 000000000000..ca65c3e5180b --- /dev/null +++ b/contrib/bzip2/sample2.bz2.uu @@ -0,0 +1,1642 @@ +begin 644 sample2.bz2 +M0EIH,C%!629367PQR6$!@_U_____________________________________ +M________X3T-[WV#SN>48``!H*!H`-``'3:NO$JCVP/N!K+L'U2AE +M@`!.QH[YW>@&]ZXY```0:`^@``,G'WQSWQ[NC('@`0T7L!W84*!XU@`/30*N +M[JV[@.%Z`#H\>Z*W8>[/KW+>DO>7W.S?!J:CLQ5(AJVW.\ZI5//IW?;X/OMW +MAWKSFQML]N[8.%BXM6SU/6TFS%+WG3TWOH^0``9SF^ +MWO>C8-E5;-@)@H+)@#>YWOMW=KZ\#D`4`.@38`4`!3M[>V9!6#K@EUWW>O8Z +M:F;UP?`)][?1J[,$OM<9SNJF]:\'RTI'V5 +MN1HG8^4YY53O*^..*#[.OO;;17-W-:^[`D&TW'?=O?6K[W9W!K2@&5&@!KWW +MM\4/ON\\];WMWL68NW1UZA!VP/MB35DV^V]\[UIU2ANWKK7VMMY]U>^5&J>S +M#JL'J[N3AS#NT<[@[(RM[X!U\:\K70[CW&-TF/O;HQ\WW9N`Z[9)5````=V! +MS1C6W1J^)OGJ[G="J#1>\^^C<#UC=?>WN^NVU:[X3.YZZ#T*`]4#M>]8B(AH +MJGWO/KW61]*=T-A=.AV+5?7+.>^TP$M?&OH"@%%SOM%MWW."O6]FWROE=]N( +M`"0``5IT5WP.WN=GUO(>*G;.M[WJK)>85X````!$````1T4%``+```80C +MH'U>AII"`@`(`!,FAH`"8`33`$PADR9&@#3(R::-----`T:``:`` +M*>T```&4S0&0#30`$P"8``*#4\@0(00@(!$Q,@$:--$]$RG@2>IY(-'HC3-) +MY(\H]$9&GJ:>IZAH!H!Z@,@``T,F@``]1H:`!H``#0``:`2"2(3("`FF@(0/ +M53S:2>U3&B-/1-/2GXDFGE,GZD/*?J3U-'J>D_5/4>4/49J>D#1ILIZ0-I&3 +M1C4`T!ZFU#3TFFGJ'J&C)Y-0#/5'J>H]1IM08FC0T:"3U2D4342>TI[2IM(> +MI^J>I^E/2/4>D:8CU#0T`TT`&TGJ9!H-`9`!H`:````!H``#U`:``T:9``:` +M`````!$DA"`(&*8$T-)F0T`3``$:#30R384P&FH;4VA-IH&J?H---5/P&J>3 +M!H5/>ADGD3">IZ:3!-HTTI^4S1-3VA4_T)M*>:4_28F,@!JH)-1(($`FAHF$ +M$T------3!3PFFF)3>3":,4T]3T:-";13:GJGXJ?J>J>&F:-3-4],(GZ:3&I +MM)J)[U34?DGHQ%/8(]0U3]3TGH9/1":;*GZ>E3TU/]*GY-333(Q-,'&@1`@5 +MDB3*ES)LZ?0HTJ=14U5765M=45-55UE;75E=6H$0(->A?#APWS"&_JVK-LT7 +M9QZ$Y(D&XDA+]"T@>I>G@/M3AKE!**H13./4!UB#^^MC$S1)/N7V_G%;+2^[ +M=K[K:W=38BF8P**,;JEC&3HV!1ZV$CC>=D@$8'S_U=*?`B\]3ZFVMG]Q#4]_0NL@KRI7R-*M[QONOP>HR*`/YLW%D]-`U.0\/ +MKCW0@>[/H<\\E8UQGB@.,Q7=6*&0\TED]U(^#C1<$6Y*T916G0DE$/@00,S\ +MYQ%E1%;X#B@"B:J*@W16KMCBN$DX>.>13W\#%`YZ/[8F=+CMX8V!.5J%3OJ: +M($3ZV#P(BO'`S[7T_.SSD$)2$XXBG`BVEBE=5P7^Q1$#Z!E2%2%%IMFVS&B_ +M.JH$@"+!8?O`^ZP`%41Z5S8U%Z7]OYU8N!=+7GG5O&B*JC*8&J%BL%PTGX*< +M-*#1M,DMH*HIC5!0,/XJ4@VSXS9^T+QWZK1J+25&10 +M*>J$B2MN"U;@HP;0V>NIRI&GD;FR$H7SS+&Y&1.LEDC40F.200]2??L@VL9(Y2;D2Z=;FE&7*YSEFO.%=W"*3/-W307=N^"Y@'G:+D83D;H^';O+K=<[^%_E.KP!Z1CF3.ZY&I-( +M`IG=QDN[M=UVYNW=TDN[HMW; +ML&.:[#&P*69`(@"-O2Z">0*1C*9*::2**-(4/_E +M_TXOXV_?7[Z]KP!UW4F_B&[^[_T?/&3>V +MY;,1$,HO.Z,=?-Y=2,A#SM7*Y73)DT0YNP9-SH@D[M%V3G +M/'(09>+J9G+DF(5W=E)=W+NX29$4*,ER1LYQ +M(7=T85$(RQ3[9U%*&)FKQ<=SJ*8SG*=VZ[J=V(EMM.7"^;NH7CD@J:^_[L>=O\+SME4LH&;X]CAH +MWKNW?8\O`%\%R+U\W7+SF-^@):L6_AZ8P?O_P*S<<0-?NU0C^KU,A^Z=7-]9V]=WS]U/.T[B)SN="8DS1)G.CNN8)?.N9S>- +MX>=]%YR!&`DO2XGQ\Z\9&D31]'.>*X;F +MYC[33AYZ\*9`!^J/EF#<\8\P#<,_ZUI,PA6G?^_^X +MP7I%<-BWGUM__>5Z1KTU24TJ*O835M%!Y:U8?`Q^IG@_L-)_*2:??J.9_S/Y +M7A+.>C[H%^NF'E2LZ*2"BPR=#TYPEF>5& +M:6@E2"0^U4?SKF?":F2O"`H(",E\"AASQA&X]3YSO_R7L,[+D<%R2YM+R,;Y +MLK"L/'(%8O)]]>FB!SA#S%@L<0&0$)&4)&0(JO\B8G,\,LL^D;/N +MGF5\M43[+++LFKCH0M]P-47[_Q?98G%-$7"@DMJ4<7Z;]VLN$UY,\"(@4D1T +M\GV>)N_[AR_$9,]ROBX6R@WRBTA;D]6H*:M'FX"LB0TRL$%VV.JJM.O,\1EY +MF!F_=[JVQ\AO^TWIPRVW[G26?T]8_-)H?T5#%SOF+6I6>-N;[A`%O%+OX>$S +M[VZ:1$'GB6B`W3Y?.^NY/@/3(N8W'G_^#SB*(?.747IG4ROM@""DA?>J"+:S +M0^M;H$1"KU]^,Q4'VO0U7U?9\O<&*9L?\( +M'G($]LA!\Y`#R#M\MHVIHYB/",%6FYK5[]E?\J7=C=5[H_R4$L.B([Y!/J;)2*#>O- +M?X?4]CF*C62.0DH!%-A_A=R]V4&5B&\:*LIG57+XCHAB!(`_>Z'#^7(WW>6[!L_.K]$-$(0"3!NH02Q4S(,1,Q^UWKEO +M`UE)Q109Z)$5O4IDD4G`FM8G-_=]T+SOC]/2X?K/@'A`(C\NV,076YG`-G4/ +M-H\'GM?94N__>/LLK1];O>%V=0!`:B:N/;4TOLK%#JA?.#T(@(4-'`YBY_/N +M=;PH`YK%R)'T:OGO\;RD.HLKI59FI7W#==:*J1K+>">&UV2^/)@``.TA>DK) +MP^0W[\G3,J_YFZ<)<(@H0:SP\7V=11'=4.TAKS("!,F0GFSFQ5M'PP&]A61N +MQ[ALV>F;+"XWZH?)\UX80!`("`.5D?\RHY=DON88"E2$1PB:U9YIUP:98?]. +MG +M>-TOX9P\[7K0:$$TE5[_/]OB-O)CHY2N&53N5DYX$9E54QH5E4TP4[XV@Q1_ +MOX0`(@`1>'\ME2S$?O(]OH.I@3%'_!*3VY^[/]H6K+P7Z1MO& +MMO_?^UZ7GV$D32$,:"4:W/\.YI%Z2U9"8*&^1TX6E@00'.*T?L[&;YG\KEK2 +M"Y;;,LQGLR,C-"N5``OD*EJPM%!6M3Q%1%#%RWO>'EN$\W;[&3[?>_[D9;AO +M^80D("9@[HM<%^*!\3:_57?P8^*OW:56^_]LO['1X9$1`9AE`S\TB`>@`P`)#0D4($7V%.3%BF\T;GH7Z/B:>D@ +M^\ZK%]JKENTOFYVP0,[/AHA"HYB\#ZP8'4:V"!HFGX^NS>RZUP@`"88A_)]- +M.E;;%:S9X40\/M7VCMS1"(!BFXZ'((@`$V@_5"C6X%&@,>`GL83Q+_IEX!KA +MH>5RW??CXWD7/0K=NEYS]&.QH@NV9XTS^7H)00&29:($N8;I$,FI]7BX-M\_ +M;>BV=[_@_&&MDJ)2)/4,!_L>P$ZSH.?V-S@AVO7'J^MH`3X"<`J7_TB78MI1`%`K/_ +M70!W_T7_LUZW(_;J.G]=Z`7+GE[NARHGA!P8YG!TMYJ>G&^U`JY2^/TI(\D) +M/1)O,-[YSQ>7KTBW'.;1CR)!!KJ$7KZT>,4,U1E>1R.)#1I"@&=YYH1^XW:? +M57*JUE)K)C>21KEJ&/EE%M0W0.?C8\1G@RYFQ3Y@5:@$H6Q%-&[$"DC$4`J" +M":Z`^OSO.[;[;[A>0Y?Z+Q_'%VN[9J=3O92@/^T?(ZFC=P_F8.V,#5]S@;C&Q=3=V_%GI*[_XVY +M2.PNV"04;_NHX.\`41O/R+,J`I$8%^^,)K6[GU59VH;U$I$Y#C6O2>:%R(EL +MLGM`;DT*WXCJL.O\.&P1*^<)`N>ZO?;[IPLD7KYX\,(W>VL>W+L8;;Y?E3CK*S;*7AJ']+M%K5H?M/XOX&R/VG(7V;@2QSN5Y,)N`" +M"02:T8'[TWRYSZ@,$J?)%YB%DSX+D+H0"![438I[)*'^H">$76^RA,TLL88X3VFO-[ +MI!X#GQ=@6-4GZIDOJW]]3+(048>9?2GLPT^639\;[DJ_9G:W^/-TX#!LHBGF +M$+6Q%O%J&AM&UM7[)S[!A`>$LPY&1$50F>[*:XW,/4.4#>HZ2-A`(1YQ*2$% +MTKD=JK-\I5<.[,E/*Z11.'_>^9XDD+5&O*.Q-^L;M=W.OF90WTHJK0.S9XUX +MSHZR'?NJ]D[+4&$"XJ0*(O&9\X7)NOKOG^1#RIS>4/OYJL?KEA?0O0&2UFA+ +M`I&2!"OWL/^:6J[I&03&Y`F7R["-S42=[OE_,UD@?" +M_VUV4**2@R8F/+-#'Q(`;=2%EVY#$NHWKNV.2X(Z;49Y@A>+ZK)M[#KJSU8] +MRYO@O*>%$6*`RE0@1CZ/5QN]Z80BYD1>-5L;9.D!ZR>S&Z7-@%6^+O/4-1(+ +M*S8^'3`R4>1->1TO`J+F8+A9,+62+HMTC6F(G@_-NCT;^;>`:CZA0";00WK, +MM>)2_WG(0US7'[5=<\C&%M;&5;^%Z_7\??VG+5>E1S'G$T77IC9=YD:!PF0J +M(XXV89)X<2)E.-*\I`"`GV(2*Z&A]7/T_3L>?8#7?*&2!&L]J[$U$GD"`X`D +M".ZP0U268!$(P\H4+W(ER8'63I8J@QI?0A7"]ZL3U,)5Y2C)*JJT6!X3;9]M +ME$&*ZU#4AG`:Z=45;U7(G4[6.LF!T@)SV/;3\?7_<<>Y_?C%=?>'GY9^`5[E +M.?8M^57BD@SY@SN(+$"#%.FPR)]QQ.$1!A94NIC\NA+E2IU2M.A&9[U"?+=* +M,="YULT,=VF21,G,NLJE7T73)XW7\_CZ?EN[\K850%#%B>!B]XH@*!BMCP\&(YBRF54E$DB0 +M+@@$%!72KTG'X[VI<"[3VL[UVFP8NFC\#BWKQ2%`417!4W.E.(#4OOM`@2'( +M:W+BIL_;*/4UX0AUY4[EE`\F1>"A]F]MWHQ/*=`QC&ZMC(3 +M"QC0WY/5PB1NW.?ZPU)+ +M:G\>''51X=N_4.,],PY+/MC$GOW>\Y_IT[1Z*_?X51MUS?A[WYX#T6][2QS. +MZ[UXD9UF2#&:O6W6.F#G4D+5?R,/.Q,UIZI?PS`E#++=1A[Y1-2[\O'/)R9$ +M1@PX1.)PP>F=\L":+3ZJ'6),TH993>E5=XG]3F/\!BH':%/.A/&L7O'%1(BLWO'%ZM=^&SSJNC&LEF\% +MC8[!/&M\<1."KYJN?SX%1V:S#UQAXB60S+Y/:IATE)-4&4`5+L9EI*Y8?!_= +MC&K@YEBE<*5K2J]]WD^]FNHN-7R<"[*9`48U#PAW0JHE,F=W9F+R+]IA_'/C +MO7HV7U.=0^L][VWBIP'."B0CSS#]T=XMP1?Y[U>=Z=*F]9ZI"NVFH9*&%V:F +M?H<@?O;=O-Q^V,5A,R#9U$;2D;ID'W41?N?-[@SXU61-AK,.KVB`RCOR^Z$X +M-]<4XP7GTB-2)C[SP1B4P*J>7M#8T9R-C")40&`DN1]@97]96VZ`2D`F*,^R +M&!(9--!0>8T(7GO^\$\C@\YC`#/JX33E7.RO)>(ZMO>>UWN;N8XQ=NS9KPJM +M#(Y9.4F=O5:058'1-B`,VYO]GC#F"W9#(O]Q8<_/D+7C[OPW&QK/[:&G3MS) +MW=^T(V)^]S2VC;PO7D"P^WO[O4Z`%&WYOO9NPG^Y3ET.P\.G!21HN/5"#XFO +M>]%P\,/)?41Z.<6MA%B0IKA2M2!3AHAZF8?A6-Z&+KI-07W@JDW."C0>H*:& +MF"_)Z>V;?6;Q[>[&(Q&?IC'V)#FS($`\TAO^XRJX5[27!]%E1O*\I@9P5V-N0"#[7XL]O]%_P.^(ROY_S#LNP +MC.42?Q\E^T+77B^<\?N@?"CK\S=]]?X_MQ(>4V"D.XR/I[17048Q8P,>+X99 +M(]]_IUU!"M65;7[U7+Q;T5*PY\/9)@RGNU +M-G0)()))(PQCM%MB5W[T*'?M8>?%X<]`-D'-Y];MA,V +M_/H,[UL`VW#@^'C47$^NJM@6'.UY[JFMW+BR"!"S3S'7A"TX];6 +MS8%2/'(MOS?]BS\\4TWMVMX5:NRZZ`+OZ8[EDF"`3'H*="@9!;>QBJS\ +MKLFNLA@AUZ_3\E9S#7CJP,.$*`80HAENZ0AO])ZN120O=^NU+^KGN8.\\3>= +M:8F_U<4RWC49,II-BF1J*9;7R^GX4S-/&8GFHXQQ +M1D&^6_@XP]V.(="07!%,3)5A90+6JQ$*<5!H@$$`3%!"\W4,9M_9W9Z5&8)` +ML&:Q$(-:GEX):`6MAU-C,96?C4&JDAP4K6`<5:(9R4"2PL(?M6\&ZW%TNUQ=K@J]GM_%[_?._W'@?O]?NV\75E?*]7L2 +M3F(^$57I=Y9V]&_?0\9CF/XLB)77-VYND?/\3$]>-=KY83>\6;GX645`0,@U +MMD0W;)3O=OX^M0^--D7'$KNXB=M>D<`>YU87XK6KC6T*'KQ#2[M>.>W345RFGLX?QQS:'SXK$B(=Z0?E.P +M^0^,ONN6N.#S\AU??;-8G,_L;^Y_X'\8>.V8Q\OS[\=_HZU\8TW7?BF'%JGF +M$^%4S$&0S_JWS*_P:R/E2],=3HCLNFW]+X+.VI&>O::!'1^#&EO75ZW/)]/O:88UC*=]:'*^Z_I%S<_+.#CZXD=;;L:.C+-#CEN +M=0U^-^BZ;.G88^EHM[;1Q=9O3\9/4O'5^EUR\$3BM,_'`-ZQ,2AG +MZ\:VA)G+LYSB@\U$<1]#*V/FNL#0OJ[3&F=Q"Q=@Y%.0U,[-+=-?;8J8HGI\ +M^[-/OU'R=Z$<+6=J>Q]L=NW9C>4RM?*2=MP.34<9QQBY;B&[G?96*VVCK$\7 +M>^*W>R]-14:E[RVNG^9AJO.KBN)NZ\[P^JRR[ZX%#;R^/7`K?N58&4L7ASC$ +MC*TT]$=<%%\:?DZSIE?&'&2'?/EGA.F@LX-^DF](#R._51P9'@ZY7/:0_VU+ +M[*//2S'G&Z\'E[RRXH(>E(E\-MIPS/-]3_!E=]YQTOFWC?))0PKETEY4F_37 +M-E9H@\9@J;/'26U+ZE$0#(%$:0@03(JTAX1V>Y/B;)?LI\^@^(V/"_--V)XH +MCD\J`,)X;SL;C#R@`]+=7:F\_-#-Y#7<;NWQ7NSY/,OV\OB!P^(X5LPBD%K5 +M8S;HN;3AB!>.BV1SNF(N`[XAIQ:;3Z7#%B[7IX*VIT!NW%T1I"**)1))^3A& +MI9CKNOZ@:18-;7WR72,^=/0<%;UU`INV7JH4CZ`4\2UP,B$#=`UYY\;V(!;8 +MO-L%'D;AF[@#F`0.(('&SBS?J]T3"@-9??.2+.%C=5T].XUAB-7Y`;;@0++& +M0&_B0X#.RA>X/#"8`1=; +M);FC0IN85"*[%F)HH +M71M2CB)$BS@+P0<"^'X4`LB--:($OX$A#Q`J@+(8O%R@'S!#/)!F]+,$D.1] +MPHB:%>Q3M-A@@&"YTN?'FO3K5SS,CSK+V^0 +M*O?.B7B?[OAGU#;FTDR2H)WS1%]Z*>@ID5-5B`,-W_=\)_?&(!U/(OU>&#-[,8>:&/$3P-BM^?*$IB5>DR0#A&/V[@)01XC$8BAB9<2)1EV^$:DH5MZ +M9-,12&6LN8),-F(F2.*#MYWI$$VE!-25>E"`=)AK4OX[K;-V^N12&+=F*:M5 +M3V,#"QI1B^IS:M(,,++OA<5-O!0=_7"'-]]4U^Y^C#P80`#M@-YCPE"1FH*, +MD>&_]_/^?1M/\SGX=GA?2Q','PIGQ=5>KSA*:'(5E2U!01!;J*VP;@V/X/&, +M+\+!B[S\GNC1)6#440I81)*7QP#G*#'F^XIMH\? +MO<'AZ=(BE#R?:^-^?R>ZX;(HG_W:Z/1=(+)!;U%.4E:0,G;J@]#W\;0V0R^P +M8I&O5<8$2W6ZWWG)6PN8OTV[$%II2I0I$9[9XNDYP>4OJM4U(67%-MH155:C7=7-Z*RPS/Q\A?IJJ%XI+ +M)$T4E#)K>1MDIR#:6C`P2>%R^')9TOVP'T4,/)M&2I@1*!9NS%JO_<-9SM3:`87>N6N=OC98Q#+7*XO( +M!9UM1U<^WAY5EXCQC![PT+`20]VUD/V[/_M?F;*:^&]3:(O&)X$0#'QRS!]#Y<,[!! +M;U,B2UP"B6!?G![IKUAZ2.*!QI[Q\V!JZ=>B670O[^I%.[BH'RXH@/NO@T*H +MZ6?0B3ON*QW(JO"=G2@/:UVIZRM?N:TION5O$J-G2:JGB"T?* +M7AQ`20+/7*A0(4YK@P_KMU\Z?R?->#]8N]1R+!W'J]']U4@050!`J+>'H-RK +MF[EV&>\F`=<7X8"Z"N"O!LD^`Q\R&@VMQN`_XU^LIIYXAQ)_FSGI5`HX29*Y +M#.7#MU,DUJZY?M-'&5%M<=G>%;7[5"\`K6'MR,I\*"/^5N_0?.[S]2!_)NC. +M&HBS'@.&=V2[X/\]`1_A1OVL/8)!6`SEZQZDX>+^G_<]Q))`.W@/R%41!$&, +MLAL23("*$L$L9HH9BA-%$2R)-!A2`HDT@V$6("`A(0$@\?I6W9N\_)WN[9+2 +MSL3==MO%M_%_F<-]*I?8EG&]$*-=H\1:TUPXM!NWO:3M**WG,3C +MVX360[2,#5'@'A]PL*8T.$48AHP;)%$L/N&JR8(T3]UK0?N=%WWRJCK3S[DL +M&Q9MOPPW\^M_6-?*NAK#CK=8XRT*O5X[/-^V\K\/Y?P-#YF`<$]RG#(]=8&;1E9^MTQG3_QXWV +M!.'F?E+^7PZ/*,]:G5U%U(0$`H`$81D&$4)$.BRKYLO-HM6Y.O_%N@_[ZOV_ +MJ.K\-[3*]S#XF5W4;_HL%PHX0;L17N=HR'C1$@GW[Z-U`!O8X'+V8['3PX"- +M3H%9Z*-C][RL%S/\^?N.0ZW]=-L<;,$L2^\]3_:NII7Y^#1#I$3>+^-X48M5 +M"A55(:GD'.#E`RRY@AAC5P9YOQ[N'!P)J?.LNPP"-SWN1I<]N'Q-9JXJA1J@K4OK?T;_>Y&<:!Z*)N_ZYPN5F32)LP2BV"L#@;*W_^8G[>DJ7M>08DHZBU[V0R2 +M9.2NWY]/H_XJ(C:J(P!21,QO![U0I"@HH*`E"5=Q=?4WBPYS6RA`"$ZF53O^ +M?%I>"7]=^UA6"') +M_$[NWORSJUO5>)V0?@>/,%K24-J"@6D46[$/O+@`X!0@KM9QKP;[_"?D_/'W +MWYO^$X,J9K^':9JW-$:B#;ENN<[M\[Z\#;^ +M=`P_'/&3'$#!6-[:+S>PU:TXKE-!^NG"CS(K(FY9L,B\FY[P_7`N8`MX)0PA +M%5&`@,`X&ZM0,`7J5;&H_Q_@8KD+\@S^;V_P[I&!-C$T,0<\BL]4/QKXO_.Q].QDR/.-64221CN/E(JHK^\;B\9^?1M!`RTD57<+ +M]G+\!?FAY>)[NZ_@\DKRUJ<;:%31%VV`DT!:(*60`J,H)(!*5RJ%!KWD"FX$ +M7HS,-W,UA[>E$`TA!#5@\YG<';`"XF4(5%N6*H(**H"D^3F'>S[GE^A=/E'T +M_CT6(*?/2@60108`:].D6&AZ;$UB\>?>A0B7YOXD^[W.CO'IUZ-9^?VAL[&1 +M.$:)*#%01$!$]3GL'SC[4'@*+*UNPVN78VS[^8)57%=VH&M**!WMMD&/V_Q. +MS[$\XBHMP)O+?EL8P$E@`D%!F>QI082S>HZB@048&1!B%-ER_^L0/`>YDORI +M8I)E.ZCJ]_N#,1N`>8EVHOEYQ$%PUI]N"D9Q?(BV]UZNI1$>V?W[*GT513\; +MV/W9?-/WK>RJ^#P=_P(R[_M15M;6C4>>S4WB>*@_=49IFJ%^NRA`O9W77Z47 +M%&L6X[4MV+DK*(`J20H*D/+4DX_3!S?Q_[X><1->0$B>J*KIN(5AVQW;V6HS +M_.)7JV]KR'<=+ELGP'PQ0CR2MWKA64LF"48"4(()10J,(`4&E-LEAY=7Z'UN +M]->LUXV@M+W'ZEP])FM98[OQ+_R^)GHR8-R5+0*4NBBRC'5_?_,?9>A6[?Y_"O'85N/'`X[^?GNU +MW(WV4D--2$]7`JFD>6Y97+&9NS"J`\/PWB3W7F)YOPKGF*_051%8HB@B+KGA +M/F,4_4:V.Q&E`9FA:>+0`P@&0BR;?1`(C``,8$G`02N:W3UJWHBEGE3UC+4L +M*(16,%Z:`!HC\%!0_:X2H[JS>NR?=?K*J#0Z@!PU3U6RK_CX*#BO96,;J]#` +M@E_YWW*_M66 +M0!VY5*@WW5+O\#W$[WRV]/Y?FI^E^YUU0-1""4&7)3!2B'MY"CXV_^0]7R^1 +MJSMZE`7C\AL"T5!(#R!2\D2A&EI0@DD%)G[8#E?9Y6^>]T-M^^AWCV_9V&`Z +MRY?=MNX]RT[^Z`7.Y]#I-C873[,-#>SRG?S.;>^[GW^NXS5VT/=>Q[FC]_PU +MM_DPDH#S>)>8*OS/^KQ\H3]OL +M80P0H$6RU#4&C@X&C@M5^LJ#)\LR$5LZ+0`?6YH.Q7)OON55$\#I<+NN0N4B +MQX:_XVXS_E?#+XM'Q0&23-R,)]L%WO.F(JL`B.`K_K0`5'6-Q<3?L,[^%BCN?REN#OHP1':_11`-WADB?`O*%`X*`@.$$6\B"#NM>^LJ5 +M_QSNN+C7WZ^QNG)T"!VL4?@1"[L-0/7104520QX/9H`)N9`33\#U..\PQZKE +M\U]?LS75%2:LLB\_Y^OQY?BYH^OZ3E,9?C5`\[`$]+%^]%"`48EWXH*90(EX +MJL($%M=+94S/E(1XNR>O)+P\P^5QLJ-KXZ,*T)FRB8U(B$4%$T-(/"#)=X_4 +M8=$_"X:!1/@GX/RNMXEIE+;J/)QV$RGOS[Y+X24)0K`VY^C@P$F19)B#EB$1 +M"42(H`*E?OOV@OT)FO&\,',\[[G_.JP<0NI$`^H][4$WTAW`@?"G?5MZO1/C +M*`N\Q1#?Z&AO?'[E73[CP-Q=>C=L=_L<1L(W\K84QI_19O7\ZG*>^[@ +M84$Z_J@_J]ZG':>MYB,7L7(72J%VU*!`&^LAN,1^!RE+L]6+:F@`$.7093E> +M,4#&&/"-%E_^3@^*WN&2G\6\&"B +MZ=^M1P;CM!=J>2KT1F(\C(R_CZ"$1MXS8#@?'[1_%\R_^W;.`B.R];@V-J:] +M"4G]CY#>*MGAK?&=89`=%@)N!<+N?8\;A<%'HB$VB*`JJ2"4*`!"4(!!0G1E +M)0#!TEXG2>+CVVSI)_.HRTS^;"PO9.F[G`[AE\TW!\1U&ZO0H=5J,)ZW`/4>!S-0)C75L]^ZS=/W8JP0I'#3*-MV!`:82&8,=N1[^YW_[H?E6_A_I;X$ +M?`%\E%%4`A200I(&(^#>8?]K*#,Q"OP/XO%8Y:'$LN@[?4L8]T)QH`4(VP47 +MNE,8@*J(M4(GQ$[.ZI`450Z&%L,QQ27[W;[N5>V(0&$'CH@8XIF1%[#QW9V! +M!GS`4L8!+!8B(.1*(*_I=RNV/;Y!_?7VD(&.]BQO.FTG;:[WY(!Z;+8 +M#E.NU^!\N9UM3Z\D=V4R77XKMK#H/3[[']=/_G,8/\L9U']_#S&5Y'K;W]_4 +M1=SQ6]YG!:+3]=T?H7K]-+E=9_&(S^8E?%=[6W]C]>\PW=<_?[3#\!I_E[78 +MSO4^OT>>^S%4R23DE4X@KC.=4=FT*"(2H,A0BS*CABQ-$Y2;/7*.:^17=80J +M2EY'EVLY@W4HPE#S/CVS-3DLH^T;V%\O-_![^/\3>O"[#^_<[?\/T_;@?$PO +M)^+2V>LSOZ?3PN&ZGG.D\#`<3DMM\>XM0)R'F/N7/:)W<%+(N(*$&RO6)]OU +M5>O-?I\9]&X3OYVD$/W1?#0?90`]%Z^A<7)((MP0MT"A2QC*+4)%=`)091*`Y\[;/I],2 +M7FTBMHI0FTV4H#0/&HT&\#9R7ZSS&Q5_*_,_(IH^>^XVBOR4!\;>07ENTT;; +M.N5MBNTI)+7!+BRV+%HTI[`"7*+&\WOV1N8Q5OMV=$*G#\-QL4C. +M2\7`/GMHNBXX5U$?4771`I`COV"\_D_SV5;ONWJZWM%6J4==^P\&GIOJ@U4> +MWBN7\I\OXX#^L_G +M?*M*)MA^NBQN]MY#D?,]SKO#M17\AZVR9QGPO,Y?0(,>"#P"\-EFJ@1B[%B9 +M@@#HSH'[Y]#&@=8<+X_O>@T6\J7@D^96V9#@Q1K+TV:X;+L=IX]/8^SWG4:_ +MW+EUOE<9+F>BB!/N9;2/UM\#5^=S206]AI*UOZ&9XS9G(8W6V\`RVQZ$4^5U +MFM3\NW_/IZ0WF?(K_/G=NLZHE(']4B<7/:B!Z36;\&-CO`[X$$!"2,I-\(J( +MZE-[W4JP).C"DC+ISSB?Q7[>J#)LAN9"[145-GH/3V>[$=O,N_43V,F! +M:X!O1V/:F^8R'^.UA9=0@M@0!2GW@L0%"`$*8R0Q`(%;[!%Y[W-,`_O=JQB# +MTGU&[Q*+_=]%=NKC>FD2"J;>NP^^+8X(A7]F5##N0^$$#TML!=O7#?;:T^R& +MH`00%#Z\+\,SC<=Q&ZM^7-2Z)`3;'P99FL'X%)F]\76 +M>W(;+G3.T'B>"YJ>.@W:??4@$50B[(OQT!`W@:MF`?-0P,K[[) +MB+O\>41J(4%XP&GKGA,IP7`:%3VJ*QB0X2J08P@Q.>8.^48L/O/YTT&*8!#] +M5.1+;(P$+H(S+'ES]Q"@`E&&HGR(9)LGFB,X:_S3>ZR\RDHB84?OD +M81NL?C%6*D,H_?42;23.%5'55,52%(1]C)116QPU0(*7*DZXTU]9,)?BE$++ +M=)E.89,#T'';+&C/M67@DK&$L_@JGN;WR+R-R7)>OR&LB!E9IFKAO#EH:%M_ +M>6]\%KO=[H\8>#O*<&QL;^I9W5TR-)KVI7W";!MDY1TJA="2,Y@OL_%R[?\)GLG>=$H'Q!^'K)&2,-L_,F`9%X'Z?Z/B+D:Y +M`Q0YSX'T-[$L0TKJ +MOX7T'^BPG]GPMAY)K4$3N64*KL*2JB*M-?-77-R^$;C[WDW:B0/$&>%GK?M5 +M#.%95C):,"E\4#-L4JEHJ2".7-[-\,^O8PJ41*3CE5;&PR3&-L\?,N9!_B5T +MTQQK1J;"[-70$9"0C'ND=[FV((UML2:RA&&[7B[2%O('77]X=SE1IV!M\ER5 +MB8@8`I!(=&@M+9E61IB^+X:/LDHGG11$5@=#0P.=ZB3[3J-/V/NZ^LX_"O/9 +M)W/W-X&7-_;HIV,^\?R.\>*!,T`5?!GJ#L=)6%$.NGG3SEPL2&IS_WJ-\#CCDE"`*M&:+A`M`3EJNM>^ZO7=@I)YU[: +MYS>`%!%?>U6QHI`D<'!@9J8-+!MBQ,+8&8;$/\C*5.@]2S>=1R$*@44//9NH +MW;H>'EC=EE"UE%5ZJ\8A2"H(G.TN[IVA1"-7PT(%(A6O^!8H=Y4*/P9_FVL` +M/YMOG\[[SSJUN>7/D[!@-C[?O>DV2>`D]5ODX0+1=S(5=M;C&5UG;(GD)HL +M'+JDN&$6,J(Y3'1E3['9K.W(]'BZH<7!YDJP%\I*([\A7!U6*))4I'DU36(8DW^%ZBSV/2D^!N.HFM0_@=VM][5]W +MWUNZYPK?D6YS7Z4USIA-X0I`4DI!XFTV?;%>$A_M9Q"I[5#UPN0I-O@MO--XUNFX:QSK!"3QO&7>2O-(=[@2&>1BUSC*Q^2Q1J)M +MJ(LLH2\SEW9K"&)!%6`!`WM3J-MZK^@^%HV-]&PJQ*M;O;;'3C%K>_2ZV>#U +MK,-J9DR9U79W9(VXW71AI7<$BX'\ +M"Q3B^`RR0L1#6\\4MD0+L^'%182HW$0M((CT$V!@<(5U.09'/IM<1% +M'.L6A4%DY22QQ5F1NDQ/-T*Y&=][--<(D;!C)/;LJ'EL7V!AH1JBE<5^H,EY +M^O6L*!_8KR;(KQ?G7@['4;NP#)'T(5']'08_YY;9J9.%@%#?:+*#X>9INS>9#T_^L$%S&/9HNMJ6>.8[C/= +MOH9'B/J@*<[_Y:+4]3U.>=ZUR4?>4U6._3W_%=WY3"'D]QI]_[QW4XJN#.N[ +M96=U_-7I+5=^\N`9O@['6L;S<"G6?"R[F#6_0U0;&^E&020D&3I,*5YJ1F55 +M<37AK5?5-4/?9F#?3:[3J^9Y-T)B/%[-K6G9RD#=M/8XQ%.]>1(",M"J,W[1 +M<$G1,:8Y9YQ\=,ZJ'WWB8X8>D1A2&P):PYOG,H.N(.??5PD#_3]-_U==E.BP +M@(:4'&%@-8UG0RS2K6RE#'0S1X'A9Y99)[^J5<8SY=2E8*])CMN(Y9I48OB4 +MY3G4G]5J.NJH8XJR$JO.T>E@V?JVO/?J7<%_JU#K[,+<:&--0*>\A<6CK]?/ +M,Z4T2VOU/;\T]ID>K3>[NV(;>Z;G)#,NO`O&.UEU:=K@9IK5/Y)E0/,13Q6.OK[Y2<[`*@JQ8/[?5Y5'Z5=?^1@^A3 +M"?5I3Q,V)]^F&?8>BHMG>]%IC$WMW\"SK%UW*0\-I)XB>S3,V$.U=C6AR")F +M4#APNKX4Z03JBH1T-UC_.!FPR1]E&OU4.A,["'N,#J/?4881371![CRE<1/S +M1P=9CXH)/>U1?$L0;07XI)MJ"HR/"=7P&80X76\'PA6TMD<6GGF!,<5FGS]9 +M&D%G<4UK?9&^M;;!X9XS/4GE'Y5R8WLPGYX20>JEX,P3""E5U98@8$PJM +MCG@JK*4%@+-0-5(G)"T(VT-OQKU!!R81B,:%I#=IAK"J'6K#U\7*-F4G\\,4 +M=UC]#M*,4FWVN'A\H#^E&K#9E]>$M\,G_[JAP@IO^GC:*HYW&*S_XYIRDM(Z_=E$J3[DA]P7Z +M%69F&1M58%#&/CM]S5P<1_'77F4\XD`$W,B*-1(+@4B1(B`C=+6J9S9S+D2R!+WDX;E+ +M(9YM"-&/5/[(V,2#X+YAS;?-=?/1P#:=AF$G!&BL>V).&=N"J691=28T"`&U">"S)#,LYN8+R20Q8DNN&T-:<9MJ.G+>/+9FK4Z]JJZR5LT]/$ +M"0(#W50)-LQ+S1)JB1@B"`\2^*E73U2J7*RPQ-8>L*6L.<085H=.202`R0;] +MD,0R04GX?3\JUV-G-)U?N5)+P5XD^N6(*`02,:^P:06BB`_?,M +M@P^CBZ23\;_WJ\'CX&)_E#=)^/JJ4XB&*`\1.RCG1'A(B?;FI!V,0_=K"AXJ +M@S[&9!Z_\?<6&Z`?=C^&`=Q`W2*_LWJ@]_!^?'<$4SY[OH:;0?7^&I]O/03G +M9WTU<,?=T];=2>^JCS,.?@[Y,)[6='!.)CP;)DH.JB;"?NB?2Y+`LAB@$(%1 +MX8R4'B8>/N78SDK@]O!_/-.'(PJ)P.1.?K4VX&+MUU?+\)^CKHL`Q*]0#V/) +MR&!20Q[1\"JGS.Z6>`]KR:FKUJJ*%[:#.&C$Y3NIH2&-?N[HCW67I:/4Z],V +M(>:E0D4RO)0=&SS>$!-@MN*+Z\#Z?S<-.M>9QK,,14S(AA5:ZKA$93LX=Y,0 +MB0`FI%_?`B(J"+"8QB:_=R?`'X3^`8(D1!FLF-O2`)"$Q>Q'VA']PCNN/A8, +MN1+09113(YPB[%`&&ZUK&7B("\^MHG"^$/R2T,"E*5[KO^_/WM<^&I_]VJ5[ +M8R,T4D(@(OI'TD<*0,)3=/T+F1(5)1:8%"I`&B=O$*J5_%XYA51]!S6-U%&( +MM-.[3P``L(&]F4J,A9\.KF()YV[SNSQKD+%V:T:8H!9*_#&>]\D]-.YCRCB/ +MK+/-7Q692`&AH#-%(R0E)G%U(E*E,%D19`!.IL6+AT;`0Q!(ZJ)E6KV,"UCK +M[.NVWC^_TWK.DX7_/_]E\49'^_#U>"ZWG,7F;/$\]]WT_5VO6S,7LM8OX[#I +M=1II[^8S`C1`*N]`D@A=R/.FRNW(:]J=T?_?E?Y#1ON*BWSSG)]C52;>D`40 +ME!H"/X*&'I&?`?ZVVO[V>MTB[."!4)_XI@_ET&.?H"Z=/'50 +M.'@='`.OAUL^O$Z5XC@JJ\E0'`JKVS&BR-3,-T@^'_8+I?;2.Y,9^OJ6S39I=? +M7I<2&(DNNOU.:T`#+B($U-XSE-OEW:!\Z#K-71Q>[?1)%_GOV*7I4W/3$.O- +MDAWTLIS9\TE#`(#Z.0#WGNY>#KFHI%.L8MR(?*">/=SG+ON:5('O%+Z1[V`_ +M3B=QET'Y(^)B9)VD,GUZ3LH]1,CK35:T+7&TJMFZ[^J2F+?+=6OS7P;N?GN7 +M?K#!5IGBDB_T1DXW][)WX&HF?)4G*"J.E4+`6(QB14!>^T(@HQF`RAEX-?YJ +M_)2V$F*)Y?C1(D-H8:X!_FV^A<(2JHBQ3>;=,;$1CAH1?1XS"G#U;=2T,8]? +MPQEHP_[XM)C/!0?5>X@4Z/D2`YQJYD!=O4'BS#F0UJ5FM@[&^#1VV--IC*,+ +M8.,Y58WD1&QCP)"BDD"W,2Q5IMNM`[`98JZTKD5N4C`;QIDM(WDSXT5L6I"R +M*(_`[4&_'%Q!A-"7&$'%">IIPATG,A]\A;.'J*L$\RG +MJT#(0_&_D7<WF)7D-/:7G1&>U(]*J:YEE7A8L"P" +MZ$(`^ED(E1_P5&,/RGY#\F6DVK0IU'9K&"B6!0<*6%$MZM%08DI">"J?+KX.>:DY_?AMJ`?[;H?=I+8%H4)/_PP/T&'TJ?]J +M>&Z?TDX%G51U/.4^U[GQ=CR^@3PG&E;* +M.>Z[%%?'NS-#]=/T7P4M#@S\S8;683$Y* +M)W:O2N;$>EO2W2N&W47?HZ`A1;`60I8F3):"A<3)@>96\YNFYR2T=ZNK%O.X +MIZNKB[A;&K^^OM/AMO:Q[&+EMTW(VQM*1LDB>T-F8F_U^@@D60,7E/J\3=D#7B\?TR30KO55;= +M33>9CN24*)H`TD5@BM42RF[!N0VV1LTH?.?/_+Y+L.P-&S3>UD'6G-W.9SWU><1UWTLO)HRU^FOQOGD6^&ZILX7:(KPJF`KM3E0S/.(3A#K3YWKXP2,002#,VJW;=V#A +MF.(8/`Z">/=ANU=!L;/;?:&[5I!R)MLK5JC9(X4OEQ1K%&HV#A(-QPOJ\GB +MMC6\B/ZC[69\SARYYHT^^]SL?MV";1&1LV@X11K7:+;:&QI[*2+V]Z2AB"L0 +MV$T93*04*9%!?(,!0I;#Z?_#E/3;=D#%*2@?%_CS[&Z9M!R.>:TBP-E&0/A) +MMA-:<-(E6\F8K +MU$-"M0^CU";(# +ML8<80*A/X4*08>'8KZ(*3(P4%EHU>+70,-4C%?-MT[U3>5#>%$+6^H\EGG0$ +ME\H%*,+OB(Y4BOY*/SXG):D98[Z4X@N.LGA910-I\E._-R2BA*5Y?-(A.IV" +MIKL9]D/,.&(%Q?770**];`3@"05V:NKCN9:V644FL]^'%>7\'PJZGQ@,+5^U +M?V+HF>S80VPPI-AQ9T<)PXM!G45":QVIDP\_\Q1%&(#D,4@D=PJRI8H$V%J( +MHL27LTL+T=AV/R*A^*PXGY=/9)-FE>4S\9O[:M6'82<-8XNY'BX[&"!GCCLT +M'+GEFNG-K#U@G;?X[/;R/L=*]I'M_>;B\DZZ6VGQT_:9?F:GODWI/UTGE,GS +M;)IE-IJ[JTJ>U@W1NTQY&R=S`Y&/F8:$#8S//Q9S,X3*J*SNP43)BT@RMMGVG[GG_\ +M^7CP5;)L2;-]W2F\'# +M:QCUQM'M$MG55-75*]F\(VQE==8P:&/:0;)L1T:B9";Y:`RQH!<-0!8*F:5T +M54=&J-6Y7*(B:YN:\[AIIEWFLTTW656TD-LP49CPVA!C;8:<>11-H;C( +M3:D:J:81QV<71H,43UUZO+KWO5YX])-P1$0]^O+QZ]=Z:](P0E#WU[WL8O&/'N@SNL\B*!$8+%`60 +M4455BG?#KS3#X=<2EWJ%@QHDX0HV8XWLX,(J+7OKFOW-O7OU7B; +MNZ'C=RQ-(IP@?$:37I3`&N>X#X560.#8J7\_X1UG++2E$(DTHA.W5D$N^,RG +M@8H?J">37-[V:SL.'=_J[!K#,/Y^XIFN*ACN-4AZ@S)ZP3-K^+5_I?#O>G?,[QK[FF[\7R(N*,J8884"$X=[ +MQ.A+')]2AB_^D8AV,D#DB`4W*TW(Q*>>?S(M-J$#S;V8@_V$^!P1X] +M;"O[*SFVI/GCENR)IW\5W9SHR["^_"IBMF3#%M;9"SW=Q7&-/'JV?"3.6U'BW&PA=0B$.'!28DPH:,@;Q*VUNUV54JCS6+C +MRSD\7[;_%STPTS`W\W,2FD!&+R)4=P9"<,,/T/?(C42)[1PJ['&R-8O"=C=\V99.#8UA,S)G-D0K<"+XJ +M!AD=BAW:CXGFXMFQ#04>$'L1@@9(32+:(KRE(HA@QV5;!&!;9LF:NBSQYEGY +M[,&-I-N3;F(+:0@T\D,Z`X]4=W@.*6+\18]NGX\R*R'HO@XOOA\&H9A7#&87 +M:0]T=PU5%QR:EXY]&WA>C;)%^\##+A;*[(/T<-P4SH4;6U?:-AT0"<%RI@9# +M8PBPT.?*B`H9[6+1#NM,VHC`W(HHW!# +M>6`-F/C#SI`SU,0E^1UD3.SLBK'(-D[P_G/)STT=;VY^0)LFA\34F5(R +M(<*9_DKKF1A#ZVM1.FOPY?4H>&K>\G+.=^/=30UCLB]V"`?.S3/+MA$=CK=K +MO`8G+7*B5^:#T/_O67HFTZH&\.$AB$.DK8)X!!RG2="KRM)6=5CK%MGG==B) +M7TN[,S#R;W;GQ>1?X'O*)$Q+T/1R:_89/X:09,O5YN&J3/3>L5)BE2Z6"0;( +M?F'P9=1"#EKB&@N&>G^]#EE4.T0QQ9?1;+^VF*^A1R>OH\='&X^JT;LG4!FP +ME[]H3&`NMR)@,C.&MG=V)NF +MK-_CY>"GZ/)9"ZC7"-ST+6-"BHO4XG5CMWR!/TA(0Z-,V;#/O!Z/KY',2#^" +M\OQJ^`G)Z/AU1BB'!!G$):JN9E=G@3/PZF9X)UO9%%TE!/2>YJ'A>'V*K.[> +M"8B<>-P;^%+!51.L:X?"$QD_)W3N\O?U&G&9HR+`3CJ-9WS[:FYNO`L#1Z[4 +MNX[B%K.YX7$X9)29BRXYA'*K(.6<$((HF+`FT,T((@LLXU6P>;95H(&8-BK< +ME5TU@&_F?\[_B\6UUTS7&0,6&@PX!??P^VA'6[=0R$?4:@Y%),QXX]'!\6(C +M%'?(4[QX!8&X"\0;\XY(`N022!U9T*)--3>2@:>&LB6F\AMF+D+!:9Q:Y,+Q +M@V]8K1A8H3.!$R11LBB$;43!5CHJUO4UQT5]O\[7_@O;PM/GHZ+WW(J$QI+Z +M9]AVM"D0GVK5A791RN*0Z'I?EZJ#'QW&^:H%T$$G\#/C-G7T-YC&R^Q_2\A/ +M[0TFI4X.V'N.I>7P!](<3@6%L3HL;8\X8-M64(G^@`([D/_AT((D:"DV5R]< +M]IX(>:Q>.:X,XOT/?KU.&P<-CBKLRE2[V+M.:&!%@BQUJ&B!FD,*512*LIIP +M4/,F=66:^LW0\946!X^9Z3@;+NTYP46*PP(ZR#)FDY1`U84@"U50HTJ%H +M*`.&B90X3-!]3G9:(Q&9W5H;/?XX]LF_TVDN=.=S,K;MXN'$Z@R&@:;30I$V +M96P"I4(ZRH>78]L0XGIJE!U* +MKDT=(97MMGHA!V%=&];%OU,-FC-IV@6/1Z.7'AB4GEGV=M;0T14;2RZ4JUK',"-WF0*=V$-IJ" +M-5FG[-[-YMI$\6^&(1!BE*%,S!8W5#L3.0PI7+.\D0\7>27LGL6#0&ET\$RL3$NM'P)_`0W:N +M^^#,(4\+54FPWEXA\/=[M=U+MJ7<=EJC$-*$7PS@$OFE;M<0=PMSAB[0^/>L +M<=5TRS>LF^VKF_#+J!?#U=7(;KB<&]'1PE.5PVD\;EVAZ+L!N))?F<.G#J7SS<_#S+4 +MXXR.GC\7%8C7HV>V<2+W1?UE@].(NXOH%7-FU&YMD3)LD05Y#-W0=LL6%Z6\ +M5GAB0;G#UEEH&ZA-B,K.'CBH8[S40'310>,-MX>]32WAZXM0=UK.,7%RU&&: +M`]70RT>'4QS-$#C*SOE"^NL +MM-XOJ\TPGX\M<0E$A8G@7BG.8*=8XS&DP8@F\MQ$]1Q(Y<46OLT=">RS8QG2%-L0[S +MJJ&+JXUQAV:C4M&G'Z86`3=>;-QSA&$-E3J89AC?%BQ&(J&,1K;;R?3[DA)D +M3,KWM\V^JS&S]ATA:79#9(O-&S:ZI'TS1V^)H;;-=F30A/?UL+7:>7(4XR`G +M37R^7BQ>31!+'!,V/1>KB,M*5?OSR>E$D_-4;@6#]GM(':9<:';G]L/;V^($ +MEY#4T#"P%@N(;+P,CJLK(FKGX85/@^@IPNI#H9\^Y6D#`$(QB+B2!C+XZ:`2 +M@Y"@)XXZ*$3O[6RH00!L8IN9)&W%?+\,?X@C@<*V<@*^-D:H1;Y"@.+Z@5`M +M]1CXX'K_?7FD`>NPV5V?SJJ7`:3JM16(I'UVJUQU06ZAW?_CN[VB(#BB&A,_[-YYY!(*`N*J7P +M3)4QR=TB6,^NDZ\BU[TUYH:'6C[*1[-1IX(6=`WQ"&G*$!YFY,@[90XI?-6O +M*=B+P$2Q*`1N`$!32_'4\GBHR=`@:H120(B+`@C`.U#9@@G&WU$8R\OM"#%% +M%>?#'F*^U7E]S2W>+`QZ5D+MV.Y"^O!VCU*%T4_(8.X_?=;:R/>+]YS@_O%- +MT0Z-?LVU//%^^_WVF'1Q(YE9+[1A7=6Z!`+3P]NMQG/?%X_G([L7&M#KE7?S +MU,`UG;COI6Z:'KD;IR!G=8#VR-(E'(I6OS1LQ-=L5$6H][OQAT\#M.N'HVMK +M1SI";Z-Q<8?#`10SEMZYH9G)P>B?(83D@UTQ-]UJLYK*?`_HFR6UVOG.'S>< +M+HU_45W!$7%LX#6)V,75Q., +MW:[<@9W=5X\I>,1V;00%9R:21L*TNJ;`9RKW<]OY]G`(UU'?VO)MM6$FPHN- +M((X(`WPZI<6VVNC8 +M2;FTFS""LC)M,W:KM$/QZ-UV\D>H[5=^.Q#!LB204S +MV#AG> +MPX:W0DR.^;.>IN&MND!DAT$;LUK5FVTU@.;6-JO"TE6M.:%K239ATLU4NQ2- +MG2N>&NV81W8]2`XV"^T+1WZAR&C`YYWJXV16'8(PI+`4=L@+C2%9=J)&!P[N +M7W=S(WSC9W5+MOG,7D7KAM(*Y"`+HP.=3:#;B#?2M`69P1$B9<,7-+OQ +MALWN,'-=6YK'!8.23*)C-V)#&UAP09:+,.(%K8*:Z:"!AM[M5HNRKHV0UO)F +MK]GXN`YWRL&VP8()&Y*09@UDI?(=Z5E*(91&2YE4;>)-JI-][VR9Z5-DUV48 +M$QR,-KQXR5N'#+4&/'%XSPJ%,UU4/+@,[MPT'M/:(+!JQMP)P*+O1@J"QFS3 +M`M1'K+%[Q3/MGF,M8(@,&`7*T>^ +M'FL(`4@,U+:TJY.(0YDAN9P:9J)3K.+,`I(9[Z-=E!Q,)QJ\@ZC%W9RITZ&;;Z.5QHK6\",K-[SU +M@&$/'AHP@+9OC+@9S+7#0]X`(?+79&Q$B$QNAAD<-MJ,88-:PD$"70O*%[.A +M9S+(`Y\,+D`9Q)`NKUO=5;CCGCC.BAR4>&3E87&7J(%93@N;IM&81RD\4FE0 +M@(W`>Y2A-E,9Q>0T8+.X))9N6K(.I-T&C4D(HJZO9BB!B\43-Z$I!GU(4DQ% +M&,K`VNBP(WO1;/L+3D@4D+00C)LN6TX-B92!9)(,UM4$>CK0QP'!I(/SIF?! +M<,UAGBP]]<'%56&Y)>SD#TJTR@_<(@SM,]B2#$C%^SY5C,UA:7$V\M0V(MW-F,I!IEK06(P1WUEL@S<:E&(T#1V1Q=F&>8S5Z:F +MX6WH,*.7#[OI]M0$#,!-:"+DXIN#L@46-J,S=WJ-\II,$X(:LLCCA,896"#! +M7]`A)L=8!WRECJ<,:%T(`(86["`N1I?T%_1[D>>[O$6? +MTQY;SJ^;L0Y8CR6TA;0JK_J^46M"`7UO?9^ETHTX$V8.0`./+@E%6#MF!]/IN2$!*`Y?`&*D8 +M3Q1030:&K>0?`F_VLZ:PY'>Q'VY$(14.HUWR+(^LGK9M?IUK%"U&5L]FFA^; +M-HVL;R`5GZW]@B-^-6<-WBICW*-[+X&JR>3;Y:)8%1T)HBH$+!+!30/%\'HT +M@;4E)**HBS%AD9PX]<84F7Y)]\`;`S.];`(WD`0D98^DHN9L@W+S=8;T=UUG +M>ZOXY\F,AHMLI5-J,E=;O`040WE$**E]4!A1&/5JI]5LJ#USY/6>8P/D('MF +MH8;29>1(2D1;//V`12``I41$2B!S[YLETZ@34;F%DM:*$!B(P^HK!4RLB)E1 +M6&CU*&:8$R3=5&;/=U09;JEJO];Z#0M0<8[-D_I\`P)'Y*H@\<@#>R."//D7T[`H@_PB00!F^T9`U-_5G.M%T,_G +M[IL6V!""`$)Q!'/<&H\'6JGN2?N_QJ'V]'FGVXP+"Q1V!Q`R:G&6K$[0C^):U1"#R*7=HMH>XBVC<0'J +MH'U>GK'$,;@4&A`[.%3E85)I5X&W*60`V?S*/!@=%MJ_ZSDW;,+C/@=M#IO[ +M*/+Q3OHZD0Q0XV6@3H(9& +MU#>QT@E!I+?(88J1+H5=02('4L5L1NB)0R7DI2\A@9(INHK+CNP!13.;LKF3 +M"9)(I(L1@!FA(31D-4DI(3`9ZD4BAC?O83,@&K`#16-%!;=R@4%J,*5JJ@+J +MG099F[=KA/^>N)XHFP";\Z4RGP#*%;*=W7Y@_J?[WK%SK">I--ZH?Y,'2?`0 +MP!*]+09\5>COK&0U[#1TK6&Z$(ML6I%&(92'J+`79^:S7>7L>%?M'8Z89,PY +M"2(VWN&>>!NVSNNB:H#$II$(?@949H"A]OST=6SY:SB%,+2;L6;`V"!RYZ`I +M)*`7DB]F\D)@';VSA2B/CN\%"V&#>L;.G@$ID#.2H4-2RRE*-?,R:UGR\\;221`H +M6`$LJ$#Y1_Y;G.3>.;G3:HAT"=R6?1A7@TH6F^?A!"GZHW[*?@AM8\ +MARVQ#/]K0!GQ/J'W>YOS-V<#)%,H-'M;ZATEVZZF*\0PB*R#(Z9X@<(26WAY +M;G]EPFN#)XG1!7-,D!,^"!T$=I&S(OL3FJDK:^JV+&VO+SM5;YVU)<15D+-T +MD:>#XJJB*["(EHBAR8P1M!;0=W^Q_`()"X\6?XQT^4/@,)R.]\9<:$XB^%4Y +M(E6]GM&=;=/>>^_&Z3AZ?7B).(2!Q'<.!A-C.DOHWCX(4XUO=MACT^OQ.]3< +M0V^(Q,9&$A)#=M@0YG/M@J,NN7[?^I^+3B(W]CBB`C +MQ,,'^QRI&WW8@:M<'GV&5'CY8W)PEC=6,U?`9ER7&L";<)`GH]OK$EK9*"U7 +M&2/9A+!OZO1B0=C&<*L^VTP=U,E(4E+%*::$6A#.I#FD(K"O0T<.;:IH(9S* +M=@=F4*5!,(I5?^%*JL-O2U#$?BR5B@:/%5*I!HF-'1@5S:[6:V*QE]3J]TL1 +M!0H#`91FJL!2"R*M&QK%HVQ:-%L15%J"J+:HVMC46T6L:B-J +M-K4;;&*VBHU)L:350:B@UBC5):BM&QM%HM$:T5K%1;)M%45:BHVP;%HHU8VH +MT6E&"2!HAB@1HT9($@*620S,A(A"8A1((DL"*$%""Q02>^Z.^9>E\#WS4NZZ]+ITB)6.RUEI+(W;*W-84 +ML&X/!DK(-MJ(31IH;&SZS3]/UY.G_##ZU_:)';^>]U-+9*57M3)_*QW>D] +MUY6L-S)`4%A]=4TXNF0"B-E*"R@:0$2+2I,CC4R1?-OUF#/1`:,U!092.DJN +M8[$`+D#CRP[`$[Z!SM-5/%8-XVVER!C8@*PJG*3W2QWEI950-F@#=E0CBVD! +M)&N#(D4_2;TY:T6)DKY:BU$DA89MUG9B`#9Z@G4>%R[CD.+C.?FGP_\%Z=`[ +M**'Q73=)E\&OML0ADL8BY./OG(W?@Z&4B[YV"4)ZMGK63B,"]2 +M4^9922"_9A]\%\TAX`@C3^_UFG.5#(JJ1;%'NU.BQ9H-Y+*YFJJ[KL^7GEWH +M/3(?A;#7BR\<-?S@"X#"&Q@5>=:(BJ56E5USPC^*"+6,85(&@U>EO[3O#S$R +MAX10O14^UNZCHY21S*V<%%Y%1HB@0%H1ZV/X([#Y\#/:NFB6YGYQT%I!\7P( +M!?YTRQV/!;?,1#\3=+TU)<>.OK^Z7<_HL^XS"!]*WZM]_K@AR +MH068/]'/06/.D]^V!&,Z2=;*\'W.4#TZ>92'@Y-!7JTXG5P"R=]H_7=>GT]' +MC21#P4M*BP.TDV];^M12(K%!%!-E:`1$2)5U^]C42[1K-Q27'9-$4N@P1-#P +M0!Q`XIR#8O7D/.&RWV)/+B^"-%%D8YD$FPGRW[ONA_-3L4=5JAJCR,Z',R.S +M+KU#*#P!^Q\7D/]J'DO7IH/X1#B!X!%.4)%O7$WTAMDL['P4V*T$K4O,#[6A +MD!:JPT%^G^PEL+Y2=G1L!19-=[+5V7Q/%9; +M,U+RP5G/'W\5S-=S<*1S/$#NE6PW8K/;JM+'4BCS6`6XAVN28)\1)Q73OI +M+%<'(<;([=3/$/PA@="7B!D[-JGAKH<89]9BCM1FFLU%"[KB>1+\5;G<:TP?&YO7I_:?&1^$V'H/J`1`'UH5PUD +MZ)S'-G#YZ>LS\#\6C7O4:&X/RKAA,0ZAE3H0T_'K\1^[Q1P%0]F]9^?2@^31 +M\E)HGQ'@<3/%8!9VDH%0_6HYBQ7S]EOK2J[E=RH7X%&(<&&OZ;1,2)VT#>YC +M#YG((;+KT0'\EQ?KJR=E!Z?^-1O^_K4THJ/P'B,%`O70_QI/M4F/FZ,V=2?M +M)D*<25IZ.IR/L,@J(/:^B^TLPI\&J2?BLJ"?TDXNL8_6^Q_@U?:-+P8?J=Y> +M$*_/./HQC6L(]H?(8%HVB<)5+]^5"Z)[R=_`_VFE/^H=;Y?AO,7(:I,OK/@< +M_.S)S_7;AI/5">IY]"X>E_K_J;#`9C%*YVS?5??529'II\I.+Z7*B_?>TQ9H +M@O<92I_03SMTPU*GD\^$=:I%#*%0UQ)#\Y#+B89A=H?PF:,Q3/7,IBEPS+M0 +M2_T'_J8>EZU![KW%!J'C)E9^BPYIQM&$,H&_"L*17_/]]WY[9D$8JB,1L:"3 +M&VBQC8T;:I+$;!HBQ1L&L;04:V+%),,1$%1M)HHVC%HVDK0;16T:IFPE5&BP +M:C19-1):*U^IMR0WT+EC4:DM@U3\QUY>`Z,O9*`4$B8?&RR>()Y>Z_>2'A +M-$[0*HH*"A($\)R#47:3WMI#5+.$$4;6+M[U&R?>!F@9G#;GO9<:HH84/+/A9DW:1\_X +MO/IMGO9R4>2AK1T&LS:N1R3UY/O8&5O^GG_CGPKHLBION4Q/N&A0?Q_-T0OW- +M2'Y26@?H_5[?EG#1W5V/\2U7_^1;]#1DF:&+JC<_!9HF$S8LH0,WZ>Z/I$CR"?X?U.9B(09O0I1J<(5+'^K +M:*_NF8ZMHH^;_[[!ZD9I351^__#V/>^LT<,@P^2T1)L;=XOCGUS#&E^=:(>[ +M)^7.%BB9_%J_@7_(L]Z(_D/IPFB>2$*23ZC69?CZNB8,8V0<:82$C3<&-DD; +M3D"#'8IVB,^\F/654;#1H3"4HOIV],C_W:RTB-:>KR]=/6O"]*J4:R>O@PE9 +MSYCKL`UR2&/;-S4W=O,9Z[$PBF(&W]!#F[PB=C+"LIWN-_5:M`)+22*,A),U +M#E$8?)O0KKHJR*`Y^4)=GR@[ +M0])$)"Z`:$?RRV',VV!EZ.0H-$7%1%#/=!T0!&L2<9KU@?$$-2JBL>Z`CI2- +MZ*3"@TO;JE^.V*=AR.],'MF;I^P8,>97M\?PC1Z=;VM,-Z:QMV`5`(%MP?=L +MUO^O63!;VJ1=0E9:BVOC+L9+;_=WZ*IV&_:E@N]7-(O)$(CT>` +M8P`SEF%6OG[Q=Y857F7_5GX./J;`J0]&0])";3"XE0*2R?QQ5=J2Q,!DEL@C +M;-$\23+(RT81L>B21O;JAC,8QC>R:CJ1D(*HU;5&K"5IIH@T--S8X%*#P;1I +MUH;0J>%MADW0+B]U\#`@%>;^&G"5#@KK1;9I>NCX2M9D2++.U:4&C +M0&"[*$ZC^864EE)IM=/`82`+&,T&L:I[6>(QY]H@4DAD\`&]QL:20JN]#.V& +M-N4H0D3*Y%$SMZ"#2-).9["-E;\\ZB]GQL6<"-&+5>UNW(`UI8C#]PY@VT-39O>;@8Z04'Z.4-*` +MO[S+6%;2[Y?F,>U+Q0`D=68BPU,T`*"%8I1MH?8V0,8JV&/3KNIC%6%6*,E2 +ML4U1E53)%D51`1800A\FHF7=T,I[.$.?F.^9F)BF>&P3Q]UG0^>ZO1V=O@FO1(]>)2"B,7FJCVI)D&DX!@8K1GTT?S=?"#,'2I;= +M:7@E9FCK.O49EZGL??W7:K;NMBQ62`EC8+:6QN@):!MIQO(:7CMKQK\9^0?2 +MA&'BO:\7-S'BYL4/+KXWX%UZO;E7.=W.X=EV9S?V8\1O5AX`DTQ_Z)/]*!S= +ML^GJ^3DB+;""8R/LZ\/ZP(H?);D#U)&T=\4VA>.'![+J`>6Y$R3CA1\>J01B +MD1YR#&Y$[QN^MB\7OQ(:,C&%M"2FT,1'F,9BTJ\SCI/*5IEB +M@WIZ"@V3AG#E*AFG:GZ_];OX#-AW;WJ%\6M3GC_?0Y>S +MTZ7.0MJRL726L60V,"1*B%YNE%T$BXD*2#E=O2?V1.C@.<:9GF6[6:NP6(;HB4J#!C"1L8STU$LE5_V>Y!H-,C`PD2UY-.W-01@V$ +MJ6NL-Y>^V-K&L;:C%X\=R[OSW>+EUX:A%!1D1E"$ECE8&5%LC(E&20;8FB)@ +MW;$HTHQ1@162P>6V1$:C4'C;K+F3,=9!D@H-(@;^^SK]@]JP\,-W!-L&.P#9 +M*UB#^+13Y_<3,S^RS+!.[(C\7;U>_/?#]IAP'V,G\3[S,XG$2^N5#X=S@EO$C&&FC>2%C.\$),&*2-)^>!!(C2\XC"9945P:34D<>2&$ +MDH`\KT_)J3#'*`L!GHZD-$P,I8D)@/$JT1M0('W^[K@I+)"$XZ\6L\[C.-@H +M/N&[#76PWRZX5UMRFD@2^-]$<-V<+>#QPO;[%]5UAK()RE)(:><1Z-&0Q +MY*\'EGLZ3D2[Y&6T]'#MBAI!ZAJ-RT2@&.KAZ+ZSG#/BZ#F[A0TO!O,RG3&A +M+0@8@/9G9++U3&86DN;'"9CW'A#-L>I";S*YI:N%F#*XP&@%KXH,Z-8P`QN% +M37!I*I(=$N$KU!8G]I350B]"'D680Q8IB[/=,U2)IF:9YY8+SATG'=9VZ+NWR\YRU< +MIB,A7E-X\2EQ\.WG->E>+U6(YN+N6L+@"R*C$48JB(8Q=XF4D"25>_.-7G77 +MIO/;;C$9$,"$H5,55UHW2&;(XJ841"%[[F7I>><)H90\[L#>E>,-47L:+24H +ME51HA2J*(F?K>M>3#=]EW/8YZ>J88:4D9EQV?L:?;30]G*=$3Q:1 +M#%'*2`R,(5)'NX\EAL;"FVL4%Y?28%54>`TB:<,MU&V9_S_B3WMXGP<0F^\[ +MPK4!'8B%I(9VCA9!NCFL*A`0;"Z/LE%.S`-,=8J9 +M0790T-4-!H'A,&H2IGP8LJJAC;#>]"S$S`H$TA>F4"4,?YK+Z6=^NI0TB@3< +MY@D22)PG>DX]!:/@MV`:4!!6"(` +ML%,AJM%.V_LW6Z?#K+MTIEQM'YK+GXO361@F:K]]_2L/SLO8'/[_EZ+`:Z+* +MJ-%6:D-R.OS_+C#RH4/&K/CL\7Z+%R?D[N'9.P'%5,Y&8];0^ZR\5OHG)S9; +M#A-2<6<,Q/]$0]?01IC336-$&C+GO:_0[0VZB4VA)ID6%&([V9FRC]VN+,Z-V:WDA3*5&N2R\YB+88_1)AS<80? +M5P?<^&\,P8^%ER$(XS#)6$$DH+[_8Y=\,-);M[DD'$V.T&K&#(-Q6$L;'7;' +M$TW+*F!&1U\)1NC3')"8.J16H;&26MM\IR-S@,7FY;\4)HWANQC:*.%6R6GA +M=$"<8<3+5E,G_ET/Q?X1"^,6;CQP`(<;:P]"`_Y?$,;">QQUN2MD-`Q=]VY@ +M##/E==JO^14/>/Y^[K&XW*2RB2CK>!VI! +MUB_@$9SJF^;J(Q#OU6$C;/C4$6DS+L\8VT"V.>6B)0`C8B*"4--3*=]RA+B$ +MA?$$F!&,5GM\44@([R2KRJ=W(S[V\\+QP=VZY=NG9S=0B9(XX;+YQ?S +M/F_$#[+N]SGR[7U#@S)9#B-5F:A(S6,N&[$M\C +MU(;N;Q*#$-DS(L9Z/]AEU#;@Z;1\=HL/"QE\A-,Y)B"?:8Z#E#U?/^O96W70 +M^MX;N;!QW58ILALHK)J*)=8/PVW=#%&#ZU;L:L\?1+57Q*(>8E,H$NY`W?2G6]]>LSR +M-G)(ZXXR?%BA2( +MPMD*%2A:J=(!R5)).GSWR-OP6#L9]O9=WV%/XQU"YHUL-BCW^V\`S,1",`^S +M?W/K7-JKA:T;U>I1H9ZE;=N#)!HC"31_M,X><9[,*O.P^8]?Q^'7U3CKSH*` +M:@70"6QFI'&.$%D&Z?V4#UZ(DR!E)RA2J:+5"+:I0)=P,8Q`4!48JXUC;^#* +M9A&AUP8TVBLE%D"%:)(QDD*\96\LBQ-J"&X3&LN,:OU&$5D-,5'2314-UH6,:5-A&! +M6@"L05H58C36-*LQB(Q-HS(LR1AIY@E&800VHX]LM0,:6,9K>:33V78#E0FXH.R^Y1\:!]_HJ3^$ +M/">1KT.K,P+]=Y'-RD,^:IV.Z>P#KU!DA$#(9E-&U/G8N(KIQ/#%5=659S4H +MNQ1CC@<1^7SF+,CKMEE<]]N222\M04I="X;%'^/KJZ2/Q/3UJS1T4U4J;S:K +M03;R25B$U+0HW(QA?C:T80A]NQ"]$5Q:WO6VYHOK_#73R3+!Q-X+4J5.(KH:%D%D)AAN$)EW^V"^2`?@,,U1Q!C4A+48F*R"6U +M9$R"&N^_WE&A.2OKS9ZX@7%%=ZQZHCULHBTZI]!A)/![NN5R'K,2HE@*$',^ +M.H''D,[U^+4Y"_7B82B0FZU@%0#:3JHEB<3?M$.-K[.^5-KI&>P^3U>"9F0O +MS2%3/NW=42E0/G?H:GIOV<[_<8?X3]'NM2M.LS0:U0G"CC;J"H=E0EHD@6)5 +M-X49V!A^!4J8_`LN/F&=YLU>O@#R@H\!G!F%7G79<*,:N:NM$8 +MB)&`@L!@BB^NS#!,%!9?IW``C()(G$A02JB\[`0*B8&/$%AXN)N6UV]NUR-& +M]MMRO3Q;>[WWM[5SS<\.]+TDEYW>VWBC:Y7C4$4'+QFK%-9(9L#,9((X,$@> +MPQ_3^YSE&;L!#>UB`/UL`#YG0Y&P+KX6H@TVICVS'7^9ITS1":P;RNGA3(6C(VG!D +M(R+R_G]:Q)/871[YTKT'PV3)8.-+OYX^Y:8N&HT22"@N+E4YC-QX=FHJENQ2CK./`T7-S:LWIHL>M9<*YP<5-K& +MV-YD;`--(C`@P>,=NGC,>;&.YF"Y4P&4R%@-+&CDVQ"TP8T-Z)I&M:6<7JFM +M['OM;IMZ7XX`WLQM:+!L3;;7J:AXC +M-G69(VI+*5R.(ML@16LCC%8R*O9E9D)(8XAIA7&E"-A`;542%S>(0NK5*VQ\ +M9'O@C<;#)N:(QK!I0#&8X-IE2=A&VQI&I-#;3D"-IC(3+:22-%I)(@KKB8QA +M*0O1!A18;&T1-DA1<+H*T,:>3T$Q8T\!4A-X)L2Q)*\]1/7KI!R+!.L(TZX4:C`]GCYK-M"#?&]TPJFR'!24#4>*5!4RWU817/B"LR\D9 +M.2J58>T5D$PY;O5EQH/W!(R6=@X6'/^-JUH^G^D_0?!M@#"$Q#3\Q-T(R[P/ +M<:W##Q?<>NZRZK]H0$P*5 +M`P5N@AY&KG,38UBA.++H3Y%!4609!,D?03RN\T>$CIQ>:B-HK]7PE!?`]%#S +M$?B_"K_[#\<0Q0#OX.S@AW$-*/`S"'_$3GX\A`_%K*WJ'=SCOD4G:Q3G(?D_ +MA0\#/ZHG)^!2=CMJ1DC]Q3Q"@TI\HVQNAUN7K&(/>*2J:A!/(R)'&>&H3/%* +MZJ5#Z$_A'IHGK)Q/;TH;?![.!Q4] +M+Q/D+?/F3T=`^;C^*'[H!N9Y2;.=O$R3C9=!,[*IJ"D(>'4/2Q'?YP@#.=?( +M+SB',*ISU!P0<\78\N$-$E/.91QS`V=7:5CQK49!R2Y<6%#(`9T`M$Q:E)D576X@-,$A-8:\538 +MP_3^ZRZ,!E$J=,44F+A](EL%Z&0U$:[F_VLZF7PG0/1Q2HUX$]/52V)[E@T. +M(^[U%C>4@H-JJ*C"Z6G13N<@J#!10[P];P-YY">@9#Z +M-A[5/UWRV>?^_H-F_EY0USH@[RIZ"!)[N.J`77.N*HJ0(1"36*M@VP)EE=J^ +MNJ+5&@19"%A<&0$8*:7(&&9,WI%%)LJD4923,T%`%(LA#0RHH,3>P^O80,C_ +MR[%[E<,-SYR),*DPBG&E!_K2[:BV_%MKVKQ3X]M5RI^:=HJVM"B(>2@YD;9= +M%?QI.-B:)+J5H*`W$'Q71TO,SU,-VG%:/#\I=OL_)$S7"./GZ'/(A?#953A) +M"A\-J,TNR77ZM6?Y6?$89(8-D@P.A.^R*+!2"D62/8J$/1N$6';0U2'#PZIE +M,BP/#VA.1(*22\&:9;\9$Q523-(`QH-V_Y>B4SE,D(D%"(K!.N(':0^F>3&CZ +M]G[Q>U*V.D%E\^N54UZJ_PWTJ^N[/@Y0^_J&$=)\N95Y>^%&FS4,Q+#N' +MQ;#@.MFK9,($Y>GAOP+EZ\4^=QU'@PJ=[#G3-L;WS/V$,:,:#$%UM@E"!WGV +M*9LS0F6V[A<46144F>1@LR#AA&:R*9`K?&E`,8!/ +M4<3&`^A#L*P@5DDXSU7,W=YY#QJIUIE8KVJS7H7(@SUF&UQED7"A+A98G=YC:LC,!"A"0>_ +MHT;)^^204\.X;1RS$>&.;=64,FM6[AX#NXSN8P/%5.3#S3)3,;J79/$YJS9_ +MB?\:?E/@9UTIR,*IY!2Z0:&D%,795%3UR8DMS4K+H1+UGJ9'JKGQ*, +M.;"VC.I.PX3=$I4KCUV[M@&D-IGUC/LRAAO$:DT(1.RANAJ0WS?)%4VXB&@` +M<#`NUKH?"6$YJK/\[9L+-%M,-`C/[*G<20?RX5%X%:76<=0T9."%(IJR&5$J<*H!9! +M0I@$I,LQ+O;14BA3"GB=_X\]R'],:OMB1%N]G23C0+,/0,%XBB+\#K#,, +MDBR!B9\1)NY<=.XJH)S]E\W[BISL1<44/,W-PE*6;'L!R.R`N;#X!B%YH'L* +M'L;>'7-K/$:N?+U5KQZMC'/59CTPQFF=K4:?&&F'H&;L6[4?2]QP)#/!^!RL +M1MB[]A=BH8]W9F5XP+>4]I(UQ3"UB8UGD-DR+<`V$V@NBI]]7,%R"-'E)W#M +M+)W--3XC>F*+%U]_4;/P._(=BQ1_)K(,F=&1Y-U3DLR0H;>"B]Q>J1%` +MXF!:O\83'&APB(2#ENLZYQ&PFU=UVNE<;\/?/\VKWA0&"$.\AZZ.)#&JP"]" +MQ643=QU\'.L(EW+^UI-_A]B#UWR9Q=D]Q]?H>$ND7.APT+0#5SA$EH+]S^%7 +M>^%4#))RLG\M"QU?Y+]Y1N?**QDFT+Q1J_45HVYXY:N7T*\;E-RH\AWS.U&VC(@;X7)*"PDPE+MHI58,-64EI*( +MH)@:D1AK-D\?TI*%.4)A(3\5)%G!$;:-=MFKD1A-%JIL71*0WSGVZ;^L4'4_ +M&:TA7_T?S.7_-8?!VTJNKDEJQ8TZD@4A#$P/HDXD.3L43,$3BH +M>3]/3A!^7.!Q%).:SO][G6(3'A4@[*#4V?_-'0%V[K.*",8799W_7)*#RYTA +M;9HLICFA54%(RB*41Y",X>/KB<_V>86Q&+$/. +ML7Q&1L9Y\&Y/WGMXCJ;,)(M**"HR0]XZIR)_3>SZ0=V3LH:/%PFNNW*X,HX6-E9V(0JTDNK=O7\">U>J@UK,/MM(@.DAAM85_H +MNU\BC:S^&GK_G.F0YIJAM[6EA;.QSDP6'R)JR:3;?>@23_;GR0Y`OZK]^[>P +MM$9V-5L?NNAKEV*!*:UJXQ=H:WU-@?;^%TG'K:Y/J37SM;`C;(*P$`A_*OQL +M33C[:OW_>KS*X,DD<$60SH1+:44*1-OSW'Q&*_M/O>=1R.XWJ)E+)1%G/ +M;BO$9S$0AX'$[P.J0CFX%?+26CUI&Q_)_HU;5@?>*&V9E;\\VX-ARN+<\V&! +MD0T4`/5^]G8?[<^^G:N,(-)D-X>O%S`1Y!+1,[5?=JSLJ]=?T +M7V?O&SW0/?_K->KZD/2>1^/TFU]&IAZ+U"]P]H]Q*=2U=#>F2^CK +MR5XHY>.&/!N,?E^W96I7!N$B/1IPJD#!U)A7&.D$1UI%ML@JRF6EH+)55'PX +M63`I6`O.KKZ)[>X$\AZ;*\9B>5R>J/J7!$EP-P&@46@JAU.6YQAJ$B%>CJ3^'EF(T25*"^C,^UOJP%=A[ +M$,W)&%5*+/7#$^ERNZH_B?@XL6?9)ERS%-BBJ#%!7W_#8$:"2"1M%F!.E-D%L:UDIS/9^6AD^%2-66IJIL&D[9+ +M0:MY+V6OZ9AULW[CMS%67[;.L64F,J+8\5!XI]UBU`PF:?[.[YOT76LZW6.* +MG7XSOW5U,OCZQL)CE&9)HD%-DY&0KRV[.(%8HB7VD,TU0?:-.RL72Q.2C"=3 +MD(B10^1GM)PFL&,-4`T2#T5%-3G363)XB'XS<1+1P4=:14-!2\IDW[(4?7I,NS5 +MU#[U[?ET;&HO\GP\[]ED4AZ80I:0J;AY;C>9+70:'6BI,,9&&9"-L]$@/TZH +M5C8Y(FFA[.4@R,BV5@W4*P",N2M5B),2HTX-8S+$_DP"LJ8$<>(9&F$FE88U +M'E4I71UIE:K"S"0J;;ATKDT7.\73+X7=YUZO(ZF[H5EL1"1Z<+(1N$8XXD(D +M@S'!MY*US9R[;;VUK7%\MKZ\^L'7#O<-=^>E-;`O6)^0]+1A&H%B)E;"(CEP +MJ0?)GA`%T20P,B]Z)YPYN;4VFB> +M5ZIK0V3CJMVNY\0X?(88M-CX)E:577PL69:07P1)+0-0&"R*(BBQP=G\+`8,2.L^2[/!"%[LK@*`4PZ\.;?U?=5QV0PA5`51 +MYC"I!D:SZ2EM"F/`UH6!AM/+KEZT7CKKNVI6U=7;[_[%G!A<$"AB"`I)!9*R +MXM+9DT1JM>G'G!M\>Z>=:NNC(#X&@'Z-C9F*LC4RNK5B;!C;EO% +MF+$PDH48)/ESZ*@R\FJ&,8*(B"@Q[U1:8@+#.BF=Z_,7A;:2IOW5/49:G?C1 +MF9&C8P?1L+12V49(-0H1/&:7##%PJZ"F#-S4Q1@+7S(%U%%BBB*V;DLSQ]!I +M@;I9E35+,DI&6E,YUW6GVO?7OO7I.;L7D]+ +MRI/.G=B**Q!MW6YS7.5S72NW;O'GCNG`H713+8,FZM.SCS;;O&LKTQ%W8L(L +MBP4%4#'#=CD!TS*%PK555I2JJ,*&)B;NNN^TZ_`;SO6G#==W2)2-4L46&3"D +M;AMVW1B5%Y*I1->.;X1*-1C,BC;5LK&K%_5'OON?['[;R\^'208'H'<,9$`T +MLJ*5FF4I&"? +MY*HT54D,1]"_'733E3=75S#B^/LQ+7:=0&-.H=!)I(N7F##B'0M)=2TM*33W +MVPJ$%=OB[5S+MA'^1=@Y4:Q&)NSFNJD,>^)$#K,N01S.J@X>7?.,3%[W$)`D +MOK#5,6K@9P@:'OD!A+2SCJ8_+W#SF[Z!)<0-MEW8AR5%CHW:2T%$/*LW-)WI +MCE7=7F=1#N6;P4:BF"HQ%V:A.W0;PD;&]8G4J0@5=)J +M-L\*(Q%X;59N;K=WAN,MRNN6J7-QX9H,GF$/%/`-W6UW[*&*1T6T=%H*HH%( +M!=C5R`7OU_79HQ^\L`/]9_2)'C?H]_^G>[T0W@WCP,S,=7X;3#A8<*3Y$782W%XK0X;E;;S05]R +M.E@NM`);7TH9+!HSO^5H'S>/>N`FXVM4F+IZ#H;AV,RC)KGHD@/>-PQ`XLUV5BL.]Q#>N09J&H;=S2YT6?0(PTPY-;(;MN]4,V7=%,V;DFY(<3#TE9R8_6ZIK&/*)NT +ME'H<-8FPKB?;%H$:RZA)+K'D,&/133U",U +M+1UT'#0./#:;L05/6T*4NUMF#;RZNG]-M+JQ4B!JS;A>PADSP6NJ +MNB-Y9IK5MVR9$L#Y*9>'7UHR=9[R'S:?IZ5#XZ'190'[]@:I[).1#G='.J-! +MTW\)?C"5(`>L/3>7Z7+"'F-M[<'Q^/_.BP7NV:6)O)A"#HR+5@(O)+S$*L4O +MWV;V#>:8G$3W8XMJM.C48TMFMG&D1@H+(1AZ!XRL;1GKTHB#A8MG6B:MV"0^ +M`'OS&1I'$XHT.@%:&T(;26R3&O3O]"V)MSFY'2J(;1`62TI(*%)%E,1,-*DB +MQJC(FHS_-^W5_/Y'";3TQ1`]W=$DW$TUPGC._F.)F1*LQ\5^S<@#H'C.,0D[ +M9?X0R +M1(0?:QB'_G]8AH:4'*JI%B=,P*#T"KJ?.4,))J5?T?Z>1T%Z>3D]TQOZ[9ZO +M?.H^6WH-Q?L"YA6+5CY2'9;T5[`G'F+;DCPMQ+4[B+X,3+NI,('MH;GCK[V0 +M=_OM99'/-S1:K@++)]2J?\CTA^;/5=EMSC_Z6;]2+#B:$!$(_,59<2JJ1&JD +M0ZXT2-UJ:RQELA]#K,/5C:-:6K,I,',-:)K,QQ.A@9HS$:CABP>:0:=)II"+-9$.1*#B$BH>+ +M,ZEY+P$[V-15JBGL:4&I",M=U8HU90'B#3V+"4R;OD"(#S3GKG-Z9GN$A06R +M+X54?:LI\=-]^-C=NE, +MXN["I!PZSB5#&/%E:JE#TC;A_@VS'0F"_8F)3#A)2+9PCM6K'?M3X(KM+/1G +MBJD6G,\L"]W",KKD?I*W.+0"1&N<9;]=.W7)1ZUILH+)Z(9M0SN6[4T9E27P +M"0NS"CC4M,)CJ_'?/:;&PO)+;_K<_Q.8YY\-ENXV$1@V$,="G>DFPP$QTULU +M99QBKVDT.&I$88>F;7ZU5G(E0RL#Q96#P_#8>G#@LB86G7F),N9 +M+FS&^.JQAU[0-L7[(XS49,L;5:@SI"!PS3>U(,@K%3N5!].[[Z0[$,:LK+%W +MVEHOMZ:*FO)2.Q75T3*Z,L%24(IU]*S0S1R[&S!F.$DZ-1U:?&PYN#U$V.0& +M-LQUKOCER[:3;6CB;6YOR9FKHD"8X;<`<0Y#0ER^B&$#RLY9#=QPN"P!(!!A0$,8VP\79A-,7#EEA(=I5A@$(DT+,AC0T +MU4NK2Z$04T+NP5KFW8AI/3,02<\,C1)U%M,+P47N@UB2?!YI-DY@)F6,B\Z97O3!P995C#!Y*3!&6#O26"]S+"X\ +M90[$@@3I3DOH"'"AX&\>.KVOXJ^&RK/PALN0!R82\.P1P@UF +M4PK07:8D0YRP#AX;.7IY;3L#20=ECAZ`Z@/AQDV#BST4<*'IWN."H#+.+*"@ +M-E/B'97&"I,T7P=*X-AV!HGF*D=5)(Z!I*+W=/`B/2*+^3/=VT9NX:3EH+99#;9A[HF2P+ +M,ECV41"T,1@B@](3DB#:"?*KI08(]=,&PR8<+C<1!CC2'#KMNY#WNB? +M7_?2V8Q?@PD.\._A>+\,+\::P[',3=5OMGXX$@Z69<46PK +M*:^O'%#S>_.DT@R&8J#GI\Z53D\Z@,8(I@VN1-S3>:1HNUFRS6#$$$'T\RVA`]Y&^-IIV4;'DJQ] +M$,[0<];9B,PW#B3R9P$)CMD9C!EP;YW$/1:<>6F()&Y4103<5IKFKTC>1`\U +M_L!SU95TXWF0%AO(;,'5YU3/+A +MN/,+%R7Z`?N[-O&FH<6)+U8H4'(.^NS6@@?L'>$X>BU^DTOS<[,W\$W +M=2Q@.9Q]+"]%T4R:FK0!O4G!#M%@X\$-Q!48P3&=&\9M88Q6BB\$'""F\I3" +M#6):;.!'W5QB+F[1S+%PY%Q4)F.CK%X5Q-7UEIR'(1DW#V2B@YFQ/ZZ_X1]. +MW(\>+6'JX"L#';MC>O;7`?GM.SV&!Z:`(#D`=NOR15AH$8]L('?M:FXUP-YQWT>MY@#%^FH"T,8C2D::&UQBFQW>>H.Q!Q +MWY((C]ZU.)R]/2^UAEA/CPU_HX80=ESPR5U8'2LU'.&P[1;)^HH>FY&'CZ1^ +MCFG5F7)OY=JA++K@AAW;R5.3;9-6"PI.L;OM[5==@;#1F-0X`^WKD!JH`9L; +M<$&!Q:VK,=D*^OV.HZ6VDF;<2(X?#\WWK$R[UN`(X2D47=T[(PX2,8/ +MQHBC1%8*M#[8VI3*UO+E'G>:]=>GFRKH,`!$3&B2I,3-+KMZ\\KUZ\13WPRR +M4'J]U<'>WQWQ?2.W85/P\]G7@2'S(.WBZJ"=-V7>_=^Q?UO^E#ZSU +M/6_L\CZO!-2/Q)KH]NM!A'^,!O[3;6>)]9OOI"JN.H@.6,,87YC]\O#888@*Q +M>0>E$1%$^/Q5[/Z%$L\R0^/Y(^KUI@P?8=PVRL[OJE:QV1L8TZJ6F#Q0M99* +M;)BP:PN"M0.#B:J`:,-7#^,3)$,/?$=(=^ +M(`R1"2B.I/9=(OZ?*O]$4R@X$C#2OU8$N1`%&+[>)^Z'GO[J7S$#HHC[*'-= +M=0=]/[IA`_KAU'U-X_A=U\/`^K7N9S.YZ2W^<#Z,NB!^6<''GIL8$CDBXX'/ +MXZ+Y_ZB+_\ET+IZ;O;6//;M0?HB'_OO*>4@\U$\I,D7Y4$[3O=?\VYY:+R,' +MVG54F_Q#TGG:#KXGIX)]3V_RK+M/XTF.('4:]9Y"6AK"`'CROVJ@30E,<0.4 +M('M7C=.#Z)UIL_$8!^>\U(!H07V&[T;7Y_*:=R=Y#P(IZ>?JC461H%*HH.;]!4WHCG2$QIZ*??G>P3YD/2']$. +MWUE'+_^:`T(!\>'-0\"!GSF(G_F"_$ET\;'JX;6+[2;UO7JK!H0^U/%9XAW,3U?P?BT'P>\H'PA%>@GJ(_?@_-C^C?Z_GKZ?%P/53NH=/$V +M2&[S[,!'?[N_[BGK-2/O!_MMX3#_-7#;5E73?X0D,D';0?4L*3X,"KJ'C8)I +M_QH[B!U4Z.'Z8/Q\VCHIH]]0["'\H'JX]/N?+=)P?H\!YF?J@ZG-T??CP4.` +M^M3T\V;T\R#Q&HA_E@A=\/M=*X@2)=*/\YQT<8F]+2;6+F1?4SB;$RJM::$/ +M.(C]'E7XJ8^@HE?,U(4U&8;5D%@LJ6Y6"N1VO/.-Z;E&CWD-QO:?VZ%X= +M7T@W49_!SA2:-[PUITG[IFRP<>*.C>L"9O3HOF/6'%'-I+?? +M@AE%-(,G3N-6N"/9)`JRRK/4D6"`0(F2^(//SBQ5[@NE44BZ,QL^,BYD>^0) +M!Y4@-?1M\03)HI4=V)]O3X#MQ4Q43<,X-8:3_;0CGWA/?UXK9>U\AFP1[P,J +MGRDZB=(5P#-+%WO3RUA>,3')#C!X=CEW,EBJPCVB#==1SSC6ZPRY#ET1M,SX +MR(,O#1`-5J)LC"*-08Q]4C:U)S8M9G/1ZKF&\;C".4[; +MWP\NB>-UC>EU)W<@)*1I,D-*69FCEUO3F^=>_+N='/.\B]^N>+I@U&^9790A +ML/7>O&73:I5\.T[I,5S=Z=L:)$?'MU$P-*QAGI>>!1E5%5!X)2!3%2BIH[NX +MC=EZ6=N[NE>=<+N\>:@A@VQA(E'PR$LSC%F)D;(W'JQ@V0L*I%(R-QXZ-T@1 +MA)!IEF5$9IS9FU;SD'+LUQI1K9#.9S`(+`X@M/<5N:437%&QF+:*8#&FA*.$ +M@;Y@V)QK08YA$0]Y#N7#EB&02$)$@DVE($$4[&-,!)E_?X!KPYC):8\]>0B^ +MX?R//;9N,="(NK-60UOW8.`S)X,4U,^A.1EY$-VE20Y>(:< +M>>@GX9\OY]&A`754E"`FZ@_P/FO0^\_-Q"'X+-4G]E@%(H$)`N/!6B7$D?]L +M)8TGB.80$K2@[?;?6QQD1J.^,YBH75\B+Y>(>EB^%G!0<1"^/PK!28^@K6W' +MWK%1+Z.JRF?S&>8+RJ&]*2T%*8,932>LV&&22!@1"2$(PIFRMM#`U/#H9+WD +M%WW"5X>*,I@`*$6`;6!\MG4FAOJX:KX5'\-JZ/-\UPK*1'&\ZM@1HR$T)';G +MV#E`!.6:!115Y=9I3+9E$4(PYUV->SL)`[B&F7]6B'4W@UNF![=V91*P3=U6 +M8$V:W<7NK-T`+YN5T7<,V]?MU4T>]DUKNO!V_]%SF(S@M9B';+`.8C#!Y^Y" +M_]"M6`&7$N2(1A,@[&[B`\,IE$A[90P13RRI\,X2;K(ZW)9(/#6 +MG]F3ZU;`VVA13HT*,&(WF5/&"/J0,,5S=FW,=Z8#MKRZ1KE7.'.K#!^\W&-E +M,I()BH6-["H6HBE.X,E40]@P*@@NS!N#DV4"BD_;_<)W8$Z%]$"A9%?>$\\+ +M*1,\%J.IV7Q8*D)]72@FL-)JBK5R(\,X6`W$%"O=B2X[/7R^>GD$V0*C?TRI +MTQW]9=W81):Z"GB4;3EJNP2ID\@,+L$#P[:BUL_9&3W'8@0._3^P\-?Q\-A_XX'O]_P:UK +M@;//`][&`/>6O2RCR-,.QSQ18;RH@YX/$P+.0C:D2B,8%WW%F&`J13.%:\5G;#6T$@7AW(?2L'#27^6()9-=7OD"2%4!Y +M4H1IK;AB,Q(:C3C>F>BY:HH,%F`G$)MZ:1 +M*HTDRO3C6FR]\7:M-1#U1"O;L0$\B;<0G!B&6R+PQ;C3/3-,`MR +M3RUP]"KX:S6?";!9G2,UWF\->'][A$#*Q=T6)8&Q<%(V!:JHE7*0`E+/L_Q8& +MDWM>B*5L40E2&J6R7GGK"K8\'H*UM/Y.`R[X'[?#W];ZJ&E^-5 +MG58!W+>^M!F9FJCD.F&!?;UG>/4J_M?>L[=Q=TYI]$':M.S_J/AG`QAKTT^9_/LGU-;5W>90O^)HD]_&\:A8DM0U5-%I`C:I;!PGS&C0F`;)(8D +MVS)!$9[-@KR^,^AGI0`[T,7+!"H!`@,$6`A(P7NV&B=!'Q$:4ZKG2K$154H4 +MRXAALIJ+.]]U]'<)R.K(*!N;D.XU)@2DYDJ,);"D%B\[),9W84A_TL,F3%4" +M2`0@*5$>LB)F>3T=')Q#VY(23-`OB?A-(+Q@J;4P@QMG)G''XAD`D4K-N4M0HRP>QU5"AX2'U@@KV$1`P@/E(B!1I!3E59FZM:J!]C+K +M1P4#4L[6U:V&C#WLV+U)1\_QQXD[L[:S>=C'88=H0M.*N?YTO3F*BS_DZC4[YND-K#B88GUN"@BBGLVD +M,TA2#UZGX=E+YFN)Y?2F7K//^=OS:5[/T)+G.,)$#F0FA1*#J6+14X-L4Y=F +M5D,$(R.=?+;6HSW/T0>1IMQLDAF2+L,4#,+2N'&S%@^/60HJB, +M%BO-G$8&46?Z_QMV\FW<:32MXVJEM'12E2S!9:I;.7)IN$I3SJZ05=W;0\>, +M(4E%+0U0W=/(E21E[;*B_2+[&H1Y]'QM?96S"":F$%MO%*M":Z>@GA`DL?Q]!ICGCP9K%LD/,X^?A93`*G$5L;L_;S +M"&G+H1:D?C(!'Y%`F;*?D&!9!%V08A'%T[FC01;B409C*@55%7%@I+-I,#D> +MDL;"<#Y`['V6G@]]^C=>+VYY4WE#QSG9T',%0BD%,0Z67'7KY8TH`E'R$"$D +M]NV&QZ^QAWN.J$G$Q*)`1Y4][Q;%@@B]N%(R@3B%212$Y_)U*FA13]]6E]Z" +M2LJE,/9^Z^WOZ],G]A0YKFI3"9(!G$4J!K8A/T\WKAOMW83K?%E$<%\:R+X?5K_MS]'^A]S>)G +M_&TOV?7?Q.@1CW#\+AV-.C\.Z)7S0A$[?UK"$:4+%5@4,@:`&+#C, +MGEZ(8M?^@L/[,AAF]($,X@?DB]#V_$V#;_;I?$P/:PVALHPQ/$/S8J_L`Y)F +M]:QJ,B>!6%P4AWMD!A!/BUC`!W[_I,1X=R;`ZF0,"SWB_ZJCGLJJ"P<<\.FL=*RN]S!<5\,0ZK(B`#Z"C3 +MU3RI^U1_]?PL$L?ZZ32ZY5.<%BHQ062A^:+[5+M)3W4'UH7!CF*/-QKTG9Y+ +MG=L6.P5X%E^E:[Z&6;%/?QK)V&\!_?(6O+,D(698YKSO4YF*]Z7"W< +M5=`62&^2@#\U4)?`:(B)^7W/_;G,&?$*Q^Q_VW:HJ,&*LQ/UMOGC(C;)HTYC +MQBGPNUHV78^[YD1T^CX:Q9.)RS^>D\?VM>9[U!_,?TV>)YO]SAQ3?])H`7NJRQ`[CNRHQB_R[^LR]789>' +MQSE$VI]0EJ:@\2INQ@L^60\A_M/COGLWT%@[ +MGAJ.>A[#KZ$['Q=/91-!(.C"0=7%D;`E0J;[4I6`@$]&U.JQ=>.S+=?6KM;/ +M^&#G/=SK!BCC^$HLY\CTNIJ@GM;OU-QDR+^RI.>N75Z%HA-N;$)-28@KB#R(TPF +M*E0)((0C<+=>?[&;06@Y*T;\B#HYJ^^B&3C.2-\N$R9A2F:I\5D`6`'O_BSF +M(MZ)[\\OG3N4S\F:?7:`9'KF8B#8$S&*+(A%(`89<4*&T*0D0NI^5D>5"')0 +M':15@'OZE11!CVB&@#CB944Y[[-!:"`7110ZG[GS?#_*SPS2QUE9JLA;Y?4[ +M)(BS[*Q/[B=JWBUX\JF^*E$,ZJ"THFI8HVQ+N,JQ9=\[&[,$.'L_^5377%Y! +M8`]=$_M>Y9SKPWWF@2+?B1(G$$U*7-SX4%KDFSZCB#GNNY/9Z1K?,36:6F[6FO,UOD,5D.$![54QFJI8"]![RHOU(#`]E)N7`/TA&X=T20(.B&3"+% +M-6V824PT9DADEN&!:0ME&,H*9_C/#TN)&WER$;$N:F\-=H])8-D_@!`N/T?P +MH#JM](?S>&_X/I,FQ)?0!8,.0ZH(!V46#YGX#U620CSQQ>+PVMD&]FTW'$'" +MQ4C@\BK>Y^+J8-VQM#>2#9(Y!F-M6^FX.F<,AD:9(8PKX6%D$WVLTZ^#7.O+ +M623:6CD)-4W>-O&+X^U+(\C*X]W69A!NS:1GCV6L>S-;9;)W$.K&S&(K(,C1 +M(W&=9-@U(;["P'D!B1>215.E_8^CW-K\+!D4 +M;WL9*ML(F\89K(6#T],N;9,CO"RW(:+2FZNRU!1W8YMF`F2IZ!RWMG?<;`'>K +MKI"5+IP03"%#*Q1G.Y1H;6RJMG"6H>8>UC3_@('Z#$`**(,OI,B8O0QQ#Z-A +MH+(GKV@&)L8'_P_0H]8]Y_$?G/L?@^KU+DH3M"P#$$,08;DZP:6G+S^DO +M.1]G8=QY/'2_(F_FB!$"#+93OGN@W4(3$!6\02T#6<:4^TV>.^&LU+>;Z_[Z +M>K"[?3QA\5.GLH(`*1\IQ,AEUA9Q_#YC6>3P]VBY;R)TS/+W\3[2MA>0PD2&O5IO:KRY#3G=PK0U1ZDIFT +M\:7#Z&_;I=*>BK8SQFT_6?YKM\F;7.<\*@)I\H*I'NBF9ZMW(/)JB)1<]N?I +MVV]_\[[LY.LS?8F3J/VX4>_,]TAZ+<(.M:-T-$]S]HZO\`@"6833]!)$'6H# +MW"CFMX\AW[Q^R9,3P&+?4"LVOU9#SOHP=&X8K?OK]#Z_2DX#U<#G.;[+S+_!> +M)2I_'1KP'ZU72]!69WJX!U7@V;'M]$H,NHG1^M>K("^$/XF=W-T +M.U?Y_HEY[Q&\)M&3=GB&%GRI8;,E02"5(#!<\X\-5_>S>QN +MMXJC`Y;E0Z.@X3O$&2"%"00004)0@A1:\$%='TC%H6S':_&ZV+>^#OU3DL+5 +M8)L9T$T2DEDF_YD^=Q/A'-+;.&9S(C'O(TA/.'6MK]VF20&Y*NXR??MQE]=* +M%^NCXDFV'G?/UW9L[J=%8:+_G&R)*/^C=V"1?.*P(")O@A$+ZV0+W'NX?MK3 +M9<-IB\)D6.D21T=JH?+W6F4_V_;Z)US%[?TOK;K,/SKJLH^;'TYR2?;1`BK< +M>M=Z;=TT#&;EOWHP0-G<>N]7S:/@Q#T\%#UL0Z7SWL^J-L9_]%TU^EH@(`,O +MM_#0&>[RRF>_*PE,# +MJ#F6WOTR&H&:CB4EUKF:;/OU&SP;R!OVZ#H_*;'QH,V:LP?^C/P?SQ5]\EX? +M41S\*C^3+D5XKBC"E^50&"GP59R*+N,GTB[&'31,J(R(DDBCND<^9D"G%?95 +MQ@#:(-)1B'P40OR\"&-(R1(;2!M*C"--CD05MH)U!!DRA`JHP,//70G[E%1R +M:@S-"DI`S#!^]OY"BCSC=V2Y-NDF[O//T7U=Z`X=')(X*$D(0(,>B@&S2$V" +M3:#8V+8T:L;:>N,6MRUBUS1;7-K^HP[KX/$_X^KO3M6Y]5K%\5-0+0NFE1F6&X(+(K:(N_3MOR9"?EQ +M73%/D4MFU[]BP;_DH:-$N!]3#U=4;RK,0/Y)'Q?W0XY2BG;DZ0V3SL@[X]:KQ5O2W- +M6Z8U4:YMFO3Y-XG +MG>U^5\N9>I))Z''7RXU%9[W"*L(R-#)#C3TN@#4:C5XWU:>=VN;>VHL#9L?UV.^^7K=K#################$$"8@A`!T^7%L4RWK/-' +MS[;<>QZO>Q+SSI$@;0NO>_)`])]50^6CL^#AJ]U\][00SY$%."0!V +M^Z;WL$<>>2_/;D&&\=QJ=S>W!^R(>OCAR&H$BM;:VN;9:M5AS@FV,RYM,S^25*L0HD,7(9*@V;,),@1('T_0[ +M_Z$?5V_K.Z'<`@_C0S1SLHRH5K40T5 +M`ID.A282'GMF[+SVW(\7RM_29_RMN,9:>+SUJZ'\:'T'HRM>H^NQKJR2NU;Z +M^'0C.DY60YWQ_K,Z_#W#CW?^B4$#W.`$B1[5W@4#]_\0@/:(7Q[`*V+?G#2% +MJ>%(IU%&`V`C$0W$8+ZR'TJ&JFCD!RA4FS)[XIN1M>5JUFBYM:^J5`J9E3U$ +MBK]F`3I0_6\&J\EX58^Q^!MN46J%30IOO&K%)$M2E;3M;-J6!1%(2"2D=K)K +MY-20PO*\XL8X&Y*5>B@KQ+(,6/9V%XKF/NFQ=*VZZ:+YW(',:(%#$SQJ;6 +M[J6YP*>%+7:@+Z6M)B_/IS$`,E8E^D`%7C?]=6>_;K#=$8+-B2;NRFYAQF6G +M0SU39HTP5*TSTRZD)K?!J_3<6;#LQ[^7@\0,$0X3*WFZ#4UMWEW45U_&[>65 +M_.[DV9I-_KC.KB!8@@&TG)?SQ-_120*-G),=TF[X>A$*'5]87$1:W.S;5M7X +MJ=H7[I[Y+`"([%-ET+)D*3-=N&%@ZG#1Z&;9OET1<@G!Z'-#33S*C&C?LM(E +MMWO`TP>P`3,UDSXXF.T_G9IKFCA.5V-K*SK)HS6H[Q@=Z)SQA^RR8,9AD>CM +ML3J]U:GRWP^5OE"X^3=2<+Y3NYGW,6_`WY__C.F)^-\>[QRWM\&XGV9I^AY+ +MB<85C?'ME19>[TELYQB&&KDO287I2B,AQ>8E)(BCKB;-I$TZ>!:&"V#15)4$ +M]V\R0YCSU&8JD5)9.E6Q-M08E8,.9I2P[KK[A<#_'AK-A?9L*[2A).N='JZK?&L';P"AAK +M^(IJ!M/7-Y[:9MN@YMG-F2Z+])F)N\[VRF50!A@!3(.2[??WO$16/DF-2L+8 +MYJ!![)*#NE?!N,IP0K*KU!![RN6YP+X!!I +M!9Y=[!\\L.V5&[A@&)9:-,[!V9W`N,XG@:%V#Z036?CE4^BYPUW<-):X5DYT0_@.Q''6FO+,,NCQS7$>6G50&+EF5K.1S=^N/,ANKZ +MW#FVS9C!`&*CM&CZ5'<7SWSVAHA.(V^NWYSIL8FI&&XCR?%S$7(DV5C7;%=-R:A3TUWQU6]5(ZBS>_V]?K_1S\.Q](7=O;Z/,^? +ML^Z+X0W2/HKC??GV?BBO[`^:]T^Z']^M(//90-8&ZB:#]_;W(50\V)%[6^C@V#=_;Y>']8BLU0Z-/=@B%[GD0]&4SH83GZ7VP^6R_1 +M'[A^%=U]!S]B5F/ZOZGZ[GM\NW>S.?3,( +ME\FV>E^!%PRC,%[$EC;DCG&*'3SLXSA/6]J]* +M9_O3CZC>I9H@H@B4UMUCW]^V=EP- +M!(SN<5PW9['T>L7P.@?D_O(JH=EC7@57Q^ +M_''OJC\"\+MA@2!^W>5`?V,`GY&3ASA/YZQ1S00IM`V@W=$T9A$=AVL>CVG/ +MEU:XX':V=?3[=J%[``HS7&RJW$0]])^#U<%)O,4]]N]4%^DA[@+[OM_36OPNIK;>!PXX>]SSA;PB!F$E3Q0#`0I"GI3>D#LI$B+]O[('Q[T(H$D +MBC;;&(&D#8C*)Q+=-7B3?K+QYW2NNYR[2HQERNG=)=$'=WZE;5O.MO7SV_&* +MVU&$`^;:5D6212;&J"A(T5PG'#A*R:T@::$I.L2_2-`&VVNZ!,4#:P@Q.0?JYQDG(]WQZMT +MTHK42HMVEC$9VD2F\#VF'AUQ?8-`<6$L0+RM*TU2129I*?!:23U/RE$+2/N* +MT8*2TDT@(Z`*``^1GMTWG#K7HS/N-L7GF[Q0H76>9E552WTJV3LLZ$-,+G?O +MA:3N,#_M[U0+9Z+*@\E\-A-[6A1R/.]I#/*HLRXSAV]33CT`T0V)JP]HP/#3 +MVXAGYC@6>X3G9P<-I+N@\-DV-\E0U9,T+V4&K/,L#1G0\C?AM0.1ID4FW\JH +M&Q@>E]#?4U\_=#V[YUU#$?;+OV/JZ%%\NN&?@^Y"`/H7"]]S#N]>>/(YV*?B +M77BZ69K^S=+\+W9$V.Y59-(E5"D46<-E%M-,WU4R0I%`WBY&,\=8C&Y'*`J% +MID1(*+)AH$N'+=6P1CP7DO#,#%55A2=8/FI%&0@,6N+#SWFM6J,79$1Z9#J1.R;QND:?8YW(WS\<_0GN\NV(YFRU5VU5IU[I1.)I +M$0=U4D%72JF=-5@/$>'-?[ST7$'[[N;\>Z[P(KY519R%T'$2BGI7B"PR;JA! +M,(:+RR&.TK[)K<'4L3>*%D%D3D>HAX)DV79KT3X5GY?,=O3/O)W$511C.ZTB +MO*A0]ZL-AZ[;IEW5TB,?<7:Y$UZNMP^YVJ;+>4WJBR0B<%LN!X$NX-,,:8^> +M'5ZT#;:[.V6@;S![_)%V6-IM&R7BKH$(Y9#3%,@>JS&8X"BX9UZHMBQ5PDEL +M(U1)=XLA3KQMZ\Z-7A-H"BKFOM7W"KTU/?;VVYO;TN7ZPKTJ],:T6V-9V(1# +MQ=R7K?/KV/9]KLQ?*^!Y2E/B.(^4/\U[[>YFJBTU`9%'-I`7`GC.BMH[[$(; +ML*+J^W3T=W0.M1))VZI1@=%!T=;F/=I#KLZVSG3BZ_SWG.(. +M$'AT-!QV37W:J\388PT,_/T,%Q\CAA+MUD/[( +MEOA8*B@[L1`5^I_2C0B!8,/$==XS>>++BD!/(1%*?+]4M5B38S&B4N8@#`;$ +MD42@V$2-3='QVR(JA,M!Z&"`(YD5`$P521EAO[&(D(+S"78% +M>8($E+6IJFLK*1!`+%K`8J8:V=1GMM2M1/GBQJ!3(0"RM;*T;+M)E(9."ED[ +M(48XU#T$L.:;NZ155,D(U^D'EDBG,IT$(7>Q1:]83!)I!:%519/SEM,%O$!, +M*,FC>!3><(B%`S(LZ;#7!\"6%D0O'$4)%0!$O\+$0#0MP0$W(;[@@^FIZZ3J +M;U#.`5D(61(CL35D/@V*U]GEYDBP@$U(N&$B$4<>*^C/!0(IR.4.>"T,>A0@ +MP[P1/2;!ML>IR]\NSJXR[W\/>?=ZX'RRP;?Y8#\<=A)L.`!_2\O>T"FFUM\H +M`)GX;O#S.76B')65;.SMZO.1*"J8C;Z!^#0MDZWY[/''7FV1Z=:N[)> +M(9RX:_,WH\(>$U"49[BQF?IT#<$6!\/*T="K@WP';PH]"_IIZV7FTG/CX"2` +M3,$I4WN0K9K1]YR3E:"FF4+4V(>.,3!R,6=_+*37'D,G);N=.K=6SL;39 +M`\(?-(;;G@^$MD->R%(ZB7-IL=+=/>KRA;8"98HE.-U$5ZJCJH/@"D%W4V3:;6PPXG=,]QX&KNV90T4[,%^5]GV4"&Z]&9+V8^9\- +M`]_"O1-9(;]%9REA!7M\!7Z;<=4.Q\?6`=?+WKR1QQ\GC[N8POH\30\Y56UK +MSSP3V4*5W,I45[?:ZW=./FY#RV-]MU:@]GPO->:;W[_(]SW->KI[$IE=?N=& +M&Z.O59IKUN6[3+*L3.B:L$TD!:BOLRU$8N]XO/SIL?1"-@`0;LK<1]E:OJ@G +M(^FDSY0$[N&U-OC]KZ<38K&>G4RUA"S&'SV"K*X8/EBKO]0E`?F@?8/YY^#' +MZ'C0;OP..,(-R#'=69\`W2>B&9I@%W.-&1FYPX'AOF1\OD0M0(DUD9E3@!6J +MEJ'+(D5Q8()-[99,<;4"I?F3B7&B:%%HGMI_-E$_.K>?I-1AINWQ^5,>#K1# +M_+[0OE:9#%D<-VP/=QZO]PUG26O=@7`SXOEJKBCJ7:.RD;W3:"J7@7X]8?F;]Q:PP&)(_*!5S?0?DV=DC9]( +M,;?PR!!;[O/-1!'?"A@KZ-15H&,UUD<;;8P-%]:)HNUZ^+-1F!NO6\;F,Y +M889('+HU*N[F7MD]B.#>93?UH_D1L9"^"E^+<9:+9@F.@FOSFJ/18'66EQ$% +MQVVYL;,V9O?\K(!P]/]7+$#U?[06< +MLQ.3[UXG$6F(AGO=_/V[Z&[0&''S'W?0+3S@8';OQOX/!+4[ADGB6XB&[&Q@ +M5+J(:!U"R8*3B[Y+ZUR68UL3I]N&EY6Z=SO3 +M@7>US;92BGM:,K)&+84$2L2-/$FWH9/R"AL`CA.6&-.PRVM[4,S,E)85EE3V +MX;5YN%55`6:Q3!VRRPZ)940TJR=(T73%.[,6HNT0X +M9[1=NQ#@F(FBRB!LN6$,;G'C6-S?:15DX6K=QA'V(Y-'=&>2H^DCYD6UH#Z& +M"UHZ8J2Q((9#P)0\^DSW[X[LBZ(210203,YB]KL&$AR&21CX(02'WNE`\?0K +M#'/NR*^7MH:@WP.Q/!)%G]SB9S'^&B(7P*-^?.=/GVXSH8>SJTQE(@K`S4#O +M8[%['BX=G6SH).L]PG/EPB1[NR&+$L@)..J;NE!NBG9[E*UW7BUAC#3 +M.IIR.R/;Y_A=:Y%J!PR-:V0R8IB_I#GC+9PZ5W]_\X-#MO8QK$Z$\1>13EVB +MVU1NOP_4,1P-XPGT-.O+":9B0 +M;L^.H&\1`UC$;9ZF]@QI7K39C`IPC\"*9'7W?25WC4U?M[ACFP-6Z:]R,YY/;=Y%_7 +M(H00>\)A>D0M+KV7I"G^44=>G3CM\I#2;LUK9_'C<$@=7HZ+V[=4)]8OBXY] +M[5XH=%OKEKD':"AB56X!L_TKIP\@-U!B(0')`46NFHQQ-\A&P:E..$!Z-#$L'\ +M^H)!9F:E)MO[/HL2K6DR?@8*'4LQ-@&^&=9UJP"UUO>31=";MDBD4(H(K,TJ: +MU*B@PVH<'?XW:D\!(]\\+K\WA=NITG6RO(P#\WR-]=-IZ>!ZG&.>CI[-[#XH +MQC.*7(X^L.AY[M+?:]?!2)!N8Q`=X2#WPT;FX57'[GD7%'./9T2=%X1O"1#`Z+%,%9F36 +MPS$M`.61(9+"$-M;=[+/;KMA&49,F"A''?_&9R7X5I-@3L>$_43Q.VJ*)+EK +MQ(:!"VUEOZ_?^43^#\9'F]R-]=V0Z2\J@_="7L@>NS8+^,ID%17>FB\-IMM! +M&L$0&@ZQ#"[X#0D#D@?9D.'=B!ETUZ8<8?+R6$\<7,&3;#LU@Q@V;(AFA)I? +MB&;+:8%V8YKX,\\`Z^O]SC=C[>W/SMTXW:WIHI!*\(`%DQ3*-* +M@*!W*<*@SZ<9E-60"5:C\CZTN=67I<-?4AN#&OPKP,]R%+YK,[=7-#2#5`+" +MA+G2"D2PQ<`H!L4PM]6%[8NP1)))4-SNUK##M.U/0,Q&)BJQF7J//TQ.N=:N +M[@[,#Z1Y^WO\M6].R=@NO1V@87;O*PVM3"NTX5.S#)7P-SN%\3/O0R4S>Y_; +M6#A<,TJX?F[>^W7MZO:>$/-N!@<;+AOASX\O3"FZS1;%NMN5O@8F0)"\ZZN\#3U)>$CY2M`*_5^+N!NI^6%`]66F<@IZ:+=$D'U7 +M$K5^S$[+]+(-&?RUQ2_QUU(-KK/V4,N$_"M-(*=U:"95@.)Y;U,X&3/CR(9[ +M&Z]5PSPR3+"1#+160X08F0S!D#N[U]^&X3TAC"(Q4GF$B55M&P!*U[E)ME7( +MP:RJQ?#E$&"TA%C`AU#^LPY)?V5RPFKL]C@7BDK#8IJ\H8D<$`5(9@L\5>L' +MAX+>J1G`1`-*^#;*\:O>U#9)#F7''Z_+ZZKYM=B1I$M*64W8^#1A,1\)`4:9 +M@T%I*<]\(/6MYP.\BAD@@Z5EDH%+Q#\1`+`%PS%@Q0^S'4U,@-EF>_FA6X1OM5A\N:SK'4T.*S7QO](*!!T-T$MEJR%GJ<-N-O'U:C%Y9>E +M.&M5K`KN&!AL'UTH-O0DDZY0OI;+!*$KNK1<0W"5K&Q!-&US=Q7Z->1+D#/N +MS8>_*@^]MIMP%'Z\_R$X'L;?&MW[Z?45;T7=D2(/&'8EAI6!(#FW;V"N;P/1 +MK"0^QRVL):,8J=TS+U_5%N8Q@\?FI'N3E#A;(1OL$-P`X#!(8A<3!O:F&EV< +M\2UZ*FWR8_E>;&`R-C\?2\6P]FP#>^MS7!<%-33.:89P))-V6D1S?7:=M,C# +MK@7J<2,=^U/@CQ9-]N:NGK7CE@Q1Y/U]?.,8%LBLK+2P0OPH:\,_:7:\+&&E +MXC%54VP<-QEVRI09-9LX@%^&CJ+ZUMM[B^@QRF/9L^Y2#"!7'S>BQMR'Z%6^ +MCT&@QXW*PR;E/)]Q94_(21ZFS"Y"`[ER(-S8.XK\S+//E7H&Z,G!!LP4&U[C +MLUT[R!YD4XR1$LVVR'&5?F]0\$39(!C$K?YL2^B!C#YA!KTU&-*SFY%KF8)4 +M^7YA1:^/L33DR&T$#GXX,?5[J8^OX+>PQ$`D==^/1ZI"2*Y]1Z@/W,O+$V!L +M;QW-O3.9?MY8%M;UXE/@T)J)6$SQ#?QRNX@207O"7VEAH4=R0MEML,S@\-&,U&7N)P0IEK*T*S0HO-WMP:N$`DI!G!L]&2P +M.YFGF3@SK2NVRE)(..LJCG&U&/&6\<.-QZP^B#CX`5E&8DYXWAA>GOG'4RRBTLN"Y[,G\PJ([3Y-3]DH:U+S`[AA&5 +M@U)EA9C::AQ>`B&X9B293AA(9M4Y98R;-DQKR8#)6*,3!X''MAES$X_%W^6# +M;'B^@PZFX_T/NKW^_SLN&\Y9^K?K[=Y-QE7KT\AL@&_/>/;$RM>"<0R@E:8< +M@%R-Q[-0ZJULD"(DV[_/)WSQ6+#W6^P[E$@]H'S=>1 +MZ5@;+^AXE"$[OXHTP)N;FP4&#*Q`V6HD-#I[&\+;* +M=L9D,LH>U2:"RS5)&2(LS3$8O5_2WH!+6QR%8-Z=\C4?BWQ=^65W':-P.O>I +MA6ICRUMM=M&R+\&F`-($[5J9I<+:=P19]JSLJN1EZ$.0J_&XIQE$4*4;;#,0 +MQ9(KS-W=-+4(]YGVE-CI/TLXFI2[R)!O*'JZH4R;9L%EY:8LG_-*#"Z0DIX+ +M#W7@=O$,`=0@,+LX<\%"4NNZ!/5YKTCTTADB]JRRMU7Z(MZ=Q:1/2\T5XXE@ +MZ&>L]#Y6II0\I$$7:S!NVEKS'=VJ6X/@C%VRYJ<"O,7IRD6#6%7Q,B`3VANG +MG`O8D2"#I,Z[*Y(88@<]B(B3DNJ.>*9R>9#"S$N*YN(; +MA(OE5$7L^(DRZ'.:FY[4.96\!'"3GK(6/K.:1?85]V3\9##)TZ%H(P1BZ6T1N1WIPXDV!AF4UC'K\HW/&Y<# +MV^Z&714R1\4,./C:P)MD +MV`^.$&5Z"][:GZI6[?.WXAA_@8XZ;B58`D"P[3W%*(IK-=/)'-H9T^%M9"FQW3-`CK[G^D3KLL\2W;CJJN;_1R +M^;9ZJ@$LU!P$!1`,S'6@):2U-7,B0_Q[?(=IX_!U:S`AATS=M?9N?2IZ>`SH +MW[*<*"&#N@>_AX9)""R"?M4K+>N,7&CDY(UKGV4$7,&P113MY;^4_&^O-=LK +M%VT!=.O+"LJPN0.Y'7=`E@BOK-3OU9KQW=F22[JS-T6"R7[W!'FA! +MY%&]VHQH77IX2&Z=& +M.\^-T+U?5A>IQ="JRE;O8(^>MO9R3-#\ZU=^]0A1NPBX3\$K=5*8'!9W0:L: +MX=+C><0)+/IG-U8:(NJ(8]D<6?DL];KAU;P?.EZ[45B'U^S)K>6MN%Z_5N?4 +M1-H/JAWGIH\-'CQ&*G>`8Z=7/1K]3#7*>[LPU?%#4H7S3NQ"!Q36T+K,HF[= +M,*XN36(#76,A`J,]<3;75][LHNM0%QJ(G$CN[0^.,W0ZE!MRX-*[:VR@',R6 +M#G4&5J*ETUQ(0D$GE, +MQ,FYI4"V`CS3V-U*4Q$1#-=8,->Y.,EYAVS9W;+L\>8IX#(A*F +MF-8H)0W9KR0\/D7`=[I=5>[ +M!PI+0';-Z@E<$RS23-W6:NHNUQC$LX?DQ +M7H(5RZN>+\UV-ANIT0D35QS,6:*?SR@8%VV.*NCC)LT-C]!6;C5\\W63"LQ1 +MK*IVAR1QXP\UPRK.(D$=AQ0H214L;K(-NHXAG<1(=EL@$[E6-%0+#9M\7C2M +MP.7Z:H5_Q#`^L2P^UP^-VE>W`YZ3GS0Y-%2#Q>&)$*^8.Y0V;`?U9L*E98Y:2#%"WZYVM[/<;0)5TBHA$8+O/#1= +MV?FF'$C%.";W1I&,MBKVJWH0B2X21L2G0\$++)0)HV3%"^89WPAG:L.2-D6]Q%1>GMH +M*+BQ%AP98A&VZ%R-&&2#P%/)9'TPK+<:B)DM?F]/GDE!8&/L#"(*CY@^XM&& +MWF\B=-WHE3&S;N7.GTVL7+8+7&VS/=A!/`5'!NT$]\0].$P8'*1:0AR11YKN +M,"6QNLI$!PN.YB,WAWF:[.)XOF'8"1.6V_ZE7BBS*`^G!!5V7PUD6Q!$*U&Q +M9P&>(W@3,B.\!USL.IC!$0.L!6_#`LC)&=N,/V,8_SU/*FJOX]NW.ZT"SM\G8GACVP&G/FB_@S$*S0=7N]"W,35PE1\FS=Q")-[7NS/(8F7MHCL +M_;&'Q<@=@/RSGG0^5K?($8UZ)^;_3YG\+FWO6/F\_V+-=1=YGWBBKAY_$CA3 +MB?"X:ZU]29+Y9MONRI<>)V"#\T!.[-D.G.$,LWSYZ0\EG3Q[,SF]!VC'43J[ +M?\SS]8FUNP;9Z`]BCC^8Z%!5%$$%&(7Y#,30Z.QQY>N[?G.[X: +MR91Q#^2&U7?$'8%$%XKHIF;`KE;;(+,7HW.NFSZF*SLJM\+<*RX1L924);+8 +M9..39+)BC$#895S%:)"6MLRYX^&^&-L<$^KHAC#:T)D4$G`0VAJ[W6ULNWIS +M7"6:B*:'EJ#,HD4JDB4)#*VE`ZH@@@9[KX>XK.CC,`@6Z/TGX/T?HW>5V[+X +M_H1L3\CU^M#^?*B)^!@?MS+91@8605-07WYX*3:%&E7U>HAO$R*M-;3FRZ0J +MWFARJ#!-HF!^A)?%E2FP4WJ=A##'16NF*9053.HLDMBKZ^M>HTK&F_GZ^*^> +M?5>@]_EQ]7(&^BGPWSKS/:*KE-]6/?/P$B.\>^^^V=+MX<$3UR/HZT++'7]Z +MF/:O4;WRO5)N(UV7Q_2O]+\8/YGY+9'L?BO;O@1[)23*$3]'HXCXXP/:!+)\ +M4[2>S156448AR3""LIO1N79)`4D"9P[DO]],-9C-[S2>,^BP05(G+,*-ZMEM +M%K!FRWK.WWN[PU00_X>FE[%&M].G?GG32C>`I5;(ZQ8B%>T'#)\/C[_7 +MYU>N[COXUWW$NFWSSU#F0\=S=[-C@%R^P;AUE,P<2A>>[9&Y!JFPE>]5J1)P +MD2Y4-<.@])SCJ]Y@7HC$N-QO,$FL!EV@(\N"1(I!\76>RQ8B.;IQ?#Q;'#-< +M$(@=,\"(%)&"%H9P&$98WJ]*,R':E,D0KDD2'*HPXK\@[R]#0K&-S9-DT&B- +MX#5&]:FV1ACFN$L'`;9:[G#+[RW5Z/G'CJ3S",$J +MI=6W@7%W`T6GL.EH17>Q,3X@9&+K`K@886-(IARRGJ8W,T".'8.L.TX=W=-7 +M.>E^`'-^'I/WJZUWR1ID@*H2;.IQ#.)?%+_4#4P0%BE4BH"%4!2I!!`*("BP +MZK?7F5.$JM!)A?TO%=T\_)N@M2IP!`CBE3U=>-0/T"Q+]F"VINI[*0RC8;.UU\ +M>)>Y^6;D.\'ATX=F(XWP;Y%Z-$E8_:<4&Q*H5&%'E,Z`?M.V#@LL$X=W7`/9 +MD,YB7">2W[2H.`R\.U&8IJ*9,6NSO +MZ2_IWJUQ&\D7P])7M-X6IUB`Q2?0?5(9;,.KRA=Q#\,8%TPGS +MG4$1._GWK<[.^,57+_N_2_&,B1WZF9Q=^[AT.&OSQ5?MU!@D.N+:C[&B,EEE +MB=:NUSG'C7,1;>NO5/&$MZF-R3*TV+>6Q*RJ,\WY9_/7H9>EFN&AM(Q/:-XE +MK/WRL16`6^O.L%S1;E;B+->[Z]$!Q=+67G]9^>!?9YCEA[LL;9/@53QQ<(D@ +MZ1OJ\2%6GNUYOX51FJ?$Y+1"R&S=GB1?G,=9&B&RM8.-&%HN"3GQG+8Q?.%# +M25M-FX\),YXNM:JUR+PZR6"-#"+-EKPAQL1P]X3D3NKYOTT\5=7Q@>;V5YLN +M5RY,8V?L<(:\7[Y^@XQ[Z15VB +M+RUXV[!;Q[WR#LBXT5?W-HOOHLPXIF/SSAP[W7T]5P_G..'2$NFC1^(W$>6P]*+\*2/H +M/8LDKTOW[K@JUU#`*GGOV[[V,9Y\G&ID410Z/(:]F:-[O6*KQQ.KW +M[AUW=,(9Z-/=?7Q.QS5QQ>6[=1#*93UX@-F>/&I!^KX-KGSB]P7,CMUOQS&7&'T8=QS=\E&.VE4X&. +MT\X$M=HI`FW&-']SJ\OG>/7'?SG/9\:SU+$[;LG=:=WX![R':3VPT<1>I8*E +MW6=-?F?*I/@7WC,XR+D:RL5,W>!C:M-NJ] +MLAXH(XI[1B6N41HY[NPZZEAML[P^SU=LY-<(ZDWOW^:N\4]8W7>_!WEX7)<" +ME@T,NW2^303"Q>0R==NS89HB9NVY0X,<9P_3/<5E//?.)S%M7X&^QO/G"#OP +MW&7'=]5E1L0F]\AHG`B07<*]/%[UX?NRSEJW7R^;\\7A^%<1"N^NWQN_5+*X&YT0XGUD/T:'CB^9JHSYS5_-IL0!]OO'Q +M^EHM\G&VGY7M%"Y!/S_NP3$FKW[>]]0T1$;MLK<;^F8ASGA0Q#NY9')9ZW:= +MIEC$<^H.4QL9.O8&$[)VO.[:>5V'9K;('-.Q$1>OO[YVW1W=J;(91QO`:P^$ +M^7S]`P!$5D?>&+V]A'I8[OOF6_B@?`@&WZJ#J%W\W6\PN)8L9X&[BY%RS',: +MZ-`\2_!K:(\*U#+4I4[$U+IAXC-KNY^*"I6X[1>##-U16K-6D(C9<6QD]L.O +MGOYA#/H>"UKS^;CFO6X'-MHR[A.M89O$99Z^WF.Q??UH[Z@G)*`@#"`P*L++:T$RD"E`Z#F[9['P.!](.!8XW/.O4 +M>\:<6]0NY8W]?;U'TN!/P[_,8,6*'G[:%/"\MCP%OXHC`.PW6^'M<.KM[=LI +M>N1\N6?V:_T.HBH;`GYKJ;L,33:]'G$$L#5(,KL_XO1HB\Z>_OGQ?,WZ?[-\ +M_E/;;\X8]H6&UJ/Z/RA$+Q-)D%*V +ML&D(0(B"\D17L8@FI$':0.9B`9(`CT2_;29 +MT1/P1$>-.+T\+DN8I2+]6W$(O8P061>!(%W%]F3)XO3[IT0O;?L9#@I*XM +MDA\-A?61&X@]!NM5:##B>E+`X1FMP($H,(IOJE28+NVQG^IF?S!UX=S;UBUK +M+^`[GA_M.XE^._T#_?Q>]VUA!@?;Q[X@^)Y('1P6/84-VYU8.3DQ>[U'J +M'_K[^&E[CSCZ> +MT;.WFT^LI:V[".QP=EC;0N[INN$1./(W59'"1J-&#& +MT,:@PLF.)@[687%J[+Z.R/GR8\=I>_M=_)]UP@3XRAK"^F!K&^EXA/C$'1AQ +MZGXSCORV2(Q2;42V[8@2.A`Q'5W9O9=GTU^!=X[\L*<=N;PM`?$P8SJO^DLMO,L;J=J +MF!09?&Z^(MP+`<"WR!:S!ASIK"1G>PBM(,=B]#!6[K-K/:_00`V8&<"W'^5P +M+`,_E#H#<6HVL2+^U+-_C_9WO[5O>T>SV@AW/>YF/!CT5H+F*,/5EOOZQ>P?77NOB(0.Q*X?++F=6;#\75V\-UUSQD?\W^URP.>SI +MPY:R/*^Q)'6P11@MGNWRYU`!L$Z7B/[CRU\^..()[Q#KQ#92^IK##R5T\W'5 +M(M#5TAY3"(2Q=<),:H31O.Z[1B%UWQAU#;X9M<\F'?C;7S86'W&UK.0\%9/1 +MR;6)Q9NHHY#M>EU-G9.\-F,M>MIMQOT[6>?&D@9*BD4@HL%@BA>LT$:C0KRR +M\.?7K%W@,8-C2Z:V(\JY/G;D--#8:8)UMS)U&9*V8O7DZU<7#!+R<]41C94( +MC*1@LBD6"R45->;GO;LVZ;';^DE6L;T,,CZ=389UX:UAR;6'(!%HU3"%++'. +MG0^[8\=$DHE3W^H[",(TYB@P;=3+(ZR!41 +M&L)6W,L4;9,9W9-2:I&R6=,$W,P90JPL4ABA809LAEL-ED1"_8RAA+ZZWM:S +M!I8MF;QFY&"5_(%:]D3()@O!?#;`BF<>UA'$41BK&KLK2?+%HVRD*(*J&BTD +MOV2ODB""R"P-1@#P#:8"!J8$X49DFTMC)7$QUC!(D +M52JD$&1IH"B4#`?9GQ>Q^CW-FSV?6]=S_L[P].*@Y@3;&H'.7RZ/E85IP"D0 +M4WJY($RI1,*@0XM`3K];W-NLB'96N)7KKEYPQSIL8Q08MW=N75S:[-;;$6UBS$VQK\;*^4B&UY?3K\7D^SD$DVA-@)_FRL$/ +M8BA2VE18VX[;2RUC9&3:`86#R*[/!JK+C^B\73IRX\?`_(W[#L/P#]BT+^<= +M_/:B]R#^IS)NV'//KP&JU:5,&;.#9.EMVF +MK&@X(P^*=0[.NP_>/KQ +M=NBM,W-]-.BF2'1M^U(:CR0QMR^4U+M+XVP%]LW%_C?]W`HYUG+-2W,0-<&R +M&*[$KN@JBZ8VF91:8HUIH9,UZX+7B_4T9.YC?ECQXG5MRL>T9X&*P>ROWY]U +M%=#'ABHCYY@T.]#*[O>4"!_T2(;]#\F,_YS71:F#K,IJ+'N_(P(BF_!;_+)? +MVE"C3&D4"F1/8RM1``&>KZ/D/ZKRM5[FEHVKKSB_=\S82*)$PZN=0I#\F.`) +M?*M4.*=HV^$<7Y/6]#R'CPK%>1E=7NTC%-J_?QVS/.^3Q]3?J_]5VN%BV_,%!,I=A"$# +M!D`*06:4'X-16]SB>,,'U\-?,_[GRO:SS?(N^/\:Z;#A.`X3HJGK;*I55L&5 +MY\]C6.JN>\M``U.H&#NJ(.KE2HE64)!HK\'>?G\F]V/9>M=_>N=Y_"_=[WVR +M_?%[?S_A=IUW2^G[O[/*?*\CS?(%''/!SR +M,"05#FXK"`$DD(V&4A6MJREK6(DQ9*33-OP3H-+6VVB0@Q1,#&QB:5:HM636 +MH@@2MPJHB(E0/H;Z3:Z[;W]'@?*S2\OI]592<1<<*?'O/0;4TL!U/]YO^/)E +M2\!;,OS;]=5"(E^*7+HEJM/F(6]5'MJGQ*>O(SD"W/((@NFF!840(#51\1$' +M%'-H[Q9%71[#IN/N9K:PAQD3;0/#S"$A(Z/L90N9!_UBMHWA!D7X4!/Y9?ML +M*[&%X`8H(1C"(LBJW6(9-U_?];==G_AF:WJ/'^TS>SW?/8FY3&,-@&!F`;U_ +MH0\NF`_FXP%3D.0F$_-CY0Z_XU[/1NXO_?ZY/C]5_F^W;`(H!YN2`H$82`)( +MASD7/VDTB=<6-K8/L^UY3G??R.?Z;Z-%^/WY_@MG6WO-W_RJKP>_N='1U13= +M34)X+OHQ&N\G&_I^/)>#W&_=#^5KZ$L3];2;GHO@_/$=WO^Q_7SZ7<>AU7ISZ&\/1UL#-2O="I:-,#,[JXX'C<]V$=1X7\[;RL]X79V7>/^G +M/O^.[2H\%PF[DHK?B:R_JBO]@NFU"^_FN2]/Y+(]ET +M+)6UY!@]#SGOG=OCPT7N<*L?R7C#>0/=%11NFKW$-8M;Z6-&ELV>E60`-VF]C-`4K#SNLF-@AFL^W\<)?L0,G^#XBOI681 +MT0_[DG-R9695]@QOU#DF:G';%X>Y[?X;&MKM(X?4V_-^.?&+Y,77E00TYZK: +MPV.0Z;QA!-&`(03#FYGUU:>HA!!!)(*02,=NWI,R\X?'P6)OKR1?^=5!YVKSTOVN>V?V1?(ZWFYN?>FQ/S?:G<>!!C +M7HWUX_S-RQG?=[A_PAI;]0Z.5.LVO96'D^#\?!Q492B)F$/G,"M\)448/@]& +M!R6/OC$[$C!E$2@4_D_P8SW/U:GBH+SJIPTCHNCL\UD><6\;S2@H@2*R^MSA +M%A7<^&=U?K3M.FD2;]`/@W^1?1BLK5/Z?:R$8*G-+PV33F@`$]*J7B'LDRH( +MC:.9SO\[]^WS[+L9H``0!/,!N2:)1(E0HA4IA46\\GE8'_W +MC>'^=B]GF^C_XGC;NY9[*1XI!QF6PU9W'R_`?L9\EU7",CZG;WFJ[E=ZDTZ7 +MVEP$$5'`G0K*G0S)/B=W]\?72QS>F=4; +MG\VU?L8H:B9\$R51=*@?I-KFNB,57/259!TZPHU44$V.:R.LLJ$FO^SXMJ_G +MM]9Z[?V7T8'7P5NC/*W/N]U#\'K5NP\?S&^)#\[TY5Z=2:N8S30!L:T[1K(5 +MGTY,\L,,IQA5M&:Z.KM)-6Z@\^OWK$VG^;XO/4MV]5YS#?@]^/2%1S?\$"GF +MMF[F;SX:WA?9]OY"ODWLNV>!2P`8J%+[VZ@S+";*B),^0M`/B1WWWJ&V-C(? +MQP0&"GZH!BGUHGZ(Z<#LXOV(JF$<(O6QM)`?HP%J/510U/8%'>.T*P3MO9UM +MN0T=3W-]0X3\%K.5_Q7ZSX13US[?$\RP#?N\G,&SSF5VK0.,.6(M<=?FX->X +M>2JXC8,``OQ0?=AMJRM32E!7HG`,ZS@7!X5:J*@\"?0(B.DV"HPIF3`".GIJ +M!:7S:Q;/;5T,;1];[.K8Y0./W/@V>=A=)%X?J?@6/I$-G\[0LMA3\1/]:?Z6 +M3'S=!^@_\03W>RN8%:9^X9OA'V;90`)9YHI.('IT!=S1!:-^7R.9:P_T0%M54%"**B,C4D7C# +MJ](VC&>)O5'7N".UL#"1Q1:>HK^F8W6OL&1+3QA7GE4N*GOJ+"QK,AV38BXA +MQ%UX_4U;<]]\<`X@]>]>B&$01Q[N=9)?_:#(W3]G=[PVPJMG5J\20*T[E77)W"\'> +MM=T4GOL]X.D5Z8MYWA?99C_X'+[/IE[R9%!&"A]$!4E%A$5IL1B?X&E"4:K5=/@*F_^MKN#\J[6F@7B- +MQ['=)439VIZ7CK7!)M20'AL*?6WE`=U$][`MXNA-QDH/(:S**MKNA,.(_R?P +MK[WXIG%)(:"2PV0?+.!,#W?H7KQAN?]K4ZJ!_ +M9-!^.I=E^-4156_LE!O\G>F_-^G493AN.^/ +M2]AJ/ODMD#*Z?A>)GN-&V7;A?L8X^1,WWZP[^>G`#\^`I:*(B?Y>:],>GN#M +M(BJ'=9?WL\ORG@98-Q5K1_KH+IC=1?(?M=F7-SJQR=982^;;O&1)!)'$54*. +M,"HL`HB:/5USGNNO_9_KVN[;'LO=>ZK4?US[VK^^6+]-D3H""27;S +MR\5_8<9>C[F&[P#J.]@54MU%6=R7*_55Y/#+,MY*#`8]6@_`EM8LLK\$)!*(A(0;"MM(84';\KO'6-%K77C(/EP2%> +M<\GMG#Q?D9B**5$%ZC:"0?Q%S5DR0`5GPL[[C=:]H_YYX]EC;>XF#*36D1"@ +M05665!K0+ZH83^/N/>Y>G;%LR"\E'-J&(P?V\H8/B^I=TU>JWWOOU1QULOO@:C2ZWN?([;NLE]F@J,`ZD_[N2GTIP*@=P0HO6A_ +M^G<9U."@[_U[1F%Z^XU\OU:2OBY%'>PUFU6AM?TY!E3QWK_GF?ZD1;R?3VVW +M\*3ZG&>C_$V1P)%'*"%UPUA&BW^M@Y6QO;/V\W;>]YNY]3S7Z;Z?%BO^<7Q=]HUNOPW2=_A.3V?R48Z2H8P8 +MV)V[!47H573<5TNQ[K\NOH/7V1D^JD=MTVG9/HC*;?:@QUGBK_PPFI*:\76) +MCB.3]9YGK;=;E\N_0=1T>JS4Z7-CU>OJ1/;AD+`7VOM#1C^(P+UY]S!8)Z&U +M^EG_PZW#W;6-X*&=%/GM]- +MRH;##R6@;L1I:?5]MVN$^1G=<#S,J,39@W9D]P5RN'IT>0R7'73-?GC(9`,A +M0I).+\2Z;C=]WV\':'S+E_]_6305/4O_D)HSZ!GSVO$^CV5GFIFA$8')EDE5)-!/<+&#&LS_D.NW,YWH_B[/POHW.__KEXKZL[ +M=<_9X4'?>\%D/?XJ4M$^9%:@>0JF09)`)*2H-&C8-BO@MS1MDK1;^+;EJC:# +M;\@YLE'W?<;11LE)JBWWJVW+9-HTE^16Y:+18U&VQH@MC\>MN80+?<+:Y1;[ +M3NU!6-43[EVQH36C7[,JY5%16C1:-8,5%%I(VL8HL;;&U&VBH+8U$5@-1C:P +M:+25&HVL!45%HB-)BT6HQ4141:DVP46DT6(F4$:*M&HQJ_L.[6C&J*LFQ1BB +MUBQC:U_/K;FQJ+46T62-8T)DV(BU[[M16-016C$8U&^RN:*B$L&U%15&T;_N +M;?BOY7MJOK?3[;6^#;%DJDQL;%1MC6C5%BL48UL;;&QM4;O.M;Q8MHTE&QL1 +M6WVS7;$!C?_D:47FO@Q_UZD"VZ;`9.$_[`IJL9;?YX%6^.X(%N\)XCD`-._` +M)M&-S$=1G-V[WIL4O([&5N#Y7D9;2MHRJ"(9[1<-1`BF=Q8S"(!E>%W7$>3> +M.(QN5N6L>\;8(`!N("S\/VJQ.YC.QQI8" +M8I\[#,8)1Q)T;5O/[X#Y^+_;VY0`[;?+EV<7VY.6+5";(Q139%FE&264RF*: +M0"11FDTRB408"5(9H2F+-&"T"(`R0$(44HIB"!,!--46FJ!9M9F&YWK?5Y1D +M'R7ZK^CGK>.7`%M&="P!H*;KAKPS56O4_^;]OY]GSFB^EZ1*$P$E@!+#02EY +M/EYYMJ]O\7197THX-TZ)1Y-X7PZI9,_T5`96++&N#U(8+3@53N38E,U%^4/$ +M,NO.;!KL=A6)>G_'_\W@V45'_,@A.L+WBV,+X=WW0+: +M$-/440$(WBB/\($)0EI"'AE'?G(WI1IWUL2.U8.*T+0'&,`.[YC-X4.(#N +M14*[C&;AB@0EQLD)_]"\&_']JLF*.N*0AA%3VO0N?HJO'CF+]1^UY4:4&W7*.R+KY[T_<_BS9_PM[NC"O@S +M';#'9/^*$SZO"P$_G1=+VJ.,YO.M^;O,18Q1]=5))S,#I.K[.V=M,BXRXD>E +MA4]W<5PT*"-TYK'=8[C<4FF3F('OYYN8H^<9,T-CZ"JM/*8=A#&DG%86_$Q\ +M?OX/NGZ%/V'5_Y.&PF$65@L9X%?JWAA^ZR89W4#CU_L)8*?$2B?3F*,Z^D/, +M]+1\:7F)*RHLC:J)%JP4'Y8'(A^XG\]S0^3I*1_9Q7Q4/\;D_P4F2#])^I06 +M&5N%VQRI2]&>^%^O=.Z8FHL?M?1O.EK)WGD;F[8%-+&H\=X*1`I2%)550)2+ +M^6[4_G)DPR:8[J^R0N8^OOC:]4]<\GD53RN/JF#?\DQDDIU\I=29Y&Y\6^(' +MW(![A"!\N.3JL[Y'O."69$1\-RH@H$-.2N2WZ9,#P;>E"\:J*+$AXIQ9RA2I +M$%)CQP0($-W^5G7?](00E``P?G_=[SFUI/:_,;U_OTNDF;>[?U^H\/D^Z^/V +M7QPN,5($ZVM'M!NWEWE]=F4'\WKC\:+^)_S<3%-`?RUVZ8!`$``:GDZ_A?;A=\(IE+H4 +M$!3$Z!]]HR!S.+RG>:WY.%N_;]AK-5MM!=-W6&?-GB]L68HN"P&X*]A_\O;> +M/P#$S]ING!?WJ(?7R+L%?(*F0"9]8L_C>+XO<\-JO'VW[P[);UCN5PSTXL,P +MDF0VS_KPI;W1VZ_[VWN2/[/:%[L5JC3;+UU/ULY?&0#R_29=N4X;>Y,&1"2M +M];;URID)&[V+HNJ]@Y?@AU'!/#DX40O,PHRZC()E+!?W7\/V;%ZVHAJM__ZP +M53E=&:ES4\(?Z20&5:G%;#^=3+W;A^661(*`V'O,D!&ILZ+;8B][#M_GP'=9 +MC=9_L^#757Q3HDLBG(`P#N$,XSQX;R@,'(RA;$7&&U.;K/ZZ:)9RZVY+*C9Z#1";[GGWW_/ +M#WCZM>1?\_'!6]Y?F8"+D^8UU$.YSU(!-,C+`_`.P!'0.:,1VF#!))))!)(M +MPVZ@/5]!O$GF_:U?5]#[/JQPI+RX_WKGI+XNW'U31/"!``8'7.^_J_6MV3T`X(J4&])4 +M3&!LA@B#CZC/@Z!H/-1H3L$HZ=A@)Z5))!&"B(LC"1_7%)!%DH@#41)$6^!Z +M'T?`W7'^^GZ;\.CSV+$'479W,=I_?AHP'1@,@LBJ0@C)4E=6U%L58),5&QBV +M*D$9"1$R8M6SQVNZ`Z!X>00T00F@"8IM&0#0T4T\IZ-%/ +MR)ZGJ;4\4]`T&TDT]`:*>4\DT_1/5-&U/3U-&IZGJ/(]4>49J>38J:>:93)Z +MF1/4QY%#VA3R,H]I1^HAIZGZ4]3RF!J>*'ZI^J#00!`$"::GD$31Y(GJ:8-" +M>0AFIZ:FCTGE&FU&@`-`&F@&@``:`:#3)H&31B&@#0```:#0``!H-`U/0*C$ +M)JF3VJ;R"FU/4-!H-#U'J:`&@`!D`9/4'J:&@TT`-``T!H::`!D`!H#U``#0 +M9``:#0```"4]*4A3U-,F@:``&@&@`T-`]0```/4```T`#0`T&@`&0:'J```` +M```&@```#0`(`T!H`````-````````T````#0```T`````````-````,@``D +M2)D)D1DCRA,CU&:DVF4:#3U&C0#30T>DTT!A'J:``:&C0!H````TT``````` +M`:``````2(IA9+786M6+A+`,6XY.Q"S*;@QTUX5+7*EU:[L7"T_+^Q' +M5,"J->&RER$$"0",A[1.LF]4'NYV'`Q7D!TT$HHMWNK_LX"..7ZJF*,C@TK^ +ML(A,#Y5:P-M7"\(MBF2WU/?P!DB0"23*2BB(@(*@@*#2+2-"E(TJM-`BM`JB +MTJ#0(BJJ*&9F1F%`B+^-G(DXLC%2R8R>0[_OCNYLH9``!>`1$";Q/N($6(6H +MY'UE!9&'\/_"N4,RFQR::PQ?^_K5/[X:9#;7FW'@49^#VZ? +MU_T,M..EJMPG\>O>)'P7/`NLUQ>@-W$T)\1$6O5DK!6?93IV@IPMIR=3I.3N.ELC3)'M\HD. +MFHUM%^9ZA6:2WVQRZ^V@Q=K4B]5I-#ZWJ:&YYH`B*O54\E;;5>U5!F-G=Z-: +MMT\$#NQ-$&/=-HK-14;UZY<:S5#]E4M$-BIX:(*I-8FV-!G&)ZW##J)GZG4) +M!JMG3'M]&='W5Q=DW-3*6N$ZV(G67#Z5BMO757[TS24!#9_S4,OD*60[1RQU +MHD`1KME+B5]C=.L:M^QRK.H_[.6,*0N[SMO+T:S'=`B`XY47ARA+%`W>8+!V +M0NA)0H*+<2U&Y1[5Q:;C;A)7)"D!IQ-0E71>1D&>?](D!MC[DT<`:;+=N@M, +M;,AAHZ$V@B]K.L5^]W<#N>Z@0#^I?CEOY<_1',8%DY6V``AVEYD" +M(D&"(";HDJ[;T5C?,('I;K2!(T?,0$G>HVM0^7HAS)1D*@G=GK3??K\ +M[@Y_&8%_\!!LQTS!$9D1E.\EAUJ1XGU9"QLN[;^(X<9+ABP<90A!C):J8^`H +M!?^D"WK6O?4!@&7CJ"`_,+WZ-PJ4N/-Y0/,^Y]CMU[7_EH&2A0 +M#_-UYN&T\<&9\V?GTY5WAT_$_G-\WSU1/5G52J'+&0[\@*;89D\`P:7TH@-- +M-9LIJ^O9AB@9`3.*?W7-F+CTZ?)-ZOU\3H3B_5E +M/^5D).';76]PO]_UNZ7C>1T9;^$]371WYS%,-O+0Z1PD4&3V='4A2TB0_2V0 +MN5I*59/6&N+Z($:_+F>[W-QR]V;I9\2[H=/)L[DT<)5#W=8#C7RQ[)W]_J6Z +M0L!_$DO%ULX\-J`8B]YR@X?F1&%'+];6>ZM2]?`&]PM=/`MV0:0T9S[:DE*' +M7?YU#KN&Q'#7]#'";*?-T#/TD<4Q/&U:Q\&.@B6!T/<0'QAUC(!9!\6`C@:Y +M,'?K<-_0XRB@L:6]P8LYF;7CIH)>EI7;O+(C4EX8`Z1D`.)\36$U?]2/"S-. +MP324)T%:L*,;0P@R_[5)"1B("4[^A+1\.+SFF0'>@137VA8&*`1&S0TVUM_+G0SX+3@:*^2JX?8.B7(,/YZVLX?RVC-7WD5$ZTF;&R[_ +M:*B'U:5$729V$.FU[K,\1KH.1E>'9N&:CT>PGOV@AME"?FNTO'G$3C$;KEL]=9Y3`"Q$'[T`'J=XWC-^RL,WZ&S;H_D&!!K8R+1*]ME65OF22)2PB3&ILB<+"E]NNY-MP\ +M24*&$"\7$/7PE9.;AKI^SQ)X."F[OW"N*?/8X)EO.S0"1D7`/H.SY0FWTT*\ +MT50*<`&3#<73(O>-1D).'&XT-&O4..(2O.)0ET_',,TK!J386J@@O?65E`V\ +M((P7>D2@`:N"PQ8*K!\YS$V-C(PA8!5&T.&WT,%[;TXG)PVMH#0T<3:1WM:Y +M0@9IH0;-#8_*N+I&;.H(XCG:++*A%M&P>KV-DHZG+\]#?:@QY.9"&8*N)-#` +M/A%`-&_R_!D.(YHR%U42NG$CJFO9I2]O3XDQ>.:RT`A/.U#WBQ=NC<^4:"A= +M2G-]E#,'F)23>W_'2UE_QM!K(S+7S)*4(8%5KV`3L#_W#OI8#AA(0+V&%1@% +M4)2"A5DHTE<<&8BEB9F'*.ER*+S^^!AQL4N8V\;3"5PQ%DMJP,M`IK4!\"T4 +MIMW$;II7,2:8P8-OEK\EP;/<(1R/(1CCD$-3TUK\Z#&#%-&!H<^,4N;AM@E& +M>6Y9CUK:OO9'BM17[BJ'AFE,K98+)-W6[@PG0AGSXS!ZPLSF>45(0\,PAG._ +M1.4J#("JS;!G+:BRGMM4/Q<@)@XF1:9E#!XTQ$BQ$(#"**(">1"C4GF)%-*A +MLE7/ANEOK:H+MLMS-H--E]\;$YJ4.$TC+CJDV/-;A*9K5FXAED$G)XRSF>8: +M^C7=N#0V"5H#8$3`L9O#0#,BJB!*5,&-CF_JL +MMH1QZ#$#*")9?&MN5X#.E,$$;AKDT8V!%+L,65V*+"MDBYZG<\Y%)9]W6S%; +M_BCX7C#@L2038(U!^4A!S32-IH6I6=/J/FXJ*(QE^'_DT9#JT-BWS&P445HR +M25@A&;!::P&9-[[9EIVJ20Q(GBJI3PEJU&VT,+,TFE\J)"3SJY"AH&R]70!@ +M#$BT\_VDXD^'OC".D@PS([;I8]Z2:4!;KLE6:"@V#;?-J]W=LRE;LA4=O'A? +M9A&`P#*8+$'.48U$08TVFB/,U45F`**Q8-$O>+_HZ.&N"EC2+490RM) +M)L$-[PW.>KS1NJ[#2K0#8X4RQ9_W2"C3PVV)F\WPUQL)=R$`.P8FID'+JPGK8DJ&X(9R4X/8*\.`N+,S:>:DE>;;+<8%P&)>K6=,1#L9 +M$.DB_F)J\&)765DKFH1"-4+80B+9(A$EH:HWHU>:!EWMW7$T&2^'N8>S6)C@`4&9PS\92RA`Z$FW6V5BD06 +M1*3"QA;$YCFQIMC181$`Y"(G0F6241!*1.PB4X"Q6--P,S#E-4-@VF37%A5Q +MN7T^%*BS3"1Y]=F+&X_/A*Z,*7PX"G.<60LC%]\7=T/2M>?KQP<4+2!T21IL +M:?&Q#'ULT--@%.+-[N^4@;ZBU#8YTR2`79.3OYE6"H2?!J0TK\#$Z-R!]Z\- +M%%F,ARZH0PUX0I3/C\51[)E40X3.1G+C,N!-V7"(S,X5M^2@6,38AZ1*]??E3)2(+(J6;!W>[)SJTWVI7#0LBR/%F +M$\,BG?=%C::R[4;V]\>;,L9%D-2@J%0L4())#EV106-PW]4W<4Q3;,U*`L1$ +MC(5`CGT655\.JM!M!NI",Y#(RRR(IDLYZX;VTM#M>24T)6*$!%`ZE"$\]PU@ +MA/:`5HXQU=JAI1>4#?(GV>9?EUTIJ:BZ;VK?0@G3`G15\">`Y7(VZ;PCU.@Q +M#SH2RP[5$5E1$6R@0@AV%!,*Y1$#A"!P(W-(WE,CM*D>OC0Z^(X]H5J%`UJN +M:O.!O:NQ'*>N062D)'-@L32(VE9(1,$(&*%3-.9D8"HCD^MO9E]2X`PZH8C@8:9(1F`22B2F#!$"(7J%LPPA@P+`9 +MN9Z&470-8C#(;$`QX-;IH;4]8SEVM+$(=F^PR3S7IW.XE8T!5>0%[9P=&:(( +M,A&O11.FX@4[R#/RJ'&L^A&@Y)C8T&W9%Y3/K]#B +M2[5XH;$"H=H%()HMB<8GDW"C!Z:VH1$1F(B!N)O+.XA--B8-@[%2Q5?3U@G` +M26D$DF5T&@#9,/.UN_QUD5A?PDSR#R>^I5-#DWXB,5\L$F:#9ZS-6ZC;H<#Z +M+AEL@8B#-['3#2(7F3H@8ZAL4UO:SR5B"]11DBPG5X"D31"PF8M\7+:+S2LW +MFL$:[C1;[X2N^:J8<4=2>1@D'^W.`40+$DH(^=8Q$CL`>WV%BBWU88P>M`:C_*Y!@."$AM0TI"04^ +MF@L8";24DE":2(!&Y8A*37M"<[%Z]'LPE`*275>#R4@\L/V*H(503$XJ&2UI +MEQOK22,U_8T"_;C=ZOOM@%7S$7\:<3$)\FH3PKE9*EU1MJ6B1OPJYH1#S,8@/8]YZ;6.'D;&@8+3ABY/F'$:NUAQ!:.P\":9 +M0".Z;A',LM-.LV,U:]D4`#-0!:47=W9DI"$7'.*Y&(+EQNZK8(F+X"."+,V( +M4%4DPMJ5>T[J[L[X\AVK*`A!)(G2NH:K>.)W`0'RB22&-IDO:+-LTIHKJDZ2 +M0T&5>LRN4)(!($:4(QHT4PZ4HE(H@B)0&-U7`M55MPXQM]SZ\']@AO=A+>)S +M)$3('-@&]1:"#!H6D1!1$%H5%1JJ*QF)TS#&'T+,LKN;EM,BZR:;'X64:6E?+"DA8"*-BT +M"J8!E=%**#-]+:H!AF*Z>*"%/C`G/'`MB^C:0KFC114NY1!*]KY0'1L7`,&' +M`PL0!F2'@4"+!E.IE$2`G_WD$:,`,@9F8W>^V=)\@G;<5C(:[D+![.F5TTD5 +M#<+9041F-FJT&U75&FN1TU196A%T\;HY&)T#]XP/CH/,S5;-4<>97/W9P:FU8*Z448<-FZ^DV^U,"X.8.AP<*,06%C6FR +MV`M,M60#E46C"VYLKZ-')9GXTR9S'/\=KL\J^8]O-:LMMXZ^CY+(U +MA\L^9>(B0K9+^^5J52;!_5*'6.95CGY0;J_#/-5MH>F>*)>;-:30++3H3(/G +M^2,OVZS((AP2(&M4,$T[<=BP6:5C*O*XZ(U2HDH&H(,9(0(+(,E$I08Q%J4B +M1A$/*^#-KN2]+;9%Q02['JY[,N9Q#T@^,B"MKI$?#H*J#:$0"3(B_E.-K',^H>.I?7T3LE&= +MAY6T4D'(:8^7=?7_<"!"UYY,N-:5YL.UK';)LA[)K@/D[5>DA39Z*DM/.\M( +MCP/<2[?<@'172;O\%SKD:8B*5RN1YZ=]Z>]J%!]1N:86EL$>L?""B&1Y;??$ +M1#Q8OPJS'!FKK$72:[U$:6%N38M[R6T9L_-\?S]GKCP'*"/(M^Z'HE>*F.:1 +6"B*@22E%*JXT83_Q=R13A0D'@N8^0&T9 +` +end diff --git a/contrib/bzip2/sample2.ref.gz.uu b/contrib/bzip2/sample2.ref.gz.uu new file mode 100644 index 000000000000..10291f930611 --- /dev/null +++ b/contrib/bzip2/sample2.ref.gz.uu @@ -0,0 +1,1933 @@ +begin 644 sample2.ref.gz +M'XL("/B]F#4"`W-A;7!L93(NX1)(!DVDX@UW=4SY717#5W=F4P@""XL2L8T!?44&2#L/(`@"(*, +M+`HJH.S*PR(*@H`R@DL0?%#@/"?-_W?OP4DNZN6W,V7#%A^/@WYLO^.I[&VKYE_);)CWP +M/TNO&+-#H3!F(CPR+E?J7-O2>L^*2MG+57PW#..&0J'-=XK]H1?6&I9>ZY6Y?V:MX?A<^6.EVHW*UZ(91 +M4(CP+PO6U#[:_1*G6'4J7N!'';4/KRO`2&$A*)?<P +M?I@1G"9,V;+#WWK:%H_91JQ]`JP]A&.??G=;9U@I.[G* +MP`V[G','_W3'X(YO/T0_Q?]G8/6SACJZO3"VB_?U.KT;VQZ"%?66W=#U-]XW +M"S8;CSGOAEZ7CTMRHE"14N00'='OO::!:[85TRDY9:_8'V>JYWO^)AC#! +MZ>AV8^NTE]4[NUS?+3M`KC"[BN,5X14N4.,9946-%:3$)C$64V1LOS+5\_'/ +M_).PZE6OMA?^VCV3=F: +MW?&;/M@M-W*`9CP7""GJ"BYN>RB(\H/PV][(+=.\@=*2X.+[9JV!#Q(G@35V +MP0<%,7;9=6!#*UXNMM\]$S8'=QNH-,S6,LT/PPZ'WCK8L6HO'0?,-:B&,,.H +M".N`;1YW_]O'P:K=&&-#NF^'!A'KAO%RB-'C(J=";%9G`#\+J#GA#DTJQ +M/SJMZN62'C%8)8CMEZ[MW`0TCZ.4`WFF//O>)/!HD5%?MUM&VL@%9?@0J`Y_ +MXN'>XM>PDV)`7`SN7[$8VY,[Q$IH#DZTQB-"@[?@)0N`20`E-0]LWOZRO>C9 +M9=5RG/GZ6:-=+V"1N#K'\_$ZEETW*CFU,5\?^`H0K>?[0<)TCP.&S6(J"[UR +M6%&T]7;4!R3C#MH/[N>6>HM!U`^D4_+6NOD$CK@/#C6?`!TDG4XNZJ&_A@F] +M7NX[7%P@H>+V?=U>#D;J'LQ,_1K`!Q,7 +M:-5//#B!;E==;:0@)*Q[%@)9=GM=L,514,[#OPM5/\=KJ8V;M(`EA%K)ZQ;? +MDC`HXA71(\*`U2()*ON9N\MNK@I\>`T>1I0/2K!UD7L:\P4@_Q#/#UA9T-M- +MEP782%[2A%LNQ=9>MY6EW(O"?F#@I6QL+2WBZN'MW5E@9?BC@E.&/Z$LBGK@ +M&/JR-?A1-WSB='I%>-H-Y3UR@/7,.K,3V6L_C``KPDNTQH/[%_&KW*@3^$)> +M+`QD)[(BP;\CW#M]*^')"BTEMAX>R].#OG0?.^T*G">;MP. +MY+)R-X$EE-U\;'_U2@>.`I@EBP:4"#1;8@=!$D3NVM[$]255&1+#X$]20E@/ +MA/+ZX]&,>1)E+#."7J\"TY&']*OQ0(PY5QQ.6`7FK[=+#$IDT^TPTX_M5S\% +M[RR[19CG&CQ@.(S0@UN-2I&3].-%W>5,)%48*JQV=8$4(#'NP8EVJ@M-A(4G +M18OL=F!12([(;:K%/)X*T,@:D`OYJ,]#05&)2C"#:B[JKL%3@GXB6H?)QGPW +M'K?GJX+*Z.+!'TJP\?+R1#`O!U_NECTD>-8%0DE`>3?GY-VI89S9_!TGSYP- +M-HCN`SR71YIVB'[PKA0J"2P:11)I+E)>2:$#8G;FU2048$(LF]P2RXJFHNOD +MA:2&$UJ_BDXHA,D%R)^+?%&":E=W(J?628([L]MS4A_R#7G7AV^1&@OPG`AO +M`@P"ZD]6/`]3CJV3CB\Y/4+$A%(S`'*$PR2.@0RE`-N!_V5)$7H@.(!4UB]W +MB?2D'@$4GXG_@ML'E(G+]V$\E/'%`!;8A^\`IMSG1T6\#N)%`6]46EATX%3B +M3/;77A[6`_13O@/("\D.A1V<$>S]8M?':]4??2Y"'<&IP/F%,.#*#8N/FS5] +MH+;+NO=79P=PM,WC?SSF_#%C0-$_]:,K-D^8<3`HJ[5M#^S<_.]_E;=L=^N+ +MT_TQ#:AYL_8=]L^\$[3TV@ZG7+9EW//1%L3#@JZF,IY05-GX\*O]<#M#MX(\&Q3&,QZ@\^SS0+5`6IZX +MEI8QL'D":*EP=4`7M&Y[>`T\APH[LB9!LJ@$'[J76P::WKO0/3`@%>T+Q_P# +M>$]O$:]A?P0,PWK[FTZ48V("?3$J!T57ZK;+EZR85[/>/AU8?!(4J[C9<(#O +M+D:B%0R(+C6<):G--+A0CD"]?&);T-!`A@FEI1,X`XXJ^0*\3!`:,5\\V:2* +M%YN&\9F_X-5>N>&XQ7`Z,P9J!_S@GZOAJ(Z#NS*K=:"VZ[D/K6X>N`$O+3US +M$MYBT*]O^(U6[;*#UOU?A/6P>IU-Z@T!(M)1U!4Y#SBE.'/12UHG`KIZYR=Y +M5%#QN@!/$6*_J5Y(X"Z!>J]6Y++&%=MK_CF:BL^J??1Q>KT +M<&TAZD/8J+G5\F&'#@SN-O#J:O[;K):!9#4H)*^&Q[$]0.,5/3@!IPR;/?-; +MXA*6/<%@PKJ3!AT(6&O9Z2("S:R?1$HSS,]=ZR#WSLI!RU7?I^5NV`VV7XB1 +M?*0W$AF/$ZVH^M$*6$JNJ64Z*$8W;>-$A[0<1JJ\'$E026RO/[D/[ZPZ)+K1 +M!Q\#W)"421`.M",@,>#_/?)7[EJU?9)K`5-=/DG)!Y*$ +M2GGN2T@>@9"LEIMKXY_^[S84HKZ#IG8TL4QR@\\6-['$M.OPC(82&I%7:C)VCL4M#!A5FD'UH(_)4K9.'JLL9:?< +M56795&#Y#">,/Z`;,IK`$79&TFU>$_NJT_!VR15LDBL@;NZB:@!:5TJA2:0Z +M`X^KD11[B*V7K"(8AE6G"\VZS+8GM-6LW[VCK08P`D!-98T$[)>"*^0POD+M +M`5[FV#[V8?P"3B]/+%)).-J``#<4;4Z@%5)B@7J^>"U<5]3]0.[Z`(2RRX,GO%5<3ISN.%!JT[D8P:$%U*ZIT,>+,4;\CLIF8_\X:P"K^7RWMP+2+T*>"U[G83U-P2 +M9&],B8FRY]QRPK3?9%"PE!-/4LNAB'*-8 +M]+K0$AZT/UR$VD.0H+Z:T'C`P0[[.LXMP9Q#FM/Y.;BU,&%%8G#21:>LS.SNFTGW+/;#C-%(!AER +MLN6AK\T!I9^$-Y\!;E&N7,W#VI`K.88:@@_M^1/FA($?B)'$=L%)LF!,&8/` +MJPZZZSAA&)N")R@#3RB'V4'[DEZ8?+&*:ZK97VTH14"2Q4(V$:0!=EQ#A30_ +M(?"B59T.,C?X_10Y8F/H@K)S_[?@+BX&P5[;==\C^2ZNW+#"[4-]:?>#)JV> +M!B3XY.WX<:]A_.!S[G9!67M_0!QZR-U25"QW+A?;DZY2G+OD@DF1Y$G#<%"G +MJ.VVW0F@5F3VG'D*J6!\;0HNF#1Y.,,DK\@%U(MB@!PS&UM/#WJ50>LG;\$R +M2F&6K;_^)(_N0C=,X/+!0?3V@L*!IN?5[4H,T<52+)FT1&OPB';@6-$7`M\- +M6;%HF3%]^G32([1W3K#]Z'2^0"#EL0VC7U>G(I%"K!=[. +M=I@/[-F)T,71#^OLBP2=*;I1V[;H7*41PK%W?+J@5:5H2_M+URP=H]S8#>@V +MGS7<7G)ZHR$\L.'V0E#,EX>R9!M64>%QE*+@`"<_!XB]"_@3'FJ)";&,'\," +M/#^LD,4)6M$/QLUSB36KBW'_A?6T+(?-HT@";F_U/8[L+^>@[')\@>0]A6^&SDC1I/'4X<@-A#@?\L*UFE\8H^K-+N])\T0!#V1L*9P6P\*)' +MEJ6>8:YN/)C=MP]`F2_\I.@YZ/*]B3E'2D[4NXKD$0,**+CH^@0KETY8'5&U +MR$(-:`PGXI25D`6+!7@*_W,!!K:L,9_LG\^/"&QAA..#L_`/[!%JALN26737 +MLC5N>8WG]H%B\CBJ(Z"(+2R`T;%YY](>[!ZB0,$Y2X#@X=S0L!`\GGFV9,O$ +MA8BA@856$?$)4+A08Z<7Z'@&>L8F=YA>Y2QHM'!\L.L5E,+P_K*,<$1;EE8F +MGC_;),W.M;.&E[;YOC,D3"X<=(4K0@G11:W$54/FJB`2-Y*S*D=6GBLL#(_( +M\;\.6H*LLPS$5`4"EGX%A2WIN*(U2OK7J*N/-@`L# +M](A3ESZ%3ND8VOYA]IN&:6.*^'U`U%)F)XFRIK1M)IU,[.*^3OH8P+`]TW!I +M;JP3H71-\6J$]1H;Z\$Y<]@XXQXQ`^3MQ*EMM4S^-7YUV6,Z5K9\RB&M%6C0 +M07-ECVX1.06$2TP<22;[YB$X`DB':A=8@;7=MTQ=C4Z1)UE5T-Y$=NB1'SWJ +M!)6L!WU1^=!P]V0N?1D=[*3BY;5/$D;[\`$^;R0KKT0;J5Q8>(EIO";CA'&` +MV-[N8$-6[OZIN>@S[`7NCX]\I0I:J^N31V05OI9F,X4M8SE427B.BV\#O5:J +M9=\PO*5$0[,JRA511N>\"J@>/JIC`Y?I.^"%RET'I!O;#XT)T37:B7;`UBU[ +MX)];>HA^@;B!])#1F(?*7`7XMSFET`/E(N]4*/0(%Q>C4)*HU"UZ]Z&#S:AE +M=C!ST&?J?!>F1XL4ODCY^"4!D/D?VV<7B11)M`L5%?Y*@LH3IKVX4C+.D,@H +M@QA)Q1IP05JMU"I3G63%`YWLGL"3R +M#.:9L;-LPWTVG/O6NF^)*\'V&W%_#CP`]V<1B#H<FS&.'Z(A`11U!YLY0 +MC@G@^4YO6$7OH<&%!VMM)*:??I&9+^5,FCL +MM-$@K83#(0]\?M*C"S!DAL^@Q2"#-?PFR?5!V!/?MX_[#+G:@5;R:`KR419) +MDI&?)\;0T][P_68VR0*Y:'@!R_.;!AFDW+F6O,X@Z +M%QW),/EOGHT&9VP'.^DH4L3RMCE94<>GK0>"F:B;Y*IAB-[M8I%51'4[44=] +MG!V0\"W,OT@.^)ZH$Z3>]J`L5HPHGZ%\&??%"'O!Q?^^!SOWWBS!SJ-#0`FD +MEZ*[75*=AQK,>Q1(`',*UM>'IE>7BX:CY+G`QV+KZ`L=.7OAD"'91)QB:E@7 +M=@`FV;,O\B\BAJ(15D19`*R@4"V3:P2-$S!IF@B$HU'F01>Q2 +M`0I:9I%9I38O!,V^HF-K(Y`;@IE:/_J;&%$MRGKLZ=XR=3K=3HSGP^$TU\;]X";8:+@"H#HQ@6_B59.2E("Z+K46W`[S[;,]CFHRVE&^B*!M +M(M4*S&R08R'K#(J*[?&6'%+*1]P!W)O,&8\AG=*W>=@9WR'9*&8&'#,0CBI! +MR12/K4U8_@)>43%6CT\106!Y7SX%UDODPLI0E1T.AIWO%JMY=`Z&>^`5926G +M*%1[7X5"2;F(K6=VEA9_!;V!C_4[X_MZQX;0M\AQ6X4QH#IJN')%]IJ]G77"U//RRMS +MLI2@]<'&B`)$=7H^7_`?[8C&(WIH/'\(N?;>G4!Z55\H,<`HZEU-]",BK1+P +M*F8,!E0%[036IA->IN2T\V'FH-3&&>\1?MIUNLIHLX*-FI-!%4E$!$8#=G+? +MZR30",2C+K.X(*!G-XA8/GOZJUZQTH01<9CQ)N:$RM:&69^_BW)0PC4(DJ#H +M@C23E,+Z-<,?PFQL=WP#I8O?%68C!.[!%5WT>[IX58QTP#VY8]>V(N,0A)N_ +M1-(,[#F*39.+1(2/Z9K%UHL_`G%!8L+$5+*]S_($9OG'[86-C8('D5RP\(A8 +MAA&0#N+,['G,D@MNG@(]36B*!N5B7G-_>`GI%:!`DYN`7$CN6O3ZI]S33I&& +M\@AUXA30?44K2CV,O)%#I$9X^CA@=O`M"("N:70$Q+TK2GCCQP'Y>(GMTUEZ +MA*1P0&%R2J[0MU(QMRN75,K]`KP$?*LO%5_;J`!#0/,_7KJ8`+XU^Z<+M?:G +M8L!!%UM+L?W9WPH%B]$$9+X$^#&QR]FUS)ROF2:T!`,BC,F>]I'@MSIXU,LG +M3;'O3/4)7LDFUAQK$^:\W-$MHSX%)R=V!?$P%*%"5P7\.8BT4Y&=A;21UH,G +MYI`N$8%T#^C!.C-N_J\P?)H(O3PIH$ACJR#17E12N29WI!:?.D,5LE!:R[-3&>?6EZ"` +M0NGCKG7+.;`03.69G-MI!(5R:!(=QU;'5-+;!8*6`D2P/^M^P3=E:Q-"2N,X +MEZ-C8@B`MN[Y#2OC>+#B4H#E^>'?E_AY$),P].,;TN3@8%0!=KE:+LM09FI? +M_GAG6$)?F_)I"A*#S8TO!FH8A%_PU$#+ZP'9A9%*$,.@R4C#1X^(;XOMG^P. +M0_6Q9Q[Y0UZ&VS;^PO2/AOVSAH_;$=C9A6,GSGYEB`.6P)$V +M,H@ISLS95N#%21<&8Z(+(V/GO*?Q!K3%O81)(DK"@4!+EW#>V)[^JC9LM5Z1 +M`T78`\8&E`N<-MB;<%"*,G"0?#4'HN2W_<-+YX&Q!)*K8=G7T./G>W`0)CDI +MS9Z##:$

@]P'M*'-!(*+?<6G^>]M=Z^/(WE0331*F(8 +M*`1[R5NL_-Q)W9O49`CC^81I&05DCBJH(O"A^!8ST((#@GI01,^3'$5;`$US +M:_:=Z^>)IV/[SNM7;FC3/E,@RS'=;47<)S9[]1FH];%AE]GQ[R"2D7J":#0( +MIV*4=&QX%$T5?4CX=S2[ZHX8),@D`I\QX9DTUE;+M#^:=QE_D@?3O3_.+-U+ +MOPZ#KU'86_1$`H14Y^- +MQX7H`+61B%N5/V573ON10F,BX44>)"#,GS;C)I*L1HP#\CAI(-,XIH4\-X,[ +MA&`(3\0D4.7:R/#Q*+5D]GDA/QU]BZS'UE%D-[8>NP"U-?+2\4SI"-@9@,$C +M'=)%/Q8:GVJ-5=PGO!.QO>V07!R0V<3G",`):ZIXE6J%HQ0H/2O$Q.4O%>7Z +MR%!WFDVW"^PJ%QCISW=[MK'8I8:F#=?:O?B?$$G!+ +ML89(:[YRE*$2;0KH:M&?6;TBO=DCH7#SX\1">6_15X001D1ZP+Y4E;,0-UGQ +M&+1HOGJ'(ATT:4&,L4RGP`VB5(3R#9-\<^.20GV6A!PK!.4AMFIW$^$4)8.# +M:7UWHO8!$"D*ZT-QG5["@#/3$K@S:^]=M&\9O6A.&5.!A'W,WG`$#6B]HY.E +M5+_)L:[=6=D-]B-6E7T]119:['4D'!.)1AG^H.GWZ"U2!X9\@E,QMD;XRV%W +M-R$8&N3&^&80[2':L+#[:[QRX)?P&$(>/#3OI&)H:2846]XM2.E*"V$/&M+* +MJ[,8A,0&-$&/K`MLH0&:VVA;)\(/MD?QYK.T$GOGB,@LT$D^^D+0[8>@WS6% +MH'@7U2!%!W4R/(*\TU3T4.T>M,[?>>4&^/UA,P=JN_YT%DJ3:_XENK\P5OY'L$S4E\D0HJPWSXW()["4L +MOL&^1V5F"(>A?%^[5_3=_@J;S-ZN$=9@J:"WHP8\0>>7VH^#:;?&-(+@:BD\O8(R" +MS^@&*:WG"00/'[4+/'NGPRGC0TAB(G70GLHN.XSAT!"KA6[]S)[=RI1STD*^ +MZ(+%:N]35=%#Q,H;N9]\(MV.]VCQ1%S-5$;""J(HP#I"LLB1*YOCPA +M]V//R/YP*>X\(90P]*=``/DH3<^(2+I`Q%_4'44Q$F- +MY-8GXYI<.,*UX#E%`T+!(\69W==A]%%*E6F28(@ZP49MKHUO1&^JB/:!J!!0 +M4"^UG2DHOPOGAH&%+38/OX2931KOI@*_62>.I*S,8^_)+WQ +M!HLV3B>V[N[7047I?"/L'LE[>O()LFZ\/&5S"#/-@0*SK2A+UI&+` +M1C`T`X;"=#Y8/EQA:S-R69$5DV!.3"_"=CA@-6X5R<](73[@N&4D;0_U.1RH +MTDV0Y]C^U<6L&)AZ4CJ9T+A<)(N;Q!"L<8'2^>G=GB=7#Q%,YIRKE78=D?&. +M:&9MJL*5[Q)Z-JLG@JA4>%UH*+$ULTPQ/`S8YKWM7)GRR#D_.)0,1J@@5PV> +MR6$0&X3-4T\((*B.(Z!C6IW"4Q/1+W/3V>`/5]4V<29QP\)$F:*IA6$>/9&(FR-\/J>B^D7"8(%HAX,2E`NJAB1=9/8[MVL +M%L')UM5>.-)SRV'`@("1`2RY.D9/3.XPV5&1L0JD/_:(Q;*IQ.(XW:EAEG9H][8*OYOI%#ERA99'A"9@),)H +MLVO(7G0>(H>`"`UA`TSV]HEH4*&<&9E[HC:7!$R9*`Y8T+9=?2))IJ'Y1#:Q +M2!>G%2GH-0?<22&1.TP>C'-.WGKBBLYG(MA-'1!!G!&Z(3\SS**AM-X3V%FV +M-/A:E<@%`A?/Z:+S%90>B3@/2CO3LY&+P%D1N&JGDWEF6TO^*:&W/"I7B<&*_/$, +M>G-\KQ>A%SA(P[,[P+E^S)9F:^/./0/42+9IZ:MN8ICCH@HK2OO`%,_ +M[16#2_*3C4N0]8!LD`$L=-L_2FE`'$ND!'IVA4O9U=_W_1]]=%/AXN]]CSJ!1BXT`H-.;Y[>.HVG#*.!Y@RGRS@T +M4FO(F]Y+J-><4$WS[AJ4*L6@5R0WW2`Y.ZRC5:[C!$I/\(J#F:Z%E(H8J7(" +MF1\]B"DB*A^D#P@B$:I7!+PD*;@NI:S"#\/`F(KU_MU21Z64(Z]BN-M'`Q:@ +M914(W2!#NKA4O-"NP;BLZPN[!B<_0TZ>,,#??(*,&1DPJPAL*!]]-K:N^CKK +M@]D(\0K??`()=7;-_O7-=$[=3EX*E(LIZ6?0>C.3%Z(?M``PD\E:31`^G[!) +MF92<,N]M$=A.@J<+&IG!R.G+0>M[1\%V2G="!!1J/7CCHJ!`7H'WO7:WC)X* +MPM@D,B7$39`6Y$A=:#'T#=H_W@]W#?:\F*#+OYC'_P`32;H=3.9)D)F"$0KB3J@(ZD+R$02E'M>0VV/N?G<578Y.0["%#DXC1XA]Z +MJ>))'Y9`J:+:]4P?C#\(CR$D`UZ&9*>1A7AK02G:92I5Z&#H`8&5C#5VE=F8 +MS.SSILS,S[L38?XNI2<@J,(H"('$%B@T,CL;L%[!-AL$=JN5ZA5TU#[*/NKF +M&+Q=LX]]O/?BNR^1$.X(,=P#F[$0#SW3*@#M*V"]^%M\C^=CBG-_'9C=WONC +M.@`8AVA8PC*<'9%U$0@5-5#0][^:>P +M-$>Y/Q%.#E0_\W`"!&DB6DD(N"D2.6&[GKZ68GCPOP+E?VJ.'&?&!<-+):ZU +MEKD*5%*<@P2W1D-&M#,S]PO/+%W]<7]QAJKHT_+PO;E@POY0,XGM@;/&D)X#9>B +M86"@K@Z"V=:'+0^VD1!I"%V +MF>%]&UY*J6*,:M:12/1Y7O`+UF>&LA)A+7`M]"A*7!Z6PT6BG(/(>*7\662V +M;F389BHA5"&97188JB3$#6;4SW`X(97R2:Q%")%K#>5!S%?PND=.*:@J!'^] +M?D>63#>R).G"X!ATYN43'/:>7"X:68)@&'`<=9LR_=1BT3V$AF_N<[*-FE+,!0(I&R#O9#6ZZ=<\/M +ML&TG.L6A=,YXPU'WJYQQCT%LI+832!"]AEQEA8(D$AV)-Q>>ZPZB/H4)(:1M +M;/^V4<6;C=HZZ3(QOVUL28C4ZC)E +MT0+R?/1__T\A!";TO4>(ZVEJ9P0<[S_0OO+'<[!?A6A.U[ +M+XZ:FP$B`?-,I:)`,7X3K2,7AKQQN/V+T1`JX\+!/*/YD.86$\]D+#RVSMLS +MO7;!]'C6V4'KFB\2]@+S:]QL`K\"W013,Q3`+]\L)['`8<%N73V7L!_P`KH5 +MH`?*)$>!:U79"XG)CFKV-E46J$,:M85%:_P5C(!+(3,#WZ0KVF/RAJ#2";0+ +MJEKD%5AZRL'D`,!08^NCPU+P>W*_&6D5(OT,+N+D26UUNZ-3$1''O^Y1PD*C +MW3SJ]M0:CGU615ZX<`Q'#=%X'26_>X]J_2%D5M[#/C0T5SGID>I9)*8GEA8` +M.Y+@?NBL4'H5G./5#Z#]#OSOW-7,';M\4G)''+Q>N?W6/DM\D-M./IO0PVH? +M,1QN1Q](Z)QQ$/)IN":W7[^5-,70K'2!(XWM8%G'CZ*^V-#!'AP7RS>R["53 +MGZ/*LJ8:F]5&VBKY59P2A^0T(I7WG@AFG=<@+TI/J676'[@$+NG,"]E;#M:$/>M3>V+[C1>$>)N`3[PU0W;\F=%!4!@Y%L@+B'7@V +M+]ZGLO+$..ASX9I@/ZVA^35HW?IES,_D>D;O/W(2VCAPH*#@P1BB2`-]G81% +M@=L"V]M34#J9SPA'TMK,W?;P,_?#1^A +M+K#HKOE,%YB14@@V@4T#%EDYJ$^K9+.%ZR2UU>RC]V4I!^1U].=%BB/KVBH6 +M[J7C%D9RA;K?A+X`G>-]X6B2+D:C2F>)*81*<6;&+Q\95'_E.E1)C#)`@L[C +MS*S;==69LL:58OI-PBS>$=,SRY0:;#^MH\;6*W]*>7;KU+4\&1=S,>E2EABJ +M88DAF/=V5RF]E"X2*]VC/B^P6>3W4`<%UN2%8W=^_ZVY3LCFY,:[+^FGW.C4 +MN>#7L77M>

.3V8\.%2>B(6'/Z2/ +MNOX$NK%PSO7&1D#>5F#S43>6[3',HZCQI,5+%TZKV_Y6WOZE!J3+Q?NB[!#8 +MR-&/9)[@X;$U_QF=IVXF1HMR6\`X/3@<$S66N&SH*#9";XKMTEQ]P+-KF4?; +MA]L;X9!!6[X[AO].&\)PPN$BZ4Z%C;'<1)%=-WHW@G*8@DWO<0VG@+-7S9<> +M7U4]#4SE$*LEF\'%/?])D2B7M3"X8!+-+X7&@WN"*;R)$_,CCU,=P$"/W/SL +M6D/?1S![(JVU42M.?=QG?][FXT.I:=:Q_KJ`]@P1T,Y\LH#V$0]N/:!-CAFL +M'=OVG,A!X+*-*LM,.LXHGB/<9HA*3E.[V*Q<,3!J)V.ACM@^[?[7T)[!A +M=((89XC@5+#252>B%%W5%4B4)._[T!1@EF>?*/.]AMO72FG0SZ*@+@O,6#9F +MSO&U';3W_A&27F02WLQKT1/'A:6`"A*=A8-V2)K+)*JF0`5UF2JH&U\\42YX +MN/WT4[-('R>LG)Z=OCH;X7];Z+\MXN\M\/?U-7AF2#JYWU+I!`4#3\Z>!OC# +M;'91U4[=[^^XA_@\/O7%KE4'U?8ZY1NK\"]';O\)WZS"WQR$ +M?X'G>5;XEU+['6>(_YZJ"M92!"?.[+=*7A>B+*58<$4LA:[<&H.7V9_Y0?NS +M.Z)`%AKI4;7,,5L/1Q;2(GW(L%-YRY+T@E(9 +M]2Y!M>Q#_D+ZI-B].G=I+7-V&X?W#_D+S0J#$LS(15D4WN2JK@+-W\7V-S\- +M.TXN*8*2<*VK,-+9/DA"CH>%;&51$!#_/;>F*\/1\D5AN,D=71SD\&DZ(P6.4:1W<-R*FV$T!V77$,(2HS=^TND*+R&L",(R4:I[65Q_BG,)3"B=KGRZX:GSE3]@ +MXO$[H`Q*Y7:FIHEK5W,5(XVZCFGQ#MXM0PQ +M`%I#\.S+#5Y!*%L.O)JOZU`VJ1]?C(A#Q?;I,Q'"(@`AL`%+=UJ&G+S/P]H" +M]D4WPWB&*4`#U]UW=2-#N,Z?6S!B-31E1G.8J+OQR^8+NX88K_JI2M&G66VD +M3-G'-Q`K$`QH2"I`QLC$4>HF)K4J+.KRP_PH#!T_UB@TKK3C4(1=&2B1X3!* +MB5[.JIS<81(NII([0UFI]>7=7-%A)RQ<-_+7U0&D= +M*\"4.?[X@H-9J%\^7D@/`7&KDR"X0MDP`D36D]USJY4:/$RQ!ZI43D^0Y2BJ!D;6D-,\>E1KL.=]=B +M51*SIC!Y2?[R/RG]F:MJR*D!J]GFMO^L%:IX@M#H8_O:`X7U`2SFD?TPW<'M +M+3HYI6DZ((D0WRM'S`JYVXK.BU_^8RG-QZQ]NI&+IW.IOM[0K>:#)N.NL+9_ +MX5C;U&96.JM!`UFYFL)WS:4W2?%PHMD1?"&=T4.(C.Z84(>,5N)+V'>X"(EQ+Z@'$`68B>K4L!,QQ6#_ +MW?A`1O-;VK\Y +M'8;;>%\P0*&,P%/!X`.;:[5R$U)]I=_>`D(5I.IJ]#UF=OQIO;[!$`J!-MBZ +MFTLB4Y"4:,V(AW31'#Y]P71Z_X*6;+2@%;\7=O*"&>N'9H^>7X-V/=R1O7KG +M!_+BID09>TRB1AAD^M"TK>>LPM)HH$_?O&$641CXSJ)3GV(MI[7E5Z,GSW6+QZ9==$83`Y(-:/ +MAF_]^.%;'HI[S"Y4U4=J2)BJ6;!1:\ +MMB5I;FY.UOI`O"!9/WUS![MPS&\4M9M8H]A>-BA(VO1AB^M(Z6'F3@$?^E)6 +M*#I82]R,`W(IIL5IK^IP^]H6!)*HT)^A18[`1@@>99;E5UL$YW*2!:.UQIE= +MOHL#CF)ECQB)&Q2`@J?F*4<;S-P^CQ#%7UX78EDET/P^$'TL!.;&=;.)D>9U +M<#81/%L'`0A]T8NP`-#9+B-%'G\KY!?>R]3Y"U:48E+B2O$I8T*@=?D!*CD6 +M_9.P\9X6O:)HA"$A1Y2B9#[)M2BM2SM'U*(T3Q\X\#O[UA7OMNX81>A5&&PXX,B@['6)^FK`EBM*U`LU#003I>+I'96HI;@A +MJICU-M,J$PFW(K=^D:5CFT;G[9X?-TR=1O<*I@^2VHCTR_P7=H%?S.F#Z,2% +M)R1_<;'I"0-`5`A0]6R(QVWY(_W0J1C0(%D"3US`YMJ./\PN*6&-&W),R6$4 +M<&?<#<\XS"=QK$V&T;'2GT`DAX_@!E1^?G4[ND`'VP;NT-7Q]:MFX>\4*XM\+'-%"\=C/977-++PCEQ-;>[Z$ +M"TGS=;A@[3\E,(,P%PC'+F8H*1SNY2-+3DHM-[;?64PI[ILXR)QFLVKG,!!A +M^`,XK[./%G"4'&P)[->R]3E*ZA1[['JT3D&GV!/2_BJF +MI?<9].JIBPD$Y2\BO`]O) +MDFK,_G*DOZ_-X="@BKW+C:BK,[3KQKI-H1,E_U5?=U"4XS)]TJ%RJ7J"[6JL +M6U@9M`N/%"6?>H)S:\T"99*E(X` +M:NA%*TAO%3TJ*E(8HZ+'LT:ID.Z!M@HXF&Y7`:1RW?,FJXDTCYE""98(9-\>YG''KB9:Q`5WM=(5P46,,#*$E7Q5-YS;5#Q-SIN8&5^NY +M,SNZ56]0(6"4(:BB*F%LK?@U%Y11#A`#$T@./-B".M>A5NFTR4J58+^TP=RL +M)D5#39*&!N$GN4AOL6B]4OITK\J!D2II+O5W4-.IZ#^W<*'%3 +ME-EN+?REN&9<5T+VP1`E_G6U9YRV+L16C*V_;J.)2H7O:4L-T46UMTTPM91F +MZ+9*!]@/%@'VAD\68%]YT7\(L*<+LTZ\;&&$E/+:B[);5LWZRTJO$LGE$I7K +M/">JNZ*0L;QZ%62G]?_Q,7/]8ETTBMH(2JT6$]@^61C)\?!A*AM:A.^UVXM* +M<<;63_85A=TIYD#Z#0OGJ-/)PXD]]1[>8+Q-V82;EE*'R"])',CL@6LH+$E1 +M%PQ[D>!>.WMM."V:$ZV50=*A)878OO]+HL4G5UV,A.T4#=5=9?1R-N)8J#RL +M"TGR_^GE/BES4`U1N^.F3*X+/CO=P. +M:;AE$REP7"D:J'2S4)+L*7L0;?+BP+3HIER\%LZ-BC!?L02=ZH!-Q5V5DE>8F?$.)I)6>\/N0'Q%'=WVW8_0L6@EIBOJ9@Y:;BC? +MM4SU:=D=1+ATC5N4][A>!`D.46S-Z"H@0'A=<6:;9].U20CC5U%E"?`'BO#' +M_>_[2T2Z&%]LL^)>\[LAB`V1(E%+72X52`.:#U +MJFMMG`>3YU*A[!GJ=D31'_*8)NPO-1+G5?825CL7V2U\1_$=Y$MB6PX/39(BTK6;]?HL(;<76*V/R;@'-2*&Z +MPW6A5L7$IA1`4^*CL:B6TXN,WXP6'7,TMK-A%Q^YCO0N`07>-Z.M9A_3:GRA +M<\TY7\!(0Z.V9M;/CS1YCN'&@L,I<>5!8LS8BX:+!WAI)UIHIJ%-G"I5PX_S +MBM4R2WY#36Z*RP*Z=B[3,8LALEOHWK-U<^UVW3D"?#1:-@-%]BH>-R*A]P*HD\B=?82 +M/?5H7MCQ,'&C^N9,$NRK@D<'4_"HG5HN>P5R!R&2U/#JIC,3!R=D?VRBG10> +M&>M;=_EAPJL0?GORA',`';B>#!5QE%7D%`QN;3#8$MK5=YVQ4P@5C(&5< +MHB!53J*ZUM*CCZ6304XN!(;G1F=$'65*YAEWQ!'+5)N,V/Y%(D20GAA9@5ZH +M2MBK/E3?>4?6_F`,;)-PVD<5_$ZXA&3O&FKBK2`AR'ION5276@9+HELK>R'B +M7/;J;:-*N+`E65+K21/.1MHS):0LFP(#U^R"?">U8A1T*_ +M6N!?T^'_^%_\8`;^0$4NN1L!Z0Y3\[)!!);F4&4_':X>VZ3A=D:]BKLG6P69U0WDMXKKF=7Z#=#)@+9I#0/]D]:=YY).2>7/RQP8'7U9G15 +M2$[)01?8GX7C#R:'DD:6;E;5WO%U<>;RGPRWMV(-S[%[.532E%(K$!AB'MO& +MK8&B%5M@LADDLL%(P]F_(@LA<]A;!HY"A"N2$U:N7A\-<6R+%9/3IV>3%O3R +MCC_W<"HL;'0ZJ'1+7S4:_68Q,-Q(\IBKZSJ3KNL*M#PWWGU)V4P;/M:MQ-:[ +MWQYNG]]8`GHDJJ*#K>:!K_TM_K+M7AZ2$RSF+[Q)E<'[C$ +MO:9QC%2$F2D?"+]0XLVKN,I;"$RN!@,,=:I2#MQ(!+-+)?K-F)`NHQ;238'E +MT"U5"5BS!S;OHL3P?/2.3:OMD'U@#KZ//5W3A"R>WXAGR$(X]:W\6JX6OX09 +M1V*Z]/RVGRZHAW"$1OBYVX(`&'*!1OA7?QK]=.=S+_0*-(883X2;J&>MB0V/ +M\`5'=2S;OLOQV$3B@N@B32H*Y"&"YD,Y- +MRO>1-].)J,>@+J?I^&9F,:4-RI1B.)FB6Z@0S(<.2-1P*1J)<*V(6-C_"A,Y +M?P@CYY<+59N[[AS[>.!'_QD[3][F30\X(980I7XD.$G.XQ&V`[?>RYLJ9B@8 +M1+)F%/>K=?DATMP0BY9&`&:2V>_\*-V"#=C5MCXF0;+@+HFZ$3*Z@-%']"0/ +M6L^=J20;R$>L_R6@*,!H423Z47^2`N!D)DR;6ZTD9K@B]"HRT>2!0SW9TYVB +MYC"1IY\U*_<*Q4?P,=4_H-^(,70Z1 +MI,+%]E\]S`Y/A9V9K36)5"()[63]2:IWVE;)(1;"=>2'NJ,R3U2[GUJHA9I3BK6%`K18E'W[/6R!M]VUI'[AO^ +MMC']7'KGY(=R\]3G4F'`+^-][VT<(H4P4L);=8S4KK+8CE:S!T$,PAB)3O(B +M?/\EIT(_,+U'Y,8#)L^)6@H@:^!*5`T*JW(!9B5PZ*&;X@]!(C/"Z)8(=U9!(:(>D.R^Y:.5AEA"*(ZS8+*I);) +MEK*NR/JE%F:B/U`ZJI6-C!L_"F5I?*X6+0JURV#11O&W:?I/^L91+&#^66%0 +MK'*F7S[HK:0A4**8'LW9+0G[T2L:$8$N*OZ?>4R6,OCA/J(Z-?D9$%_X)!E. +MQGTQV$PV,1![:#ZFF"OS2I`7[A3<:Q$$X5M^?0 +MM&R".<":P>*3L?V3/ZLZ(^A>DRUAC>*'PA_*H];LMW8:;A>X8]A"A!5*A +M&);ZL*]LR#<2JFBJP9]3YB+CY!Q=`*$F'&3D25LQ(J#9E@ +MRU/L_)N7'5WADV3EAF,6'XO=AO=N_/7J>@D\@W,\Z:R/?7P>Y7=RPT4B61"Y +M]1+7GKFS;-?%O6%$%CJAX:S`%U0A(D +MOK\`%.P1#**Q,QN)[Z:R#+GR2GY6"2SCV[2X.M$IUW;=_+:C)!9].H^N*FK. +M=5\R@= +ML!B:*2(6XSY9Q&+=/SXF8@$FPG`[SV8>9N#N]/K)Z>GCO-J*)'=7"XMW6S5_ +MIX3S1RQBW2K9.C%.3"[--$L:'75@6WM,O+G^J49X9?K9:0.;)XU_Q6BD_/!V +MY#JC8OT2BZ,Q\'@A4+L1(PP9/!SYLVAN=CT[=\B!97V)KN*ST\(DYN%/" +MIF+K%@JUBMQ/GI\WEFZZ&.HR.R9WP!%R600SDT!U;G0J@YFS0*,1HCRT`X"4 +M%U$:&%2?,<=H8)%JQ9'0@:@P#O9.G?"D4<#>\W4%7E&<4]8:3GOYX(;N-I_$ +M:EWSM\R*/P@C(R\T';S]F/PLJQ[A_=%97&R*R:BZZCL,2N2/3T7F&MOO7F.X +MAK*#F>;WV/DA\61(S?!#:M\GR[2B,@TOT]/30P!=1LO))[IN7[U#.K$`P5$( +M_/C"4[`\[&T%/U-?1E0USU')?AXID)?>)KJBF7<'M9;SS`]3JJUN_T4TB\7A +M>C&#`)CPX)JR*/#1U$VZF`G/V&FN/PP;FO()=2-9#1A_*.=%%4D +MT"#'.'Y$Z57+P+A"W5>[#3&SFPZE/CB(*<,P'$X;J\;*@*/#J`G554)6YY`6 +MCVI]'%9+O<*MT[1GJNTDX6%UH@"7`\_D?M[1+1H1>.D,,%G#,[:RUSMEC<$7 +MII8?R%W@^X2%;*R5TQ527[Q"\>+8/K\P>E,<.*GK>I2`@'%3I(O>6%^!`"E# +MB]@(IXI4O%XJITPN,`,O06$8[E2X>??^MS"5@9PG2W2B$MY+#EVN;I*C +M<(QK.'<7I&N.V+_Z6:KF"`D+A8C+LU/+C_E)X*A(=?DV&R"(7Z0N0P[ +MY0)[R#_&63\0.:EU`V8V-\"[(F%Q-XP]3585Q9I]B8P'2.8(')H<":*1:U[' +MWP@O//"\JI*MJM*G\_J(--62,V_-UA&<"@K@:CAH;Q>:[Z!RN-*=ATW.Z1/, +M&T@,@*T9LLR;(49L3AY;K_^)]`BNGS#Q/5G5!)N"($5:?VVMJ_(M(@/""B*% +M118LC^V.F\T(*%KJU!:&G/:H<>5T'$4TLS'*Y$DIOZP09[YZ>0ZL.LH0>F&Z +M;M^-;,$GRPFX1UCU%!)!FC7PTQH\W!4XQ=GJ`-9Z)2\DBG/.=%1U>*](.=,& +M'@*X[9BWVKBN)QJ/1A%?K/R@-;0JVO2M-P'WC^WL8[+/>#XBNQS!Q-VBX4P0 +MH3\X\/(19CF)!KQP1YN`)2AF9<[`8(7C3FON$R8>[K\$,F1KXQX7L3 +MWZ$ZLN#E)?N2;J"I5<8-:Z\MNY2?@I$!1T":R68E#)TXW5(O0;URZ$/9;F'G +MO,!O,E`KH#]N"K4''YA.D0?BGG@2"J$T5*R,X5%;>*GPZOZU1D+IH-5Z02J3 +M.*)OHU0"<3*D-ELR5.!%-[]MUI-JA6-\_<@5"@TD@D^8*J&3CF7%U%]_VI.5 +M4[0,1`T;\VF_6I:USOO9ITOW/YHU/>+F]*'9BRJ'-0M@Q$O^-RAY%9WJBZZ! +M-]XD94,])++Q9,EZD8TC:JMP%41$?[5C(M#44/&E,H9PS_V.Z,8IO6!4"9D7B<(;!F25I +ML4XL%RF:D-3&'>HRTFQ]4I8;-"G,S]Q6YC"(/4GC*V)VE^H/1^K*&V.4T*.S75M9J-GR1 +MV?W>JH^XR9"][R)-@+2Q[4BQ0953EAPE'Q2ESIG-@?'^KO$8[7+73@S"-?>? +M>%F1P$.*D/!SPIO)5NSU^9Q8W67*BRD<%S/*B*^;(K^TO&RNC5\P@;*H:YG" +M'(2OF-UUT;S^Y=NZTJ:3`LI(L%[]4SH@LD@EK@J +M6`?MG1V)]F7E>,YF%7"O^GZ>($%Z'%EU0B&$Q2W!L!\^YIN])_JXGH'VR$E: +MS-Q\TS+#0[[@7J60P1H"C]VJJ31>C\OOTY77#CXJF#IHS?A4E3KS9F/KR\<# +M]\W*]NU<\17T<;ED5#ZQGC9`SRP$I'2&V#W[&`QO"/N).++A4LP]^ +MC-A5$HBB]Q=3FSF@HV123N*K=[/ +M(CB-:^@O?$X8X)+&0I-9UTVC@$'."4N#9;X;9T[O8'!=2+U'`J)@LKO@R*CD +M#?Q"EL*']8)6T%4"ZDIT]*2=DYHPNK,&:,ZZ6M:0M![Z,RHL[2MR"/;"EO0L +M6U=N@$=FM0[4=@\NP0YXSW:90]3@,6K_8%0I^_W1P.U@GK^Z744G'Z8)[ +M^GQ1\@8.ZAA9;PPW1M*AVM8Z2J^2V#5&0+1"CZW]?\T]S;$K+"S,7 +M?OEY));+KG9Y;^+B4/]]%>4\],&U1^PSNY0ZN9Z/'[&\!ILKZ0:%"A;^/RL7 +M^'C_U'JIR[B",/_E,ZY,('_P(G)*A-BDHJ\^XI:81(*_+7#-(B/5A^*&'/;W +ML%+[_3&5RT;#("@DDEX2U.O68+D(Y%E`RC+HB9SZR7OJ"]UZ>1%AONMSA.%# +M]P!;1R#LQ[ZV7';HP!]0+0,M`<)J5Q>;Q>8L@9X/^!7FH<-2C<**P/%5$VCV +M[<"+)E:H"`0?)M;DR\SRC:J*JBIM(;8_.(;33C>-EJ+KF)UQY2G#_3AT"4+B +M_6#4!!%B5.U7*-TN77@0KOK/5G1T:RO&#T2IY$%[Y>V!XKE&7518^2D=6RW` +MD(WMKW0$Y6Q*(DD,'KP6'T8MI.QV.65*_7(4#\*XIMA*F09%'!8GCM)%E:+$ +M\3VC:J5*\FBKC6M^5[1+CL<=]%.S9Q&5D!M%E^M-@F)_R:@E2[C%AG-O-HJI +M;Q>>(2!R`ATCF3+S'LVOT^5-A]O+[AKX"E9]X\0APPWPQ&PCD94*'X_,IU?1 +MTE2U8DO=$19-.30:I6;E((8V]8D%3_WN)N-*13KS!=YEB820QUC;/_U7IQZ7M@G +M7KE^QPG61T8D.L_$`L-T+>\'J"@-Y>(1%X&MECTHH@HV9"7M*HS4F\#HS"%( +M,C1BM]8?OHR>2-&Y<,2>XK6N3H[:+W]^5!WW33P +M((X?6T?'C)Q4AH8HQ*K>CYW&SFGO'TV4KW#[\"V['S1IM18]PAL$C.YFT<=0 +M#45FDX9MERB;@4\`N2DH-.DZ8*[:-/0LQ?8)OU$. +M?M)#^!W"YST2T')4+?.[!@V(KMGNOTW\FVH[`2,_ZQ`;9$<'UP=T\\JG!4)E +M_&O$4CB]B'[&"48ZMQS;F+5%U715> +M.I6C.FA_X3ELM4PZ.38F)8Q1@G8E.@2Q/U,/]]2A,$I2P!K3Z0J8H`B8!:"M +M_UHEN@Q*:(1L,0@WX>_A4LJ%4,T;K%L'>#N,1%_4\S7>3Y:.$>+2[3I:6)SK`,?3D4O.,0`\KT\0HKTED[C-<,^\5=/V:'"P(R&CW +MPRF\LUM87V`9^ZOSH>HZO;(.@*P]2MO1VYPSE%A+?JJU%1%Y +M%#Q`PI`R%[!E#7[!"EJ>/,&"&;H;SG02>2=R'S.'$_5 +M6^;*^6;R$OZ4'?M<7R,HN77*G(9"Q=:#YQDA#T9F;9VP@+?\Z@\&ZLCLWPVJ +MT`Z'$_#9R>7@.6U3U3+'5@P\KM%M513Z:JH#Y!PB\#CC/QD>)[K^/V00EY2) +M,.Z8?PH@4%5FNPCKL1)TP"!N'K3[+%:G8 +M2>J5)*A\`651K8U=E>VD.U)>13:V?GT=.U(JE$_STW5U_;^Y\Q65AT#@(`9L +MR]SH52$\*`9)FDRD#!]1+RS0V9?4$%XNFKB,[$^-+>V:9$+8#&YIQZA`@V4W53<)'&0DVD^`+0G1+>J0!T;* +M$>=T#=J_7I-S2KWA[%K#IMLEO@91^OFD$SLO\]^!DDYYAOM+)#`J.=>09JH> +M`0%4FA^W+&!@"67@1JI1BZ&4&2B85,YW8X%KW?='ZV0-UZ&V6N:/.^"\8-T( +M$\[\\5P5OI..@]!LH*%RH,#\*6!9XHXZGR]2G4`^@>3P\;;A][1#6N.S'IT7*U3JL\O?( +M-4O\5"UT^_E-;'?F4K]3N'K,-L`S\?T.N5/%F +M#2_'S73*&\_=4Q.6:@)_XP\,T[GAQ4BX$JG_;CFO^Y=P;YQ`U*T`P9B0`B3D +M'6=9ZVZ\3]Y%E4!UAR[X(#`H`QN?)E*?E[J:(YM[)2K&PS2+'4GM[U^EH\XP +MTW=6+O.Y9@GN%FH:Z`9\_MW`1_=2!0%%7!INTL[F2/1-61,2;"-)E0:E) +M-ND?Y0;H**EQ#S!7;O>_=9"4WOY92K/?\41LBZSW)L1O1J-/U1G[+>J_!JL: +MM&XY>'AYY\7G[HDL#]M?A8DDR,2@1OO]3\TUWB";\(:$,Y!$A]CP0:MU,VTD +MJ,YHAX`)D@]@,T[%\A-()/T)1Q<25*&3+D(RH2612&-*5:<0(3IERKYV-G8" +ML9Z_0'11EMD,7':M.^#RK:I-.VRD4^:Z,/`H)@ZHO$Q29F+K9U6,MXZCRP'`O +M3]\UA4O7^$:L7'RN0$PR%DZ]:GND)3U5WL=OL,C?.46T:,(+0;.)P!! +M!;OSK3M5E?HW;7QP`-:C@M"VG3NGC@;H16Z7`B# +M?3.="1-4DBD;CW->.!UC%_D +MJ%U!,\5&;J1&T`3:-Q`4[UUA8$,)F:BC^.X:L+;59><4'+[NW!Q28M<0^HAN +M[1=6&MTB1Y@^M7$]YR!!"$R"%_AJ;-DKG5LF6^'KE-86]>&5Z4$X)X81$O(9 +M)UX![W\U@<_=7N"6%*).6$E)S#X!G;+1X9RUQA)350S9!ZEE=L@T0A:BXH)9 +M70RA&)*[V""5T<8S2(S&2U6`1O6JE=2K-NK55?7SF-U4P>`BIG4P(H'VD30K +M6"&.DV[@1:)P;HJ+-3S7/%K^-:$?2"DE57I$EP&U./)Q`O&14#V*N7+Q%ETKNNB;DPU*WA=HI5#:44+/H(&7DA6AO- +MB>#?4@-8I*H(=[]#@D'$ME&?DNYD>EI$C=:_"#)!#=<5]4\;RB8H/;6FQ2/$ +MF8DK4_WE%%<2[0CZT;L\]ILGL7W!L@F%;[=6KX;;0:?<_;`A@Z&)Z6'7&^K` +MJ"JN`Z?:HX7+Y:`Q2,Y>/P2I5U8PC,',@G&K,+@XI;DV_J9S%XMZ5J@@@&ZU +M\>^4DD<]P[$@(+P\&4*,'5HWB+!SHC54ZD'GKI-!#PJ!]?L?;(_8N*!@RGM, +M79G@D(^K6,0,6-13M&Z=B$>D:.!=$Y4MB$-BDA/1K@$9\;N`X0_=)'P645<9 +M(YME*A0B\`B(K3"\$5S1"A-9-*_B^!3G,9-E.#'LYES>H,J9#R+>"1_-YG*Q +M3$>4UWX@YH`Y^6AMV']@R;5H]=H1;\@S:][X&ZDB(C\R>'6&=:(PO8+EH +M+$^QRV>HT3+&\O'DN?85X0BIM[NB*%$Z3&Y.SKA^(RFJ/H9OO[6W"D4(QR*> +M)9J]GUB?7?X`Y5SWS)U +MM>HDJ`.\Y)ZPEITOIH&W;VHH0'$:^JD*7,#`HGBI:DSEDYG&ROE\PU?*FG5HCZ"F\U*?';12*J7>+:$J(&`!K] +MNP^](=,!9\B6CPO!>!?7!ML)YKC';BKY?CZ0$.'[F_Y)0^MKIM1IT0TVC&3X +M@:Z5<$DHYR)ZAG)%6&N<>:"8`[UGG2N:LXJ6-P++'&ZU'[$.U9!/%\3#KN>O +MD.TOQUW>VMP::6BH*&@C_`Z"A3826M,LB[D6-)C,\0<1ZT^W%`=^^>18V3R/ +M`TNVLA4%<441#C8\-@*)S!!)&-[VU\X9ND%<4=U8001>:,:PH0&J"FX^J-5SWY-PJ`OA5H=LHKQW]B(V/[7L.&'UR5-43$QG@ +MO:\]2[!544'4//PT;@7TK]A>_H(DD)0D[#Q"=O:0W7D5<6F$K"YT:1A^<6:7 +MG]0!PN'P][MK+J:\]J@9R>M/4#-U[%CS$9>Y9@8%R'T&(M-A#?10J1_'3YO_ +M^@8Y(04DS%H;L?7ZX012)#R0]J%@J/5>;M5B_>5Z(R$ +M\2H>EAM!8.[FZ#\628;I7^_RV+\%`\+?DO3"8^,T4'BSSEA?4>6:8O;Q-SH2 +M_",C/"#[9/\O".43B#+ZT9.W__S1$2.Q!>VE3-C#,Y\_=T^F2`YJD&L$!XTXVQBUA4VHPV/ +MW:DF=%0MDZGI9G76B]N("I9E5Z*HT4#@V*`,=^K2N%DNG"6;AE1 +MK*J^+8KUZ&\9L5W$?@=HL&\23HH076\4:$*MARM`8OVK2,8Z6/AH6V]KW1Z6 +MSE/=U,/8JMTVU$@12M%"(N4<&H2OU\3:MV!]MP&T;Q4,9G`$#LH4%$X#0CA^ +M,W:OGKI#'S?D+G(56G1,'+B^#WV*4W<("ABT#-G86"6/>4JDQUNE>6V<.?#2 +MP)_"&K/"WYLUATQ@\J2FQ]?*3V%-2&4I3L-_H7XA<==Y9Q$5K +M7G[2P*6I_@Q<5"*VG_JYT;*/)%>?AYIX8+A,G_JY8H&4Z5K0JQ+]"6IL0Z-N +M`\<_\5]O\[?SM%D=V^439%=+NBT]'D=#%8$3(K="P'UNFB[?`;]M+#&Z!$FNDXRIR_BOM`,9*1%@XSB<[4>DE=,^Y:0_R6'';4(>W; +M)^"0:CBPL#.+?\R24SNF4-!P?Q7JH-*XT,]QE8H!.9)S5XKU&%#5U4G6:G/";? +MFS&"?QCB6C2`SLGG-9\*%,50G&'6MBP$@-S.K2U6?>YA6]K>2U?^(/V)`UVJ +M';UQ&XS+0/&SWE!B`:;FIHHR2K"A1"E%*C$*=+7C>R^.?OW;Q#IK]C9'PS2Z +MSZ?#BJVK)Z@U^.$FYN4CM' +M$G_LFT2VF`)F=`7&E?!GO,E4?F;XKG( +MM-L +M8S0"FW2@X9(3W034!3*;CN#"G:(PML,:/.C!92^JW3+[W<;6-:\*)#)UDMPD +M.TDZ*'>2=!,GX.4_^G(?.8A#4?(;QP,%.[86W6HV??($>5+.Z@$8K.A]6NJF +M%#GF*DI`%L_^H<-4?M.A\T-%Z'S")PN=WW7HB-#Y%1_\X[K\ALT/%!_?P,[$ +MS?>M./C\,6,*A;'O/OKH->,^^G##AHL??6QSW_.;OC'FS.<3_&;#YKMFM.+/ +M#YMTV>87+GB,?W[.O.R5&S9$U]ACK&^,V19?5RC4QA:Z]%\:9LS8_.^//@0# +MDDH,(\?&/#_B)GM-.?%*]K]XUWPL1H(#9M7B?&8?7W-QZJ0&!FZP"]VI%6S]Q[7NU_=)O?7Y?U7J +M9S+V&_.R'_*(O)_5]93-K4#GS#QJL=MWSL__OY +M#^KY@ZG21@54\$]1+G*P++N3?,SUS1NQMMS_O;6-D+6T)F&$4Q-L6ETR\H!'6='_O_?S.L4+D-,>_NBCZ")+ +M)G50U,$A9/?DCA::_PH7FYH')NRM8/P-=E(4#\``)0P&[P!UX=U"07%2^'#M +MT6,4NT7F?H6U[2F7$J+IPTG`F6N9V8:YEVG]7%WMSH0+=QK-N5!70X5#*(2- +M8-&)J`0,1<7"XH9#WTZUO:7;B5W-P&*?EJTU_/@BW7^=2`)I`ZF"Z]S#.`P! +M_<*53#N1T!I1`:B&HZB,ZC9;5W_%,&9QI!-K'SXUJ>U8KM8\/`?+2V#=;M(TV@TITP,IP?$6.AKC9HKXF-IW#_P7@<>!UTRZ$L8E5&!Q1?4B'K/%7IX[-G#H]DL-*, +MU;<+=QYI9;8'L1-&"BBRJ!=N,H_ZS(AY'0);V>V+KW`\WMP&(E$RU- +M"PEFPUM/5$4#'5^VT:2@N]$1NOL1@\&8'9`;=GF<+`CEXN#RRD +M]=>%@5F`V3JR56O8W.6%0K*@=OYZ:"&Z[V!&WBRJ:1)ASA@8%)2A,-(_&\)=^,/-R&`,>)GU +MO4O)LA'@2YI*-YD6,.>.0<&:HQ8$RIRWF*,0G``,HSWX#A,S5<0CM(I1-H,+ +MPX,PXP)*R,94/RVO+%WD!A+J6+%\#F>I/`>5?Z.SNLQY=2C632/(Y`$IL]$;PN?CX'\\_+" +MCD8\5T4ZV,SZ)R,L;`H.HY/DX*LUI8J?&2S0B#\2^%$TO!S=DD-F?`:6&[Q$ +MA:_Q!RAK==2??AY;OSQ]R,QX4+P0QK6?IG%I!WCU)O*#[>^$$4,BWCT77;)G +M/XN'.943Y'5'E;.?9=[47)O@O"]"4Z&#Q4Z<; +M%%,8Z=]%S%T]S\S,:%T1R$P]$^$1VSHL0/ +MJLO6ZAL)B8M[->J%I*V>FKJ4]DN'MM4%OJ3\`'[QWFWT2';0^N#RCSD)L?NR +ME6,J8)?P-8`!3#A9;/_S1='IMM[;V'(?>1OQ%Z:/KQ,]SW@$4SDQ`]4#BD%J +MS0"3R?;Z7!=G%XG"A,PG\/Y0EJ>^X2B"^(WVWB]@DY6]/@,(&GCJJ-&[\8B%'A6_MDL@EJ +M,!KE(:U`^Q2MQ=`Z^9P%5W,SOO"?>J,[+K[U9C +MNZ!/_&.S\)0-6F]]GYQE$=7W4&$?=(*J*N&9'6>O".B:Y0-_:@6S[4GM-,K[ +M@C;QNZ.-S1\MNJ6NQ.DH/S%@2X*Y4Y1U/P!1Q;@;*NPEO(D,&1EG!8P/OJN# +M8!!`CR_]F@B;=[A8K`]JITE%=R#DTBFG;&;`#XO0=,M/"@819@S>\I7O.T4$ +MDG5U&_$YLQ4INM"*8-H5A=3#MG/4TDI$*Z.;I$\/^C +MYPXP:OL7XLSG7NFG+D:&NHI<,=.SH`M;E\EF(9OZ,C1(<^1$WA4:/!1LU@9 +M(*Q[5,484K&NLYDHZD+BADK!$NS4#%.V!R*K2#JPJ/#^@=-&:(OB/SC($#=# +M,VH\BP?T.;2H@VCDXV@1?43^#WE_'B!'5?6/PZ&K)PD00/9=(0B9@9DA,UD@ +MT0!#0DAB)D0R$2$)4--=,].DEZ&K.YD!V13!A80T18HB`P80$5!DWUI9W)#5 +M!Q59W45%`ZB(R":\9[M+=?;Z_[^]]_WA]'DU/=]6M6W]9$GJJJ6=-J3]LJ:NCM%EO&J +M(1^%I3#,K#3]`(^R8+G-,`[73PR=PO-$.(F1S%B)!Y@,&1T1A(>]-SOKF;+< +MSD7#/#'00M72Q"U"$LI6;YJV7[UR2R&/(AI'F-SFLV)C +MTI=(+P[=0(=4'XN'.BR,S:'>=$(?97RKD.)VCW]3%JD5D@:-I2.H]I)C@P(_ +MICD#TQEIZOYVS5I0YEUKI>FE[RM4.B$]!0R?`?-4/!RH-\5?%-LYB$8\."A( +MI?!5]_T58TJQ1[%`Z;KXHL%7BN,5,1G;JRT7?UL>VND,$U=,9=W/7GT6-7;M +M"J<[\2BW,LQ)^SOW$S7:'_4;OZ_MMI&[=9TW2#'V_4O_+4G)Z2AAXJ6C53$K +M-HOAY"OT>URN""T7-RU5"(JPQL`Z^+"/CDLL)&?@5<@Q>/.0H)R"&-/)]]U2 +M?*,WQ\:A)2Z/JU;E!Y2+SSRJ"O)@34S7STAU&55:!Q.DT?BB=>86_=C"MU:" +MC5F'L=SSM2HQ3:&,561.'+;%)"5<_4.D_NZ%-$82I+5L`(-S0YJ\MYZ5_<'9 +MTQ9MN7B0Z4*K`&A\,+GLHII5H?T#!K&7$OU)SUJ\6WRAX-M2EJX52SJPZBS7Q%2/ +ME)CJMEL74WVVN)ETY'C:0?VQ3/N[RSZ;V9-0'+>@@;`CBV1&S[&C'=SDJI\= +MN!UT=(^Y:LTZM1/Y,7*FC[FK[5Q;6%*SJQ[^G77.4TM=V%+@X@4;=W/.8#.7 +MO()AT[P^XN[+@FS[Y:%:G])*M6TLJIED,6IYWV"SALX>4S@1D+,9B$D9/LU"P.*8.Y5!7-3+`.L&I\(,W(X1C_BOTVS[Z45<0A:R1-O+B +M*HY+DFBPLZ;^SR+:,:W:)5#,59RK%]4>S77K2#[6K!W*C@<-('1>_42M%\'L +MI5I/7!Q9J$SS+F@E&C:AGD:O@_CA8S.H=;#FRPQ=@<85U3&RAXFI$U"_1P(^ +MWOJNN(CA!/O99Y<4&-3(!:S-D*LD2S5O_4P#^G1>R;<&?3NZDFP:M@")OYG> +M6.-4SBA>F:'SI]?9"-3TWJZ_52C)P'1/>A`ZWWZ`!+=`;"O.SZ]@P'+&P@8% +MS1K216XL8X-66^AL&=*KE0K0IT/GKC-[A9Q*9"]OGJX:U0FNJ];H!,ZOCI35 +M''-".;X?6]6U9-FQ):SVL!XFY6S'*HN)MWW7#QH[`D/I@AI&!V +MX8@&4M(NIW$+O*(JUG5U"<+D +M-:G-3WSC+='D3*I)4=1KJVFB\K;%O9C)/;=;4E"Q6!+;*)FKRH8A`]8=5(6' +M3)7OQ$_2HTX3;@UDFL`@<&S+,U&Q*89L@T9W>4!"`''["Y3^W;[=([U@ED+% +MQE8S_\ZO3AX%^;\ZF\CW2:LU$]@S!J4W[/S$>H +M\7M$J\+JD#[B<*RDA`CBU80.7Z^AE)0%UTFI(M.YK!U)8G'RQ@O`;7J$U-Z' +M_S#Z"H@YZS:0LPYYH6E-MVGZ[/XP^><%HWN#-KN`2UI`Z.7T.=L.Y5YXD9:1K]"MU[**U +M!A>A=[F"VB5F2@-I\&-A^08>:D/E]86+3-/5(/S^I9&>4 +M*-X?=7).:J!IFL,=5;0=/UYBK7G"9^FTXRUGN/$IC,5:Q&%L83*G!I>_1=UQ +M2,,`0,R1#_.CRTJRF,6@E`V#+T=*,X8Q.;<<>G#`U92'H$CO2GK-8);[#I[. +M(A8GZB=7/[*%M7"SCRREH9[1B42,PLQ((25A6A8#CC9=-!PV@M +M4["7\YEX0?'V2M/_3(FE38?.XV?KNT:<&X[A,`6>Q\A%C@)0X2PBCM+S>H-7 +M?_QL4(-K,H<(?9W.$-5#MQQK`[XI8V'M^.E[XK]?'TGGT0Q#OF?J] +M:Q!+\?%O#1LG.6\Z$.LYGZ3Z_EC;2[QLE]0NK'TT];G;\TIXJWYKNZ;JN.L^ +MLJD;QT61TL@8LIXG!TI,0)CV8IM-13+ZYE(>^QM?\-06T!E +M]12A<7MEPH]WF*\]H5*$,AR;^+841A[[X#8DED'OCU)45$&7QX).TYM5&3*D +MXI?7QH*78Y,[QK'XC8OM&/<:].B5JQ56@$T:8?ZD.G]-G_O`#9NV^17)(;S9 +M]LLQ5V]%T_=6T47?T)!33C48/90`0P.@B!'&RDP$@`$Z;>'D7YT$\Q0/F@F:8;[&HS" +M]O9VG&7Z9^6*%I2`LR2/&.^S[U++:3-WB8`@[!O,V.#=K(2&SJG+JE3]]]2\ +M`.K`&EU/C"J$@]2(&WW&P.@@-,Z/5.J/RNR$8?GISV7C%JDXV@[T%TC1,-%Z +MMA)&*#9!,BD/==R@4G-AZ@:H%,;T2/*V,U<%"I`*NW7/(S$ZA"4I"-*">P-5 +M6/S24@TCB]Q8-:X7=#ILZI\A(#'D,=_EHZ:6"*_+U50I%T'*6.W'S#2_9>B\ +M?J+]7M76D>3'+UL]X,7BO43$C-8@C9O41#32K+?()65&I'@GCQCA6KP6A#-2 +M!,Q%A=K#/6R"%+-%K4,5CZ(=S$,CZVH4`I%K8\0AR=(O1R<.&3_S358C(R'@ +M32%5RY!/G3+%HB7CTF@"RHL1)I\YE'.T&J@]VA#&?<]YT%9)\OKX>)O,4^C, +M_+B%%_O*[TY`8XU>'Q;V[,]2[COTCOQ4199D)IJ00:C7W,F2A(M,0![I[%(8 +M"U9MX6LD]$CA-Q?$$IIUDAE'Y8@2HT3&U9)":V!C%&,3PL,\*UB62;<&F?2* +M@`-6F301!0WIF9&ZRZ-A1F`JJT:%GJD$`I_Y=.+@KF]LK]U$<[1-5\QFT_*# +MY87F.&>C[-4?>]LCXE].TTW=M)ZJ=C4AF./517ILMW5!G7\]L@6.60'FW+$'OJ$ACZ;`8\I%JITR(K+?N-L406O$?VUX.<4M +M,=R;HM+(>-"BPE_&3.A,"8/G(/.YH%8E^7-/\N#)(>P6BT@MK8%X+NRCN]Z* +MA6&T"QGV4A&Y4758C=0ZN_2O<=C188-4:2!,>^.4Y3,KR7O>@?,7QQTA#\E9 +M/>R"H]I/OFF94-6K!PI9W;U"K)R]@6^NO6G74]X3$WCT[7):`\=&W2:Q'!?) +MSG'E07^@()5=31'#TN;Q7UP.-NX!92Z2,#GF)HM8RH]+-"Y-;(23G50BI?(> +M?U"-#NRVM_?6^/'!(BP5*L/)I#),F^YF"_VPEG39G1@M:O+"(PV/%1P*F?WF +M"X*?@,2P,(1%$$QD6#:__8>K2WJU:3@LV['%-BHY#')A)'%KI8#4D7Q($UX! +M=S&=Y_5^/.*FO!"#WJ;8\6H*!S-@&V83;2*I4)TA]`ER#[WZ0VW63QW5K(_3 +M#\FLHL;]YW;RX2@@]`A\`?JE8`'=DJX]6H!/GI=5&A*:S<1#1D:SB<=P?O3D +M0[AVH\79F,S^>2EF?93*><..7W&FO\3%BCE7@W=]F>OB,BF13K&@49"":3KSUF3IN?*&9A6=/6;[,7P)PU +M?"S]JHUI\ZO]JE#9XQZK5+L;^C7-QPQ.=X?4M'&7'\R7YX3"`NV85B-WYFB.QW7/&: +M!"[+Q=UMPH3VRKA??@NT!UQLY+70\0%8;F%B^(0JI<13C0+RB:J4>#JP-G4O +MS/31R=P\IP-T*31^AH(Y>32M$]&%*/LJT(:TKQSM=AE[DKA[?9/0XN2F*,'! +M9?+N-W6?A@;MR9\3#!AV"@^.(;:WAO(K6FI;W2"M.DV[Q7G@X)7@/KQ=;D6O +M_)Y-\1!IZ(SOX>YV$G>U["-\`!IKR8^7J1?P=6T_HJI=`YX--GXV!E+D109F +M09.G1?&!KNE6F-C_D*K$R*2R*H]S9Z.!!O'\V#V*XH/ZB?+S*YXV@O7LFZ12 +M;839*P%F[(;#73^PB4MT'I5P2LT[8PHRF"3OOC,>*ELZ>5,WKLH19]X*L=M!&A9)@IEH<`HKU$3"8:T658K3*"E/;IUK!7X[>A(GF/]'4 +M)%H.E$0T4#N9F90ID/4+X2DA347T'LY3=VWJ)AD5GQ$23&%RQ:QJ.>^7094C +M0GU-V6:=_VQP"&Q$G;VU1R^^G4+!^";U#/UV$?GMA"E)H5U)#52Q.>@-R4&$ +M&;[P9_H+C=2FA2J$1>*.`Z#>$-&&V"$IWJJQ0*WE*$A._)-V%#BOOA=W%#1D +ML)G2/J6],O;K?3W,4*-2CKA,9YCX\'J7ZRNP/TL<#-J&:]-V1AH3&;1'P7'> +M)=,\:]06`@$F+V"\@G@8:H-/7`Y!-6U6-:4.UWK=T5@-D]=N$'NU*?DMF4M7 +MDE0L;T.@1CVP![G::EG:Z&H($W?N.KJWH9)XI,H.!^5G0`DF\T<)UY[Q"90* +M%79"Z&27&H_#7,8NA,X[!U.C7/HE&,8OJ`\%WX375)T9Y2DSOMRL5=<4,SYA +M,U\W#.^'9U3H=+W%+JEC$_+54O87X<,BJHKC9B/E(PQZ&=]:[\;.Y$>Z<0SWZ@IN@P5M0-WW<>Z:+C^(CZ"Y)'JNK-T,&)1`4M$OY_65I`/ +M1S'[?&KRME5-6D)!GNSE +M+,$.!@.A\^`7K1XR1(PR<8("5X'B`Y%6=L8X01%H +MMV'R"->%O0^?"_E,2J7=8M&G/VDZ/0DU^`)JPV4?E4P=0I82;L94MH15LP8= +M.&LKVYU^VZ;%J]94$I5'-G4/KZUL^^N)YN^SUE;&?6IY3$HA:O#E +MO/RRFG40])%+KBJ8A7-WEED@73NB`\RDGV=B:'%_,%/,*,PO^[I`.QO]@"+R +MCMK=?8/E]E^*.R:OMB[N;J/*\3\K5R!'RI#M]>>MEP]D\XUZA]J%E-B[WY]* +M[-9">U;@:A@9+Q"$0:8BT',`XX67SZR,/2P@&U3+U&S6ZT?2Q1],*A4$."!# +MF?C!+E5*RI61I"0&X]$KYU5=;YT]:)J5PYM\_2#/*\YQ8TE_"!C/$L+?[$\PR#ZV9]7Z7,G[*#`_C!7O1D8 +MBJ(!M@?$[8$7V56O$->W@;DX<6'8NQ&7$L7%V*W"OCLC&!HM!0*2-9CK5"S` +MFWCN*,JH)M0$-"Y9@?@]%WF4\`6R\4=F4UN>VEA&1?$\JGL'^B4J!W%*2M[X +MXE9ACRXU#./PY<=`^5S'Z62Q]E"!@+X'RGK0SB#C^W*+.>OUV8R%]V>4$\PC +MNG:PJBI\;`F:<2""/"7YU1U!J:#^^IHO:#S/??AWS?:`6LF!8%&L?56BTX&$ +MIIU;3K1QK7"GN@\OKN:X+BNZ4&'L(DDIXB/"%*-UD;WDF;=S;I&`#^E@^:;N +M>-^J$T$8+UNQ2*N`[,"AT;/SUIC!SV/OXP4NO7!C$8N&DZ2`+Y%A7J'84K(F3K$Q.A12`1F_;!Y,,T_MNG7L3ZNAOD#ELA$/>%3/`@YCL^@$5E/_QK4)BNB``ZM# +M&7=43A[&RLLBZ`L$SC%1;I9`M]"LIM=]@5^.W9'8_ +M"FF0E!%VV]5R&.;'4:V$/-@F7QU1*^&IY7U +MQL)NN:E;O1/*XX=N(LA'%'.-"U[3A#YBI)UAXJ?';.J&\:@22F+52G04_6J( +MG.0I$]='K.=L=='L/#IJD@_UQ!`E%C!>"_XP\9__0A<[U)TP:MC^?U_2\1'* +M8(N3\EA)A&VQXA%8%K[B_',"U0[Z\3X#(G.SP^:T-K4%:\T0$Q!(;M=AVR/3 +MX6@?>RAQQDKA$"OS7*5^&U52C^>U]8/9.N)DML/15,XC',ZH`'O]LPM=R>H* +M8E@BQ=UIMVRX:YK5Y!)SMUJSV@PEKA)5].S\"0IYJ0=C/;.R;[C?I&7S.=-#J;,2^D&?E(^_YU&1,FY(K!RNU& +M27P8O!/#G.)X9,;AF3``(=L^L[`'Z[9GL"*0'0SH6NBY?;93N6M1(8W7-<=N +M:<'_J?U.N8=A3`D'#Z.O8U&M=55Q73\6G+![U0P#.27`11*L4H/7LA6];$9' +M2D=+@$$\^MS9PO].H>]4_QCP$#HMVPFE/L/EA*^[1$%0NWBIT_;VIFY85L2; +M*[9$>1`Z[>EE@%DJ&]9N=`/)_%$]TB.$Y>B>>]6FD8Y1BZ#LGEEQ_OL]-6^JA+=)&[`WI24< +M$O^=XL9%HTV-HL3C!D(N)G?S:G=RQ4F,ZT7EDWTE*L^'7OS<_7F;&]1N#20X +M6DQ%^?+JTO@\T/C;2T3\@K25<$]E@BSM\F)+U0*5R[#3[[,"VG#8!OQH_92% +MGW##U?W@RCV=]3_URD]3ZG\J2G.\?WGKA +M6GQP;EZBWY=<9!%KC?_\V/FE8`)YT,LE@V'*(M]52I/VE0`8#:U2%+[GGLMC4DPRO*+U\;<_,I3 +M?<:?)^:&)Y(O92(T/+$UF`A-X3\^_*,BO[,H;H97MJ+A67,)KS'3IAM,3!?Z +M)Q((?2K-Z]1\EJ\>T$BJY+)G.$FJO.,M]$1?Z3)K0VP$$.BH\_KJQ%6HJJ +M9Z00R[8,5*E=WH>T_QA[6EUO`:E'G'7_8WC9(TJ?P'V/!1G-(HS034(;$UX7W1ZTSFW. +M"X82OG6?=2[`PW?Y9(]11WDY8]DNK\TME;!,MS&T.;4,W?U[W:]LMMIE3(;8 +MOA=?UKP$[$,+<=QH5="R:=')$^1*J;DM&&7%&V>('#&A<_IVG)S(OB2,<('P +M5.7*X/@HWB=47OBFWIEE*FKA8IX(EG?%=Q[`F%N;E5-0HNH9F?X\&-YIVUT+ +MZPC92Y.K;R8/MVVG3.-IU!"S3=US*LG5)\224FM"!*'S9#LJ"AOBBD+L$&`# +M#FG^QQ[S7W[GLA!Z8%GCX=HR,V"1KDZANX&C]+!55I)"`L9=81#S.B_]RZ;N +MWD*)@O7P5=\JO$&TP=4#^3Z$KQU[M17_(1+AQ.?O4A3$G+$7J6+&M-J4,X<@ +MS13IC72A!(PBZW)+YLW"Q+2;5/Z0\[,_2&>:Y[14$M,&JZ:6M^TKVES-*]+3 +M=?A_#N5JREJ%EFF-8;`%5U1-N"6^$I5[&VZ"ZUK8FX"?\RTKE+_3;K`N>E/; +M'+F^MZ:U.3XB^N:4:G8&DX?137Z+<2S"'&[=2]G8J+H[-]-[&R85NV^S_82+ +MXOWD-;;5PZ_!B[(NV1\/FM*2WH#/X +MSJ9F'1@WZ5:0E\3,JM)?+-8>G=DG"7WFK?%2?#Y%)P>.,[=P#@;V;S:]Z:#X +M'@<[6;1Q7&?I@\=5]RF5N%AE2E +M\5'49_*QF^5-\Y.X?I(UFPBL?>N>^7F.>BFMJ+62J#Y.!+/73P(K)RA0"GY! +MY37`J0$&[Q]?M$M:&M7D(RMC/2#D5V!5PJTD3^C0C/;VZC)M\9'[U6X%\MC` +M/-[H3H>#]-Q3NO*FAAM5P2N[5$L5TX-\B=C;Y'!@^^SR)`$3=]E_!\X[LDL< +M65M9>"VI6]8HV8ODFJM!*W#S>?3!*H5`=+H=I`JC`03Y\<9IMN(A;_'QTN*# +MV44?3,`X7=]MKW&W=W2(MWW"UGG;#[ET=&^[PD5/:^^@HMY&3]Q0&ZF964GV +M#<23GX/!2++!T4HSP.EY`IG:OR-=:#C`M,[5LG7MA7MT9=S4L:@BF>K6VDD6 +M.M]\C.LWJO!ZP+6BTR9NQK&SYIDM)CE%N436$VAA1(P=#\M+!UZD.9!4M!I@O&_);`TJN73:T8H4".YJLL3#QU1L,ZG\0-#/< +MX4C&V,A:T<0!::_/RM/(L&\V3*RYB77L3%H\?5G8KG\_`K:KU!*&C7KCD^*W +M0M\!J>AM>7M8#9ZPXHPC9%7HC'O'298#3Y#2+P0E7P/^+YM`,'1>.*FH*CU[;_02ML9=I +M2"Z!L<*SFX8@HW!`VF'GD1,Z_FS1L_[??+R=A2U=4.3@Y2S(HN'0N;`O=O`) +MR8F;HKP9'>4=E86JT!7FJ"*/]Q1=#28CMT^,=`U"[\)VAN:0EBU[!` +M,"E"L>R@Q`^GY`H"'B1GAYT@5(#ECAK'%E*%E%,R='9;.\I93UE"&%ZT\H1@ +M7'>[FUX??0_UO!R$*"87N_:#M];D%M5P^;B&#,?RN'?YX1Z?6H8YZ]> +MSQD"9+LPGEECR:]^8+G?T<7'$9Z0<^P#^2^"R\>?7YBM#E2\CY55JR]V].$[ +M?TX7,4B*%0%5`EH#!+O,).C/^I.T0CH[7H(T7Y4=#GI88D)C]_R1=M:.-E7L +MF*AA?U+4!\X'#TJ&#H:H+'J&-.A`L2V+>*'(LSW`!C:MTM8R&=#279BOWA6A +M<_536F1G,D$LN<&W9M.NT?-:S-+_]'E4IIICP:;.4QV).FHZC<(:`3N?\Q;$ +MVX3)0Z>G2X<<6T>9#]ZKIJ2'I[,=C^PA%+"JV1KI=A!<:9K2`C +MU9D,=A%GY"U1!#YHAE@ZUF[LU:/Q9GUHTH>)[ +M)?&P7/NLX;03SRZ=>?)YF9$AF=;*X4?_:I0'T*&[XU/O9]4'O1;L&]R:)E9L +M]FK[#3%1Z9H`\OM0!UJ +MT:7-4&<3+14R>9!HJ3!7@^W#%HKS5B%)I;]Y$A'C3--WV38[F/FC/Y;%G"Q# +MC2:`ZHS+=W63,$P#KUI;`$J8N.'O7&N)_.5(\E%WOB<><"P^M1KXM\TFHGN(>BH6#J-H,^,# +M!!U@^5F6K2#0.8UW_UP8&?^;F;;TYW_9S)#[E7A +M+7ANC;2X;)N6NWJVN'?M-C?NL\O1%A*OO7/M9=OLNF4+3_)@&YAV%O9TWT]C +M@2NU%?OQLT(64Q%O.D`4=2H#9TU%*.U7AW,Y=+[0S=HL\=B0ZAKS8T!SL3I0 +MF.K>=\I\)-NF="W;E2[U#(S.)X:@-S20Z/P[^5 +M8P^9*M]8%YRVHK+XQ+=.JWSJRM/I+_W3:953S[N/OC]-?7=:)35CD7RE'&5= +ME<1_'J`D/VPX3/SGQU6+&),"N;[M'Y6T)JHO@9$=1,4K`:!W?E_HM`Y::>:= +M1W#Z5%9,<>1)I/!>!A$L*)%`T+@_7J(R`G*8H:47AW%3+46]/#J0T7-#2B>0 +MONL"111GDCYB!T!+O/[9'K$=#/C;]0MD="1F7`7*6Q9S2"017J]QQH/0$TY; +M08K8>I6PX?QBRB+HKE7Z`'D/3L^0QW?I:=6C*\[O)I*[V%-0=W(NB\GE$=*= +M(RZ%X*1YB^:VQJC7,^CW27P5^M,:<$3HO\];6Z`5W7=1O^1M1.5!A(%45"Y%5^2G0$2L&""4>_:]%UH=&!D-3R"6.6PO&#MI*?%#+UO_\L=AT@]H# +M9@^3N8]Z=I$!=JB)3(L1B8:K8=<92@*\05-H1ZPOD!<_?YQAK-^N\@T]D&!\YA= +MH:;%]?N2K)-!&&D9ZL`93GRR.21?*H&6W9<$VX=2:QPXE'9IR512* +M@DFT5?$U%,&YP1SX+49G=\1T-/4R7B*.TC3B"X2^EX#]P4" +MIQ.XJZ>H9D:2][\F8D-NCZJZOH!(NYQ+1HZA[Y*2\&!@;KQ3U8KWBKDVG1\< +M<'(P")KOKID;DM:J&!N"UDI38H&5&*(RIH@-S,HP"JJ#2+0HP^);$-,RIQ#! +M$US.#1GS;FG('I<\CPNBMSD9B_\\#?Z/4QL"N8)3W>!N>?=0#1TGZ-7='1_6 +M+E+5Q3/PE?7$L,DE2;,Q^"P8E*I4B3@C@V(YZVF.N>.%BSA,'K.-<4T2GM4^ +MY=$OF3SZ+LY1-7#HN$NREK1JR<BG_7?+59VR-"\X=O*A,J,L;]XKZ[F +M47R)RC,*MAS=S4LI&-+[:S/W:C\D7++5;M#8@_YO/:>!OW/CKO=/LFB#S\F` +MO2[HX*H"'B&GH`)3CNY;4@Y\T0:%H#<JN$@WQ)2 +M[:;=_14RH9\1EPDFV+(N*$T&%<1&PA)_S.*/2F#"4-J_N?$;.V,W +M]L9_G!+[L=BP57$*S+:(VV<<;&M5.&8-*$,W4(8.G`-FN.%&"XPO;J'06?1M +M=A/`0;O"D8-=D442N6^0+>3[L.M@D=1AXO63J8[1Z@BUVYV*C!TP +MK='%.G&%AAAK"Q+U9E;[8D6H>FFB\O/77D\K_#U],%KRWQ+B6H:K%#DM_KF* +MBO*L?'B$&Z^14K=ZZ;QOQ:<,DR`U+A),L7$05V'"4U8`.G1^_D1^!$Y..WG3)-];GN<>4F.XP@"%S/I7,1I#!EIK +M!(G^!;4:@2*Q9M6.$QWM/F'6G[/#KVM.;$T_1A'S083U(W"7QJ1NUP +MIV6Z$#;SI7UC;XD*ZFQ+"F/!389UQG*-D&X0458/9EWWN<;3568(W=X?)JPX +M[A2.XV*0'VQ[L';0S)<`]O\BA$LR]<^?+B&+E67:3^BG@&59"J,T#)Z#,E`R +M=YW(L^\F-Y+PS_K(FWPZ9Y[V0):QI_LJFXU[.TOL1`@XQX]"$7 +MR20L9,LJ1E(TF\XMKJQ(RG'HG/ZR%C@5!ZWHZ,U,<9"&)3WXQ+R'632<`Z#RK]T.[F58A:-0?S\D'YV.)] +MK'K!LWSP-+38^F5JFZH20Q+8;2^)O=P-TG +MMVGER#O'0_.(4<;7M$YXJ +M/N'13XLMNX/1M?&SMQ0HQ_,Q$RWC#V`19@9"V;X"MP&64!F=EGI..( +M1B*[,W2.CV)HIVGMG:0-4-"GW'!X*0J$"71J2$T&W>S[%"-\G2UKV=@HKKXY +M,@]LV@@))U'K/N'3\+D"]U-=\QN4$\D#(3JO'X>CK&HHD4#'[+X,%M@@?V41 +M/6#C[K[Y>$XS@SM(8;*.4N-T3^E^I*"_R875^MY!=\;=M9K#CLF%JP-*MB\5 +MH@F2FJ'!\F3?*]9A*F[_[T>UQDOF0RRF-%C62\R:-9B:]_>R$JSUVBJ$SOB/ +M::R&Q>(ISLK8E*&T39'W%ZP#]'[!/?5K/DR.95=W#(0%7Y+VK%A3D'(52=7< +M;!`?+^VXV:RN;')S_OG-."(5DU)RI.05M@=M+PVO_O9C7#L5SV94^+`<7F:" +MI)&IY\WO8QDWFQRE-4X!9B#1N=U\&+'$HYG@2!>1W@7+E@YVM@:S:S%@*[3$ +MLU!@-W`^S&8T@1MNL(#0M3`L!<+:0CO**:$CL,ZZ0<+/K5M<;>R8T.^+UBTL +MU5NG8U55;I<\EYD6]!H3Z3*H]&;E4[HX\8`5I(0XX1HGD#9MG1/VJ-6AY6H' +MZO_1:]<2/$P1?]:.6^?/6GK-%@@>&@'/&T<`_59AML`X;Q7AF1]9J?1#,QPI +M^P7%\CU.8MT51*52E5070#?P^^S(&HHHXWT2J*S +M=+F2\IZ_)1/_P6$KK0Z$VX/=)E=>%`R!E&@]PY1`O<$J@>KX*YCL*PX'&R(. +MBWQ#SY-J2+F-I#VFP3GJ%X9]RS*T-G5[J*-$KY^`!CF(712T\Z"^+E5%'H;.-XCS@"8;!N@+ +MWZ7F>;)+WJ!RLXESNC8>#2^D=#[HJ2F:B5BMD$O\Z3JG +ML.I,%5LS6FR'X,@LP_&@9:P=LB`&963@6G5EKL&5J&W@-71U_/(\79ZGR_.; +M:SB?:W!E;2:Y]E^/FS/+8V?B*,0AK97Q)U`IBD(QTT\5LV$+T'INLQ+))4D[ +M3/[LW[*Z<7^7^RGBJ-.$&R!(E=.DS\2**2@_>9_X$F_@V"H)$,KT-+GJ24G# +MM6+\U!\]OS@F*.EV_!+/;F+3536`N;17Y*,U;2#.HV?Q)OYTX68<6*#O_WVW +MS=!=DV=9"*]-EVWA))#^9JUD2T!9FR1$;&,;`.-X6 +M*WAMN0M,W_S5I*HA%L.N5614,.Y.8/IBZ@.))C2]+-<3-HMJOPB&U.ICT=O! +M2RD@GILJ6937UAYE$RETGM]EI:A0>`(AJC6K.&R5EB,KBL)WB)SAX!_;JW1OTAHEZC)/OB_7+U[9Q +M@VH>R4/OEP*H_SHZPXQ@BFH3:R'@P<<`?E([$&^!,1^-5)#P5O+ZB?#K:N1M +M;:^,?_2%DU2IL8:NZ8S/T#:+R]I";R>_^HI";T/W_GH))<%%&D*)7T$OT<&" +MAQD<:CHHDN\G!)J5QRB`N9'$][Y###AT^O'Y'%GG>60!*R*TGV-`-CW&^=`9 +M.G#TH$[3G.TVS'J+_E,OD,J-*YVDI>7-:!]Q). +M[AW5FIKUM&-!4)6E6>Y6RBVLXH,T>,R-F1*&T-B8`W'ZM95=%>>8JVE# +M$:S-CJ^A*!]"1UH&P589!*#%:[")\@ER_\^W8O%LYMHC<4"00N&H0I$UPI>P +M#F6OG9KEIQ`(SJM';,9=//;:?5CGY-/$C=DCULF.C@*K$WI]@J#G`D11&C=& +M+PRJ(,/BHE/QL>OHO+@.ZB6I(27GX\)J8*M;D##-@I_DFS!^5;*:5:G![T"VO2,`T/)S5TM4R>(DJ +M%[)[S_3VCD#550?3EA*0/5\`R"PS,!97R*3CQ#2DZ7SG;3Q73#Y[1GSMO4A> +MAH#N&13YJZ5'$=QNT$VCH3C:D7(#MTMJ[7 +MK1=%UB,>B0SYZX:#6<%P0/X3ZV!&:;H=HRW`03>A;OJHU,\&#`=!+%4;YSU^F%[Y.!M85S^.Q.9 +MR)V[KR"EQ-[C=U]AV4E1IM0:.K^^46-.Z;1GXLM(QWA4-\+D]H\;M0O.K/G] +M5*^<7!4@9DI>C((0,Q1211!5>:0&UO$B>HG0V7^L:^L%')@6MGY8N0Q6I+U9 +M;0^Z(BX.+XP!1`M8Q,`)F-EZ/8?.\!QRZ!H(`HS$O*-[!AHR:S089D-UDD$O +MPD`E<>IL')#6D<3G?X]UP6'@RMJ?&@G\^]39%K1'I[G#?O[M&2=Q"3V\1<>= +M")N,I7(7B,H3-SX)68Q6E9RT*A'4BI?H!(I,7YC8]S5UM(-MT?T_,!E$L"XX +MF[JW)FV.8T;Z9:`-3M+7D9Q"F'AWFO#3*M)FC%5\>%W&JD:G&(YB?C'6(''? +MPNBJ!C474IBH_)<%VZ&]W?NZ+/]7%9/K)4:X4A[S'G&@VMA[FL0I5/%`[_3UGG@!P:W +MX('W\BEW$-Z5G'>)"T\FUXQ&>%][15"QD4XC;?!V1,`2.D]^<;7P?1,5 +M+E6`M)_GLWHOY7W:P#& +MG10%.!4.NU0RDANN9CBS3CNP?F?[(M#:-`TUZ!NS_F0(X.GDQ(8W$/LO]BQ# +MR8(#[_O(24FR@%D!Q>:#'HCJ9VIO5:D@]_YDY=UUBB0L;]`)RSFLO34A%*:^\]]2>%UF"'_X>#">@MYBQMN! +MJG"4A-$0UPAJ!^+^$30_OJ9*0C;S1CHDDQ"YQ95!F;/AS?L12`"+S%"XT?C- +MIK=K/)M2T%;Y!IQG*VB3Y;M:]4SCTV9G/2M-Z\.5F[I7V46[5X2)=_Y153C +MU`I,FV`(:BDL,FN_$X3) +M`EA8U3,T"X@<16P_^_I@L&I+ZG`AQSKQ:;L\OX@(HF"4/UAD>3S"Q-N7&!A) +MP68;(A^0ZB#Y@I@)Z-9?#99+?H.L`95@)GE!2`<85)L9VH[BYD>3,"+5$EC\ +MMT,^4DA&+\Q6;C[RO%T^D0T9@I^#_G'G+QFXP;RZM@=W:BMB3O'%?!N2+.5S +MK4/;"LLQ$0@*%=OY)@0J3:<\7><*L:W4UH#>BP/(B@C!!GSPS^I752WV!KL* +MQ.X]_3R6?F,OIJP=U^Y1W/C6%6F/VN%YZSR-A[A;,;Z^HD71-\S2Y5(#JY$@ +MUCNW-,D?27RP.]<;P'QDV&_9X4@2ZD$0?.1G1(,`B@1KD$K"ZVV@IQ8W))A3 +M)SY-!]TD>.^Y%\+QT*P*@+:(#JHV(G*NYKB0*F:])F_]\`3.Q^>$!TP]!$-H +MOY<$+/7*(9@?:E?69G91O!MU`LZ1_,L_FLDY5&VA>TLPR*0@(D8 +M\W@O54RB^0!]-O+#=+`"!YK[RO;-6I_ +M.E6EGH/'G0$56(<=GG54L1H^6#`#[=S89X&2A#%<0#H6+6F;D(_57D7]!TS8 +MV'F9)Y_AB//YC1P20W0=>KMH%6_J/J7:RMJC*LW->C.?PY$R#IK2BZ%II4#" +M64N)RR.)U`(8RN$(&26C6.3IHC^[=I"4_VN*EY#3:;[.,>#R+`3M*Q2A +MB5J(>D,DA*%+.86H?KT5C.8NK+UIMQM^QT;R4.C*PE<(*W2Z"[M[^6R;C0BV6,G]5<6+MP]$0G6$SGX]^)R,Y]>Y>@@K305WV0_.DM'06_@K)F75),7)N[=D<\&-X.Y<(_] +MU>2I2RD.719)G$^:7HJE:GV;FBN3"TEB#(&9*HQ/R1@&:S?NT[:S`;Y/;^]@ +MX/L<96&@T*61.J6N^-C,[QHXP(@5N7%U#7->RI&J)U&3WF4"6EZ;Q5J'`50WEMRRZU!UT*8KGP+[BU.]C/<+AKL^QDNQ,LK%P,6RML<453<*H<; +MB1LC`!NR/#C*$Q'ZN+-R52SCJZ![<4:,9?F[JJVPDI\]V>ZCK,AY7=[[=QPVOE_&U>7!V27 +M@HG%VD?C[E.1)3LAH>$\=`T&?8%'$Q&GVJ9BV,W4^Z#Y%+@(KFAIP8\>?=1S +MM=`E`P'U`!`S[P^S!E:D$78]9BX +M'&WMNCFD1FWT$DSSS:6G@Q1\"H:X]Z>EQ&G6+/6N4RTM%@.XE`:G0ASJA4]S +MY8)]+[Z,XN:**(F:8X@I+N*SAQ#4!8UW68V?8U_LUE[,=.%\7R!^?F@9?,!QM/U$D.^N95@3&*_;J#&J-36U8@=*Z\V3*]:.`Y8V3Y +M4#L,8-4`2[3)HX\-VRQ/@O-,IX%+M1-3.:_A.I>CI6FV'RFC'0R5:]NE)" +M[N+5Y:-X[4%U2?T[VS0CB,W9<$,?O0B3=(MR2T02&[JJZM13<,]*\KUW)99# +MVH&%^`(#5_/F9"0>^O<>NIL3,L"*K2JS?"3QUNOT+2XF6O!Z/8%N3(F3?^\1 +MT)=GQ:;7J=CT#F>)$HI9GV#'#--7<=D'1]M.$QBE2DY;O(0>FJ+:LSM-4+TQ +MLX\;IZ8[M6BMQ)L+Y)A4:[AVJ7*"4&,)1H*!1]4J%!\F'KA[]&Q)GLH>8::S +MO/M2/8R13S$$W"GDT.1[*>IGIBQ'9@V5WT-O<89>1$T2;U=*LJCJX*^FA.WB +MM&[R!^F0(/1G>*:HI?42C.[P5P?+FE.H33)P'RV3&FC. +M?(;FTW'8(^)/X>6(X+,V.C5-HE,?V;KHU'EO;"$ZM2KCK0Z3EUPL.Z-F69TB +M<%_H+F[MORV1LEJ7$%^QSJ`+.'W.XM161<=YN[\H*.[QF\2?V=#+?F&9/L1VC88#0KW!L<7O#]$_Z0J.\:B;U +M9W%'QI]VT9%7/DRN?3*6%E-)OG8HYQ"[/KIV2I)+'%!4`4,2F+..*I3Q,VE3 +M)MG[GEW;OA!#TH)M,[ZI;TG)99>_9#H)OX\A3US4!::7U!AE%$]2^*0##^.^#E8-3LT'*=A[,I^[7GQ9L["( +MX^DNY4,ZZ89.N:$YW];1$J0Z->,VW-$I=TA>_(R>8V.?:MJC-/F^O+37$:2X +MSD:E.&X!M)67JUU6Z%S,\.58WTTT"J^9^A1M_V0Q?6JF0B"-*L?#^PJ&5?-@RF2ZDSI#Z +MHMH+0IECAP5G8!Y8/C@LZ,#CYKMSR;#>L(=?L(A!6:,4ACO6$ZU`JWWBG;Y? +M/'90S[YK8PA`F7K_)R?=2M>ZY372D!:<7R)D<404]_JCL[!U.NZ_+)R^< +MB4PVO?JHA.?A%?M(^$$KUUW/KF/RCI01;@)=5@2N[94)USTA6'K#MS)39:() +M*2Y3$Z@/BB.]=CL*A51'8(>]<6-:FZSAME3,57*'[,K%<(*:75G'R=JBH]S2 +M?:E"V5K3]SI>7ZLR8,,W^#]X`;ZO<_,OT(`IEL[>:X\_1+ZBO#-ZLXU[O_J. +M<0/#X8'D+?5>B=F6UW>Q250GPM,^]H89%3KB*&R!B*\B/!:()LG;'F,2>DC$ +M?5?G;#`I38K7OA<,QF9V5;05^MJ&;-1!6&,0!J)CC?82,=II +MV:+#VG"E.\ZI2X^9Y]'KS3A!`P(Z]Q\5`L#Q6G)^QDB?E@^#H=EN(?!A`/TR +MAI?"IF-^*U9D+:,31E9TE8;8&FBV;)^LY8D@WDJO&#I/G\<5EGR*++9`_S^< +M7V/JB>G&7:.L:>Z\,2G+>"IM^S\Z]:41=Z?.%]SKRB6JH&4#E$0]B!BZ=/YU +M;.5ISLG06=DJ;N4&^IL`S&AX,KZVLPT`G1R6)NN'M>W.=D8SZ5AEM2'XCMWB +M'%_A8MT*)1Q;AI;CR*+/5":'RB/&Q=C'OY]&+B1F)N_J.59:\^1'6K'!BH8> +M%KF=ERJ\@G%"64_6UPFI-1BGRH$UVW9@26/&X"%!'R;N_3ERR4M.EN5^!!W] +M\8L*NMQ.8%8H@7FIZF.*B-+!NB^4!F(LKS??IG>&13=):KF%6H(%\/0XOT!Q +M1#R*6<'(FE0,$*9AXJ'=RX/U63^X(D''4/L%W0^)IY?B'\O=-'FI$?#4[^$) +M/E$U*";,N)LDH`ZK=NR_L*H)AR\%&(PJ#^9848J"E65EK#OBX%OU'4.FPGO< +MZ@WH.\><*[Y[<=O;LB+>5.)=HC[)^"6_#H4SFDMT'=/C??A/<<\WP.@GASIB +M6B'TZ;AQ\[!8*&AH3[]2[_N!_N34\B]Q7=IF0B=PG%G+BWU\1)SC> +M+!VIF>=7EZ*3TO:0SQ:61-QY@F]CAQAWEY(3'^FB,&$VW6IEBX#ZRCH:['=& +M1XZRX6,,T7,P27'32>+MA*U1R*1`:2D4>>7%<2R5Q+\>H-6CU&`$YYO\)LY( +MQRXP'#&5I:P!72=>7$!^.97"0@K988N#."Y2M]H/U-N_?(M^H#V>>A^#*YK$ +M>#3IS*X-&25_M9'/AA(!+S.N(SX[5%?Z#WA#7D([DRRAO.*61UBD'_'[/8R/ +M2?2(7T]4\^NO#IV[6T?ST4*GB,DJLI&'EKVE4K@2-_QX%,`WGV8PD=_[@^OK +M)$CQ#-:Z<70XAA>!UF8S2_M"Y:J>8:VP=VY^C.L<"]%X%M:XKDSS('"0Q)U9$&X_\Z?J]$9TK +M+QR)PTIFRX[[A(O.7,C15M`VC)T.9ZC"N/^A7^B@.?CK.2N +ME+"AXJ[2&D:!W02@+[\R28=M%*H3O^3@NYJE#9R7-_;RO\:\F83C,JEP]HRK +MT6&(6-/O3%UI*O0)[QX1DC!"M<5+3Y1%:A24Y)[SNWS#=H\PSVD5WG.G5)QI +M7U9RE^>$10#N(P[*PC9CO:IF2]E[S[>KTFXQT;Y!7K;>,_%!F7,W)>^/'U_G +MXAW[YB5=4KR"9U!JU*\D6E=8^E:\@EXY\>)O+.D8JVP9J^:%!1XQ]B$(`0() +MFCBS*:X5.D??2>-W](TR?C#0(VNP4[P221U-%S0M*RO"D:T&FW6>]VAA%+E@ +M@\>UY_)1C&*)CWE?T]2HF@ZTH6:NW3BJO2$CEQK-XJCW'-3R2DV7N,'.6Q296/A3\MO5,O>OW;C'17?QU5.QZFGR^'OGYQ$T-[D4,9`9PE5WW(W.<&G6$7A*\D5UTOFBS1<+6` +MXFB1'L-4#/P5NKU!8U^H?G*Q$#&W?JP,/5P7R57ME:8]#]?AEHQVXTJF0)AX +M\^>4.Z)!*.5\1.DBE)/A>2MK6X9M8RB6;-^.6PP3W[T\%C47)D7HI4R[*J:' +MT39?A48*VZLJPX),;'DS[2(;.4)0]<^3-[)4>[E,"JX?.$K.YW5R/@<@+C-6+E&V$!564@0+%J\B<*`T-7LQ@MIX +MZU(F78#K54A#]%`0APHK:#!U?@`[$TXK-89I@M3#U`S^\VRI5SI,GD1TXR*N +M\>(75#00&9E*&2R&%H'Q00O+%2".>5LR3BK,HL1*`(-5;])\YQB>K+18XLW# +MXJ9DI#,/E%LVQY*TR +M2';X%;-V0<'+4S><2+Y/CQB&O'K&7`"92.;ET61'";[OH2L$9)6!E+6 +M]RF;*PW:E2NNBV3U&9IQC9KRR[6E2TN%,+G@6'VVP#U7G*/0B#%F"=C;N@T? +M9+A4@IXPU%9?R183S]F#?1)%]]9_U!Z;0)&;,;]""0GO*:BGU!Z3H8\]UX<# +MZV7<5XZ;`T.=4IE;]MZG#6<"6.\((=@`,#V^3T8%JNE>3)"\LV +M/4MD5C!V:V@\%Q879V\&GDA8"4JDSBJ@WX";54<9)^V/G_/5&)R>M@,:HV%R +MW\\8LRG6(0,2KJ=?JHF!)LZX81I,VR6/,=B=-U=`)'A"RV%E/V/'ROD,+#B9 +M'2MR"2*OY1FE5==M&.U4(NV#0&TU756#I9/*4;NT>`"HVG*,^0;>+)5)LQB[ +MP +M-82#3:&.H+8/OZK9ULZJ;W#$%\ZH8WJ)6P<$EB`F8_=8;#.*)LI6>KI?5C07 +M:5!3!+:D$N9B.R;YR(''R1Y6M2#!_(E+(21$7?*[1)L1$9 +M676,8FFFRKA__>HX*VJ(*R1^@2CLL#.`BT]07?JM>,]:6]LNUW +M[]-Q]'_O.87(C]?%,U)`A_16JUV,>;XJ25!TUU9>2C#HJJ!]P#6[H%'>^+R> +M--VA>D6J.T4EYL%:D:BOPNAA?,(%,P69\V?-FG44$=\*VD0CYQI=E%(7(>16 +MNS(#N+`%*4/QLL"UKID]RC4I%9CL+OBE<%SS<]191=G%@8V8\XMUS12=X;:J +MH:ERK`BK/H8A$(50E?^#WY@P:(CD8 +MEC:4-"U(<&TA96G5$G2]%":[O]]<*)?LJV$Q__A>BNRUCB1'?J648(8YJAS> +MR&H*ACUTYCY((157R"PSF./Z'R4=F +M6/8F;'L_T.2M#+3>]O"/'5LVD5-=S1K'MW\8E(J[8['9!JNJ!2^J,C\.ZKZ@ +MUPJNNS8ZC!E(+]U*/G0]04(OUXH@XRQG0P\4F64M`_L^(CB-`.'^QVM\Y(G)7DTI +M22AR49C[Y7ZP54J>Y70/$[T'Q-\O\'DIP[*5GBACA>=5Z)A!00>CD4HT)+[X +M'[]@-4DTQS5-KNG^7>^.8L6/&T'^3J5QQ^B\[UJZMC#OZ +MO2I.#AF?Z<(@620;]YFVE\J=FDIEI"<&184N3U +MJHHB;`P[I^I89<`]]"![BI4;C(7N;*DW4B6%FZO*DVB`UQ9_>AV1(>[0UHKS +M[!.D=MVV=[U.R<&&6"`;D^6-1FLS._[@>/-LW3\%[N(_X)IX?^5G^0N#"*]= +M2#1]5L--9^ZKL]R$*(OT5"-$:F?-'DB=HD>")DPLNH%A$:`AE8>H4I1AU0$K +M^L7II+EB-19MO9#G!SOEF7`M$DSWO\E05$M*$FB,UANJ8+1Z,B@Q,/%OMQ,X +M,;__316]26=\:TJH?\Y+)PE].&PL,/+K.TGU,(HK09CEAY1O@=\XI=4\"[@Q +M'#K?/M`E)9R9TY@4FY><=L>..#][1M?9P]:$T!\>9/GM&3F'RP\LI(+D2#9< +MA]760#?7`W-C)1O/,$:V05'KR +M2\5S.Q8>;0A_XW8`J]99K,LW@:PB+O(G3O5F<8#*N_@JJR),_/COKD\9_'Z+ +M,%]`@ZQ_@@6:H^.ZH"N.TWM)-!"7J&F2N@+:Z?=N)Q#*@H=R'FU\-Y_Q]2UL +MV/BU96>L>+U +M(,7](W*RVQWN]0+:4*T5-OB*7IQ[..V6*"F/+\6"QXL*Y&L(/AHL`/X4\.4CV6"RIB)^S_40K>@:#0XS2QH(98+^HT7!-Z:3DF=<*@:Y9 +M8+2:!UQTP#-J8'NBXA_?\1GA?23UW.AN*SG&^NIT#PT1%K&)/0N?_TG)O&":-# +M`T,.(.''7]ZCM%.8BC^D0-[@E:`4D6=`0I?0+#K20=KV>Z:'H7/GR;Q6*3AI +M4;+3H:9J;Q)U`JPRM4JJF3XA#:/:#OIX,KU*/KN6S0#LS))3-4A+Y75"8[3X +M$*^#TQ%4S;-Q%]@5I%V2I]GAD<2->!JBK`*1G,5L:XJ9N]$\K*3I(9$LTB'' +M."4>7,(EK/3Q5`9](G&_O3;UFD/(DF0&C'WY&FM4DT?MX@;X$*KZE-7C)SX= +M[!XMBI'$:VNE_J1BL;##U!CI*7K](`$]S#%*_/OSQ`BMZWF#2.T7DI`K;M#O +MM&S-X@4S.M=6=ELX805,\'TS\V1>1`H#$1&:S1?Z89DBB_:6L5JTK:M('X8D +M\F+,#WCN8"M2!V``APEO*-C'RS4EX3$Y%;"`8W)&85-W224O2_8&C,_GRWRR +MDR"%,6O&8GPF<=3[[Z]A/RL)C&3%-4^P-N<7#=$?O! +M+*Y&P*`B&A,!":<6:*?]13>78Z:27&[=HW\L@Q@:#V((;.$-C_X17O"4FUO# +MQ.V/$C>HR]P5^8"8P)!)K:_42G=R.NO,M1NWQSCS'N>/F5>`VU>'R?T.9E\! +M'./E(.N5`O;Z8^9,(9\&A:6<5;X2!MIE^\C=!$W`XH(%!LI,F.AZI1_C:M`A +M4)J0_*X(QD?ZZ(HS\(_YE437DU(GK\06E$LU0I#ME*G^L3&X917<[V4+93], +M[C^3-AQUBIS#)B#DYFLT86D`#*-'_XA6#/3F&S*4<5U?L7QB].FSNXI`!*N; +M,(^K!PK$"X]-X:1@..+1/Y;"Q-MKX+6[\GEWDL]1-.(2E@>NO;86W7"$H!MVV3ITPQV/;B$K4JD#SM-7L3I@ +MG=^*AV!TC05V13MIV+3R,[Y=RYF!67*"$P\>L83%W*ERJ\IK0+'HI\"6@)XT +METZC&3L-KVF4UF#_CE\=_OL]""%2XH@(*<6VYC+)USXYQ[LU*&DRK]@U6!0*GQQ[D5+#2ZF]F=1H2\U-^&@"--$U`3HN^^1=1;S) +M05[?OU9N!:Y$@4>C0,E%Y@4[3%[12*\I+6VCI5&,FL\=MJIZ&Y8#H1-/YI?9=4_ +ML%R%A)[P;;QY4#)\H/:0(_KYRF\KI]=(XJP?K`[`&/21K2I2G/A%%EV*#PVL +M'>Z+0EWTA8G.*LBU8AEC8DQHRU-929R^0Z:D0`,V`96@>I[^"WI[E2YBD8O^ +MYAJ7VH`F_EIAJNH:&A)N(;G=5,J@]S*D#-C)7,8''3K_V=4J8:$L0W2D**4= +M+4YT6A[^>;"S,R4;FH1E#+W5EN<^3$[R8`%U5L&".?&Z16S'XQ>28+$ZPA*D +MDFZ,`1JL&8G>VGK!8\=W>`;N^37,`-:]SFAE+H.5"B7Y$AH=@'P8KT>-HK6Z[A#RL +MYJ:/YO)P/-+8BK%N9(YDYF"-0K+!X?3S!G5T4:-I1$#?>B&OU!J!S%(XJ)89 +M!I7%J12%'V.^<46@N(G:)"JQA3YB)J8/W# +M`B1A2JL`55S?A)#),_;FKM9FU1;>V/N^8]3@-WS?*RS:=9Y&%76`1RB=1[5[5$ICQM)&^#V2021-"DZ5WCNC+[UFRF7A]QIW +MQ7GTEWDOYEP!8;GCZ_[\O%6>K%7O%9RUL.ES2ZOX8KY!`M"V+\4P]8J'7('K +M3;8V#2;%`GF0T7W0$KC(CSMA<-=%+NP=`W$>N^;SY/`(FU[Z'8:'V/,+LMH@ +M_Q"9%8X]]J\*"=*;+:,]T%O&>A92J6!F9;O55Z:]5>AMC"5,RGOAP#=[K:M: +MW9;0^>S7JN3!(\Y@)M*I69J;.57#5255G#'BSR`GE6\&C, +MVQ@QDI(F^CW*H.C0M]U#'>/&D2F$3M=Y::^/7'",BY.RB7#H7O,/6_.J.`N_ +M[$O^*/MO.9N!8TP6/>J13Z<+N/4WY\A'@;&IEB)04A'5W.B4Q#!Q;!A3\!@X +M3]`[C`AI!Q#O`%[YZ`ONS^2U_G)"N1@F;ODM"*LR[RY[96FR5_%8VW$.7.%"D8ROZM/W-2,G(SL-Z2#70E/G1&!V@`> +M4EBAC<.VPR9%K[TV.-X%(OS$V]VLRL0,\IE4?14C:`QILS1/K2SY0-%L6QY# +M??A_-\U`F[$[;IR?]TM@LV-FRROL?T3W]J!>1RJ&$Z/S,3DJ7GY5F#RZ8"IP +M8GZ$SZ*TVF:3H%)GF8,0S]D-#^NRE5_^-T5V*]`./U7[7=S0N>D"0Q514XD, +MR]@\_Q;!00(\H&@>&5^MUW,L!!PZ(_<6#)8"WOF!$UQ%T$4!$,)C<^3;@N7G +M/!!,IBGTD,.COS$=PJH+!'#:#H0#:K/3N=7(-#D`7=2(0Z+30_%)>KY1ZVAX_R` +M.PN]D:)0%F*5=$''N"VR-*7Z(@Y?A[4HU1AMKO>6:,!FT7GERA/R7'_9H8X=N^ZL;5+H6Y0]K$9 +M/MI,.HSD^'SY>U@QPWDY5\,/*R5;\Y&B/_;2S'WL1I+L9U/:.7?>#X<91C!> +M.I$R:&*JF6V0(!K^?CGK,`&[Z3]?.W:8%75:-.38-(RS^*PP\=IC=%1RSFW` +ME8?L940U._Y]![,IP=64`$C,[P+5&Y:4`$6H;0>YAS]!ORFH`18D^GC/`./3 +M,50>#11`'#*.QA\%UZ/#LT@^R_'4VFJ&G/D57[U4:C*C?$NC[`^B,G!;8NE$ +MY+O$2!`M-AH"^KT]]S=?F`CT+WV*M8!,H%A]K#X)L"$]06P?J*S8MJ,H-5.: +M.GM5,!.],^XY@68_H&)=\1&"@)`*VE)][YEO(UQ,(X +MK6^@@T4[F8S^0;X7$N5Y$REQ_;8,`JM2"WJLS8:NICEG">I"*!88`(VA-XD; +M&]X5U('Y`A!OZV:3PF4!`(J>DK<*CJO-BUCHU\XI1\[.*]J,Y:$C'0&KQ'UX +M[(/60X58\0"-91C6/LUV6P]F7+;CIB39#@*@%M9S7B=OFLI.U +MG*%*>R9O62=+FXPFF&C#!JV%67ME_#EOQ#,H7]F(D9,P^=5#M<>`3"@RAZIM +M>J1M=(V+<_C^0V:B==H2@O3DD)?VIU^)4N7]A]31HJFMN79.!7[R,-/:Q/'I +M?2G!`"3RO"=4SM!1YY-93E/,)=ZO^)>FU1#75J:MNZ#Y1IQ\G54O:G +MCP&ORB(,JCHW-\Z,6VFZ-$_:DU[#W/.19/$%ZKF:($ZW'(&P>XW+PC"(B +M,@IP2B+;*@@*"@:;F4[!5R1(L88-R=P2XP:S,2M?H;:F,FJK:U5!D)<+?YK) +M$]H2%L']5Q9!G%-([GHT[ODNN$G19'?A]7DWLXJ,)+R^X*8TM,G4(9C2.86J +M$*RKKT*@:^A-.519S50]*ZK&5XI16EPL;3.,/A1#CYIVQ2Z"A<9J(VJ+G("O +MPJY1KYVB:U)SD=6PO%\7[-'GQ3\2)K]TI$(SBX_;`A%H<]`"Z/CD/\N'R:4_ +M9LYF4NX^\(?+;`L[AU=1_[FO&9R51T$X^$Z_H +MJE5%7#!@_?39D(@@5BREEFDWX#)@-3!ORZW"E"R],:_;Y'"DW-,2QS<>&',0GCZTHD\*:+ +M)LK@!E9!C=C`9HIF:.$L?N3%DSA!+:^`N^SXPK9#Q[^F&J^T;5MN5`WBJU,4 +M\WYYD&)6BHC!PI)8[C0>#A`%IW\#E#NG]2.6C2-%[3110,"BI:A\5!T/T0+C +MOBFN%>W.)`']T$AN@UVYBT-ZA"@PW$0B"C'2)$:7PNWIC"1ZHPV,VKOB623D +M=^Y;Y1%#\!ZZ0J+DH7G4I_)9N$=11>BF#"(.,&F9X22`#K +M+?JXPHNJ%(]*\J-35;Z0RI0!744["95UP>-K1.)F)*5V%M9X_5N?H/W6')-> +M0RWX0U4EW8NE)T^K&M.19QE$V^%?8+L.BSLARVIBQ5GU%F3=@[!?=*_]H)K% +M$R9.7ZB>J"J94/77>KHN881=.MA!A)14P[R]XOQNKQ[#-JIET6D?;[ACF$XK +M1Z%C2MUPM:.=%#NF7##)=1&WVM*@85FM7.MG!:,I.)6F,U]% +M*DRUP!4E9N*]5^'U1NDK2X1*XKT_Z=JAEEZN*#IT.,7-%OI!3]`JE9*;>JR= +MYA0Q`L:8N->CZI8GME0E'O]Y5:7KB`-%* +MPJ8G?H$.%%2PL1`G\5#Z#+MC.Z"_@,XJ'?4:2;[P%"X9TDRU=Z>UTK1@$YE3 +M4LUI/3MDZB.P6/-H9>`-^U&=4`J=/6=419OB\&Q]]1ST[:/PFGC`B7`NL/N8 +MPV)\=JR,H&F]X]$6&.L6>S,E\E7$R/>2T^ZP8VHY%((UZO78IR_J4IWTAF1L +M5-6]KY]4X\>=D*6\8C+.LD$S]D22G*H?URN@A0K4^"*?=)RD#_6"WUU%*Q/= +M/CV1$6&=3K?1X:<1=5M;`-ZW,EPTZR1>- +M7WH0D\W5%4>T9B1,_,=;S2588RA:C-1'N!X"O9^LK:>F.H59]F'B\LOJC287 +MC3H0.O_\8IU,3WQG";+2J@PLZ2-F\;:99.U\/^HUH@U;K+-*:/H=@2+]I;*\ +M+.+]SL"4Y#TD]S?D]S6LX/57Q4*F4X6F]WCV9&=\JV@;ALISGA4C[:HX5XTP +M9#%TKGK0JA/N#W"%K[*).<`Q^F`$BR^+A9&L4NJ<*:$E'=<\NWL.PDBN/J9$ +MIS'/B[L2AO+-C,38:9)<]I4HM[MVZFHJ+9W++3G#H;/I]\O-8K2FC +MPV\_WQWS5+Z]-$OVUTIM_J#S9H#K^Q:9`@2+`YLS&,6=4D^Q\'SRH]_)]+6. +M)-TDFQ&BR7#(+C#J:*0YOWB:%+42G'6D%N7CY4/U\4G5*PSO"WG)K+*46WY_ +MJ_ADHPO4^#`]Q#FEU5+&E@+9--VD*:K)-B8R&9]JRNU2S,XO>AK.-4BRSYPI +M9@S/<5^9"#,D<;&23#S#3R>R,\8"6>?\2;?ZGEOD9"?S``K-\?G(%A:;":PU +M8XH).A'_>+X"N>BL9Y!"H?/(PV;!%0N4E*-(X.S`DO72.N$&;;Q_[8O!BYH@ +M('5R'1O@H?.M'UE"F,"CJHB1YU!E:QPV37[I-53-M#;C.*/]+2>BT?R)0DB+9 +M5(%22,==<>?\O$WAF_C>,Q16Y\0@P8C6#R=3(UA,![ +MCR=\XHC!)W(<%09J[W_WRFNR":L5UKW'2V8XJFFP85(PNI/6S"/-U\2:P.(: +MGB!AWZ'!;"'#]>YJS4^J+$^RZNA*T_%7SD;FO4$&SL>RX!C/X8P[6)V^R";L +M!IR;6F(@>Z'&.8#F$_.#;?M>GW6ZJC:7+R;==DE[Z+1\G?9=+,E!_`]Y0ZI4 +M*_*J$Z'M]GM17:0V(;.5QU#)>IC\/D#F<:]LD&7LM-W7.\ +MOJ65Y`X=8HO@GTNK[?RI2BQ@^5B)J\3&_N54K811-W1Z7JF96M=V321?:F/J-JOX,-ZC<@38>N1W`..Q +MQ68%7#Y_4BY,7+0GQCXHV6*U4M%A?30HXX3WPOM<]R`.\/Q*XHO_2A?4V@BP +M^JZ=?7S6&W&;TLJ;`1.GJ7O^DH(@4&#.+C^9\T=37-M9,T4H^6.*3=&1-W2/ +M]N.EU%G,,F3$/(X,+5JE46T'X(F5M:NEC(JDKV&"?.B\_6S% +MJ,2=X=L8PXRXS@[HU44B'5Q54TAC=B!9$K7ULK_ +M2DSEM7NS-=J^C"V7A?CI.;CU!MEQ10N[XORTN\I&AQ#I.^__1'NA4?HPSPK2 +MJJ6\^L197\(;UA+C'NX0U\=Y%XVNE.;AB`>>J*G$MI +MRTQ3I#`ZH#DK?BE/\PY8D3;BYX#-?=S,N:8L428?)I_9U[)8`](@U>M;:RT_B]-BU>M:;2=%8_O-3:RG93_EMMM=,)_MRL&I+S +M866LO$V@@@NCJGS0Z[6O+J$R=BH0)S&HT#ED-T+*4"W/+38$$O#0V5*1A=$[ +M9-@9>'Q-7#=T]OI=E=T\]H_V48O`Q^2DW917O@KZPEZ_\?NLI3[1%! +M>A&^/.G;.B8`-W[WYB6%$6=!/R)2D03 +M&',=..(CW?9[.28H(G944`UAU17R3(*"8H>-NRVF4Z6$C0%`J#0VNF]N'%6!)8)*5ZLO2%`X3*Z[,X,[E110!<;(EHLK_9F5 +M<;NVLP2/^>.AC[0RKVQEOXHJ7TO^PH!YJM&'BK-8G=@;"' +M21ATP^3.!Q'+0JI4PV2ZTZ^7"$LO31B^>`8=MN18-WE^\>PO>*D?9#$/HIQ7 +M+J,<['",95K!>:1C0/*:82$28!G1G\?H'[U/Z-R7L#SPL(^2PST6_UX.3J8^ +M#^F,5"D-YW>W%/)Z1[BB-N0W,C/_\A_J8-3RVVLP.#3,L*3?>+"G!DY1U-2# +M#%0($S??I^,YC>I**+DI7!$*\ZL%X\U75ZT*A++QN#869ZX6B=A&I`&;15:\ +MLL;%SUN:/^*.#E)!N@6$>E_0KWRI<*+)1W.'&ZA[>OEB'0@PUZ1&_26M?K'K +MX#U]EB9&E/)3B):.,S$KAF^X.)X^AS$?'=3`H!",\]>FE0I2>Z?>2+1R"LD< +MMA,*T1>N@^!P1HQ[0ARXG$0X]E_/S.]C<$M&K1TS0:`;C;ND*I0)_ZL=]RUZJDZ0)WFM8[_172IZA,82UT+=>=CTR(?(W<:&9GME0D=Q +M?HGK+1!>G!Q.,(B$/(;7)D)O87=GR#BEEG(YV3_AVZ*N2PLG%DE'TU:P"=8T +MJJFOMM:<(;'I#YV5;\MN:;`$Z%>ACCRQ=_W%^WKD9*O@U[[>.EEF,@Z3ESVUL]JJ*G-$3J>7%X)#%\2G^!"XA'PFB2\B(\B&`,0!F) +MUICX'R:_9OR(:#RRP\S,AU<*MD-:%F=.F'C_"2]/3'@N#C^'S7O1\-KF3O*) +M\%"DR2KTLAF2^9X`9[`D1\0%.6IW.$J7S`L8&CU\HD"I&"6+V0H%B:;J5:DQ +MH:ZO'C]M/3W>DAUI%ANZ8`S\_X"7'40Z"XZ)61'[^1:^B6:B\)2Z!X4503NQ +M(+B`3Q\Y`QU=(-`0J@0'2WME_&$$!&J<_-HT_^-5YJOV546U.K*@E*(MJQF9 +M2M.4=;+?FK[[TTPI;)JZG\1XJ6OV'J.B!A3#SBN$>"SK&'27T9?3V'-"G8V4 +MW/7CF-"C2,CB>?CD8K_L:D,PX`>:F`R^KR4F2WS[!S@%S":*R`3:I3[O:746 +MP;Q/^23W:8/5I^2J2>1SAE4$?2;_L`#6#`*EJ*?R8>N3PX/KY_9Y;?Y@X*6@%Z@@ +M:5*X^PN#)61<G],BNQ7IVL*%A +MS8&(@X70'C$A:I_-X951970/3UD4?]76$6?:7SAKF5GW"4JHK?8IK9'&],CO +MAEY38C#?:,<715I/D`]]PU9QB$#-@.(0?^)#U6>*2UL95"6WOY\2J$Y]1!67 +M,32$G!EH4'G2NEU4Y`L+O"&,%`56-$]\N@U'D$L<^0BVI'(7IL_D0J(:3&C: +MQ"(OT-SZKUE!15-L4$;35^FD=.1@WBE9L%)P4`[_!A46$]]IXJ?#F_S@5DH4 +M1(0'@Q&S5!PEJXP\)B7/]#$-KTE04-[N_0:1^8G>F]LL]#6[+8PRB;TH+0.W +MBD54C[BLUJ?MUF4;N:>E2D.GR;VS`JOM^O0B+E]M^YKM1O1]JK(Q +M7G_:*IS0QM>I:L?-4IF>^"*#7C9J$)RB'8GU3R;=>&&FKT0-S.D(A@C=,A3, +MX1KVYET;]'I.1TMPR"%TPR&'J-XTNBZ_55WH#/Y_V($Y/A7O+IEGXG3/!=GL +MQ6[EB=CZ8=,5OJU9Q&[CY?97^985FWO.%L8&=S(NK:UYBJZ@2SP_/5=0[B48 +MT\&$O-<:)J_O![VF%0E^X3?*Y6U%?PI>*L*I`YGRCEF-4$];95\')M%GK)E.:H.'/>'Y7K +MVF;']L.FU;NAHHI4;IK+\^@?' +M$9Y<@+@G+]#%RRB>T*B2B/*'FP#R2.(57^QD]*&ERJ4(EN5JJC^5*1+5-]H2 +M.YQ%M/]$&J1>-3+J5\3P.9.?SI#5,/&[>U1>GN&.4E-+T12B^FS0U5@.V[SM +M1-((\J#GWI+**&,TC_+Z(T&BALLPRY,.`#0\%*-W8G61@W@=9\9.&4Z#BO/& +M^TO*@[SE8C5+$\$O8\XZ23ZW$*]S3)-%>8:G[L&\JJ0-J,K4K+W$7X-,\1/RU4DEZV5T[_M" +MQWW>&@(JH()T$*RH6<46I?(LHF.W^6]75`I4B3:8DM*[5A_[63L`X0:/$QQ0 +MC5-)1;F0V(4$OZF\P%FFS<=[I2Z&A\H75!4DZ&-I_;VV<]T._OB%LU:I4KPK +M7_R2F^%O/_[N@RUR4L''9JG:X9[!35+UD1S74&SA@]VD:H&VMJ;B!+_?U)U9 +M.[+]'O:4EGJ\7X2.VF?XR]R$B!G_@V;SWYY,:Q'WZP9LVZ +M)Y^Z9IN6.Z=>N,WD.SOQ)[CO9?@!;/DIF[KG^F?.R?0)_T)EVUO796.N_=B733\VT[%4)[?;Z([&7:([N"]G +M_O86Z(O"7C=KA6J%7'$MC:D:T6NW:CC/YJU+*MYA])34'9O4?K,?P;LN]HW< +M&YQ]J.SNN8>VQ*XX]!Q1SKYXY:A-Q@;]'/C_!AUK^S_L&/1GB\^/W4E7G]>Y +M:[-=Z$@MB'/H__]WB^)L(QG-*!W6<)3&?..%CS7LY=8.\Y@/-W9M9IAQ(9U# +MPSMZS]K^SWHFX[S9#@2C=`G[M%7+>^-N5+?VU.\4JW,S_66.;'?,1'NV:]2J +M;()JIAV!B9/,(,05D%'+H$S2P.B2:Z\%C?2MOCXMK-:NO6:;0_?>H&4:"M%K +MMOGL^0E"#WSP0Q"`Y#KB`SIT;MX&1/XZ.7)S[B"<)2\.*9\&E^^S*Q9),7B" +M\E`A.Y.*6QX,G45/D3N+V?"518YCA]L"CY@@GA&N@MA\I-AEH11-))53/R$' +MQ\J1>*Q`OP,YC^H5P\A6^V(5-3&98N]3A20="9E`+V`$,=5:]4OH93+I$U(( +M'%UJ.0K)F@IR,]=>O^N+/U#T9#P+N`+RR&@B-9+%>XCPP(,.(FSEDLN7B\LD +MIA[%AUYA(_O8L\,1%SK!S2!S[;E;K1N5FC2Q/4S^^`+&I6,I(F?9(VX66\JV7 +M":);L.81E;$1YZI7>!5L7B="3>_.P^:7(K%!_,@M18HA&@,M&2':__RY&.)` +M1">J(X)Y(F*H1L8"=/",J$K9R;13!XYGW5EWPN6(YTE1O0F&L7=%\@U/_^+)U#"='Q^0^=O +M!VN2[@EY+KWJE=`8RJ99!(RRYG#5PYM\[!0-G2C[GD`A,7@CQ4_(VI,*(N1& +M1$XHQ7>R/%W.Y;BT'O1EHKT]U9([KE@L%,VJXS]M9=SDD#OGOJ_+^&#%-*&3 +MK.$YCBSCAV7FR0/S\\+;6W&N[$/KQ)0$5ZL%/2LS'+]$X%@IG:.&7(WX!M:+ +MDQ?\'65`'Q+V$5C-5'SE^1]QYAY0YN2T3YZZJ9O?B8.54G>,@]/&<=]?=JGK +MGF>O*XKV.E][PV3BD5<5BZ#!:]V_@#P4"C"(0R+`)8F%";M +MZA6%NAF#IU:G#4-`JSROIU#5$%V*.?BOW\;N)5G)SNNKJPSV\#$0H>_QD2N? +M4C4L$IN#Q^(0FDJB%$>%U74`@4PYAQ?3LBE4$R_OH^Q'J<"-M=2/>JS+4+$2 +MBZ6@;`,^W8,.W,\;=')T`Q>-+@"ST:Q1/NIQE0X%P\&LH'DH."P8;@D.Q4]M +M\(G#*'1PB\5(@`\$^(RJ%E3;@Q/0_83%8S%UXI;5LFO!UIY@QU`XA`)CC\NT!]4W+>I +MVZ,D`:]ST^)^Z3=^>ZC7$7F=A]*75FFQK6'5.9)]?8L*Z^^_$M?J"(PYE42# +MG$&Q8-!EB&;&Z?5\2JIVMO,@Z^);PD:)_N^A\=@;,*&W`19"I_ZV9) +M`_%U342NH"JY%^DPL?ST00JQ,F.,7?<03M\+3N7J/1$<7`PR:J\XOWE,9=ZZ +MNLBNE2*%9&#'/J!V4DV1):;T-.3`7/T<]1EGT9Z:83SNI-WV9HL2.D;A3CD[ +MV%<^-8.2ZV-YL'>*DL\ZP(7<+*(\!69.CMR`'C?2++$.;C%@I(2OJA!10J'+ +M;,+ME?&W]G4)15=OY-4T!A+XN+U7&W2F2W3UDE%3A_D'(5+9SLT6X.>:Q+(, +M2+@YYR,D`O%`!(H@!&:ASV?/K\6+G;SIS1YUAF+A1Q.L7%@`7#[!@I*J--$"1'B!:9NH4 +M@?W8]"P6RC-K*++(H!"]T':54'MMH))-2KE6I1%A-WKS3F)N!\FL[B^P3[^& +M9%YB[1.&++2&*+.T'*II;S#R,(U&?/H62YA2>F,V*&+;DP=D\7TXEJ`8XP[( +M4JD*/Z)4&%HZ<%#.N@]N(?.'>$O!SBEYFD+:17*^CVP4,)>>7L;443CSU>=F: +M18NP'M2>'SMJA5KCOMOGQ4N:H\;^UI4,,[-&*5;0\*TKD(>37.L'!(OTB5P)[-NJ3#/H$ +MP-!FE&9H;\/!M=)1+;C6H*JZBB!Y!+*/.-\].:/,CBB/$,I\OP:.I17M_T-# +M$LQE&=L6%^0PVOO\RIQ/N%#@S(:EJ+1=7??6Z7G0\`6#$I"^DE&\G.Q1Z/53 +MNK*7V*XJ(5JO-J-`AD[_T8BG:2#52-'`.]69K(<$%['-;Y"\9X#U$*J7L6S- +MID5'KZTTC?.K*T`-^/"68X>5K8D)]ZV5IH_>@H6@F.^,(\\UE"U2T`&#$S`? +ML"V+Z9'DX,NR+((!L/5_4<%D1*Q#E".7@P]:=LJ+I-276E^+^<_0^>9S78MKTDP"J#?K*6H[XEQQ3]KS4\5,;^!%]HQ& +M:BRQQ@K!ZWC%10RT*OGAAXFGKYI@J0U8FMWP^\I2;X$QG3UG1L?: +MRAX?O+RBTG3MD;#WO>S:R@Y?PR%.-GVIAV+ZZSBFK_I*^LUZ@A)0K19L-8NY +M'2#(2`6(H)-4J2="&7.\AS3L$33LDG#1#Y"-!GLU=![>#_THC9>+Q1PA;TZU +M;,?N]Q-1?BMP.YIKAIX>$5;_WEGI&4PK]-H8JWJMHDGC9(A4JHR%?-U2_"0V +M-%K2E=#9=SZ3V"(`4\T[(2F=_1Z!78%U[DJ:];5NZ&2H,(:,F;DSKQ,KD0S$ +M?M!%9@6,1()/LX+)JOZ6P(WZT6?8R&9L +MZ3[2U@N#64UPPDJN8GFAI:FF:P*1[?5\F3)#CO]3#8N&?AC!)[0:[Y>L=:$5 +M5%`.79U:@X+;+4('9WW33J5&$&X6$RYMY.#T]JFPX->?,3]OG3-*0K)">OO) +MJL`Q5VHEAT=6A<1SNCAO5&J#99"VJL[K;!4>[]!YYGN8-5^F&E[B,(E3&(CD +M/N4FL9Y(HU`>1)/6H79#Z"Q^J?'>P<-(;0/"C!JP2>B<]H`@BNSE202J8>*R +M/BK$BA#AD,]<*C--$\=),`@C;=RT]J8+D'OO/Y\GH-UI2+^4//[>.I,&B6R' +M56:S7:=&06B2'Z1HF`MB<(*X'_HF"/=)/I4=U&H;$304RWDB.9/V:D@N\PPG +MD-P.N;/:RE0>)N6P3"1L0SYL2FZ[^;"68#+8"&I3R;KXZ`.X$,MYO&@T-1YO +M):^%H$XQ/6Q3]^2`W-6F^)GTQ$JHH>I>!NHAERP9]%+5F:-W%7_'CDI=//T= +M)7N*<31Y;8,?;=L(Y4CC%^]"9\7.>RL>B,1Q!^-U*E6DEW,;AO$2,[[4I:I0 +MTJ]6:@X+!UL3@=WP_[474ZU9J4#)@6F2B$G*78HT#T5*0HDPR--#`E[7CD:Y +M;\0CMAPZ4_?CR!/AAD&R##TZ/V_XEYQ/_%2-&.D+*F&V%QU]'M7?_@05<+87+JZ>SJ)2`-NS*-KPJT_.%@7@%,+3*,0.7XW$24BB@PL92`@O0:'Z'> +MM:'C5]B=K*G+D0/U`)6S:3N8"U:M&7P34TS7&PR=>[ZD>T3L-;]YAO(\&/E& +M7'INL3B,T2@4_\,6`O-O9\OUJ>0W@.*!96JDK#W!G4'2^CIE$.- +M9O!$]AJ2>'*[L77>5?Q8K!,!0^G)JVQ#O +M^?DP<<&=%/JK)#;.Y.FCPV)UY#(7M.75#4;3R#5,=(DN!E&CUG+<&BR[:D99 +MUC4U(!INUXM*"'4K59R%/Z#N8:KSMG_NHFSVNF[BC(D=Y&H^ +M8*G_!Z*%6I*W-(]QX2%LVE3K4@9.&+)V(^J$FF=46E/UR'6A"F*;J"37W:LV +M:KR#B0N>&F73-E9:X,N(B&32S*_,(XB!K*O/M75Z>ADDZ[_K[S:?(^NVL<)L +MH-TS)Y?Q6YHE$#H_/%&]F#;O.8BEUCX.%R$;W/RZNV:7*LFE^^,F;S-$1/R] +M<\EO?:^$T[7?C;/A>4P#W^\V6G(9?2"HE.28B,%^H]OP@DE$D(>W@-RX:C_" +M#@32&2Y-J(*Y,"TPTV2OX_NW60A*2M<^)&='(=4!A@:-D>VD88I=I/QRJAWM +MX\`E%ZO4!3*&&"B9![]&VG$AFKS!:>IXV%G*"SN,?\`>[X?_'5+RH)_E0"\: +M1+/(/]L+_\6+7(M?QPT3?WY&<._U#)T2FX:A+*:M@6+!VH\_D?.[=C*I?)NS +MWB>7O@[;:#>E<_?96C^3F8AJYD%/(\>Q0J=_^TW=9_>U3Z%:Q/WM'><@'F+G +ML*OB]+W%"P(/V0%7:?3]V[-O=X"J5R`S2:G5/GY83%.X5D)0^H15!<%Y#&;6 +M#SP/.YJ*PW6#+3-B#_%L?D4T^4>2N;_+>\)1"GWR,6M5N!-4*>J(XI4P:`1< +MT,M'A4S#Q!-'U2.CQ.N!=B,:)"B>4R.#3S,+$C&INX\:4E8CW." +MN!EH9,EJTZH6`;J31Y\1YV1FBKG:4Q*I,JFDXWHLZ=C6&]B5C6*5!,/$S^Y3 +M=7DL=Q^.*1-CDC&*(BC?0L8RFI=F@;?&0Y9NX)/;A=PX6&S`3WE"^F@J3+9E +M,WTEX@JN"2AU2D!ISZT+*!UYQ988D4:9[:2Y-FAUF%%(13T\DQM"T;_>^@#895O/6OBYD*2#4"E<: +MW]2=R:>$3+%?G"*L[G&U0='MZ?`SYC;+'MKD0WI_R[CI\X%U=HEZ]"I+/,-0 +MK&'^N1^W>T<+G"YB6L\IR#;OY_.VGR6S7_-L-3/R=+?^Z0<_>9L\G2:I_OET +M0=WSN:#FB)/[<1Q:B*4GUS/@(L)=%L5XZC&@2Y8AI97+/E)L#K8NQ,::U&*W +M'#^,GU2]K8[RMFXP^OL>?O2O[/=M-.)T2=T;GX3G8IDY=L)$>5VFI/"(Z'_% +MS:QCJ"3)=.AI$GO$(RQ]$VDN"*(6Q<6QYF$A/3ZP,OZ+=Y\`JSP':UIX+[$P +M)%-\X'HT:ZY/8\>,$/W+NPV%U(@*HR'_G'1A6,HGO.Y'"PWG,\)KXV'@D10&)`BWF6JU8A>93W8?+GQ7B-.W&&&T6& +M1M!*Q>%(A?12A\]`C!:SURF2BEEJ"]I_,(IDG +M#<+HB8?V)'M3K2]FE2]3%>%UO,04NIB4,\ON:].]33<(MC`BE)I;E2'&"BOB +MCJZ/:7]?S2I?EJ/2B)/J_1IL]+I5$;SBM%ZN)RH^%2C?\[6KN4Y4)'ZZ3AWTK(,6/>@9Z[M]K.U[ +MPSI(@D%WHICRX=C1`\2Z?\V:UBO!/-]3UGHLH'W'5#?;C]&4@1QW@=7LN-TK +MP4X%#<>E4$+PC0[-2D':,6^C3H`@-6U?V]@>TI(19/6)WY/_CQ!@Z)EA&*>N +M78`OUUX9=_!V*DJU5Z*RB`B+_!(AE[=6K'H/36WGSS%7H0GMD& +MAC#[U4J%'$QA^2+)NJ!XDA0>TMXA+M]GY@[W;IBH%&`HL``4G=)Y98TGOO5T +MIL]Z8_H&7Y7?7%18,J4SB-;[!W*`*6`&,@0$*P99R$F6=>)?[1$BL8[*&#>?W3Y3Q"12A(AO`]R57` +M+`VT4Z_^(]>2EN;-26+R.4Q@MNFUJ2!:;MLK1Y"'VXY)9W9,23HL<6Q9>;0% +M6=U\>XOX3%&##YZE+=3%L1A>#AE@% +ME+3'4).TFT\I.N@/CYA?(HXC7:V\#/-UP#]XY0F\!_Z6.I2*0G#`#8AHCDM# +M6NRU(%2./FX^.YMI66NB+]]K508];FPV+Y?[(#-+_D1*1R`($1EV#-;VE%"F +M:V>NW4B**ND66:]49-*!QM9-4 +MF/5HJUD^CBWM +M#_7V6[%!1AU9L_"M8>GJ.9;27\D=,N"YZ79S63NF$+5L=ASF>8@)2YR[/>E< +MGSV2JQ4P0QZ!^]M;JI@`ABVKT!&VRMA^^,3L'AH]KM;RW",=^K-I0(]?Z +M)#RB8:\U,0COO]`Y2_$TV&N6CQ0=+1`3&6UWBVQ[3V*5)#.5]!_#RHP(B<1RW8 +MIFLA1KC%[W`21LI+(]Y1>Z*E$&;$3("UG)U6C*R9WZK5T)?@.=42.C^_@BO4 +M&=R28O7LF='EJ_2B/*&8""T76&@Y.,BV><7B'2$S+G1:]I,*`,J*!,G(3Z&$ +M'K+#H;L4K<>4$E,T6^__I2PD,1`9_E('^`8L%L^TARC*-*BWMTVD$NG]Q#N& +MO&815[.#]NU)D^1#F#13HQMSE"@\U-4`H4-,1LBB'+$W>LR'[3O&]M`.ISP- +MJ[B#97(_2N7AF4/#<<'<'PRS>.Z$C_#5L-_HUM/88;),6)WXUTX&X/75-MQ/ +M#?>IACN0-[2F87VKU3"_0/P,A*O==#I7SN+U@\&9L.OQU)[%[38?%@RV!,V' +M!F?2(;!Q#SC>X3^7;3/FRQ^M=J!B!.MWYA^003Q,'G*7JQPE.B:K;)+DR@D< +M(427228=V[G4#VC%.&&PPH_2F;A^JVD+MM!N3SX%=^S3#_*LAWZA=\4?68"= +MC7UOI2&G1'Z\E(_KV@OYU<]I#3);T#=+=1=YJ"@'@_=)3[`\>D]Q3 +M_&1W9ZKJSAQ%N`GB\"_;$.MEXJ4L/G[4F#Q=J:/M:M(,1BA,/'2R"MH85QM, +M5,DS^3&-U3+56)D*U]VQWW%,0Q`FCS^2:7V54Q$>%(L>X15Q%Q;G9?)RPG$Q +M@W4"*VI95"@J>QXXTQ\T':%"M<_9@:W#F +M.>3-AH>*RI!IOS6Z('^<9Z\&I<7=7C).:QGHNJ@;WF*&7]51(NWWX<-H:3%J +M1[NIQ!V%S>09D?"WWR/8T%/K0=9HFLIMY$5V3&DQ<\JO33O6>F7>"FHG!'Q, +M6:,V78W:L31FBC2D!*A6K6\C%0KG%NB8@181^WW-F0F_2-3L8NT?YI;"LCYF5P&DS0D +M!Z:"=Q:D,96]%M/RZ5:*<%CUH(LT]0PJV+'" +MZECGUG=,]P4[IGMI.M:QI8YU;KEC9OD=42>$P\0I_:!92K7IS2Y%T6EE>LD+ +M$SK;?!=6%9H0L%":;N`-/X'KKV/B_6A-Q[:^YB()DT&?J;*-IW:>H+=]H@(W +ML(K;I9$NS5C,5=W846F5A5-)[&K_+AF,.X%)1OHU$AC1QY/48',M;%R/!4L? +M`\/9N!S9XPB*WQZW_$&70#[S'6W;A$YQ9]M0VU"'KLE%B(BA"L*^\#&ROJ%( +M&DBS")UYS]<&TI+WO`X,:1&Q_`0'-:DC_B*Q=.(ONFN2/KH8PS!?;8(;9'3]' +M"2V>XKTGJ;B!TNG:%"(-(WX\ISJLUZ9:P?@>AY!I_`V/E";ZJ\5X&MJ9=M[5 +MC48(TU5'$C?\0=XC*$4QP%F4"[`N3TY"09&,1`0CH3H64\^O_XDI7*S/3WN@ +MVRM-CS_.Y=EA-V7UZS$D`];6I!+Y0@*S. +M^`04P$1Q)J;2U`M2XUU%Y=K77K_;AI/8C.["6\Q^J-,-:1M,D*!=?-U?VW!T +M!1Q&-]/R,CCA6HQOH!7FT1I*'#OHFKJ*&@TGV%&)_]JP2)4PVV;O&ED\6(;: +MI@AHCDE;4)M:XJCZ4?JELH6:7CI"J0JU#9G^M%;&7G)KWMI!J*CIV7>)2S>N +M,A^R7UQE1@@.;PPLQKBH4.050KSH\+<%UL8F<9@0R4:,-&@\Z7E67`S)PYLR +M(&A4H70L:H'Q=QAGSN4HGYF16ACK)'N8XQ*P>`PC`ZZB,.E/P4!]D1Q#*P50 +M.'[ZA)Z`XAGT>[PJ%2>QJ?+;OLU+S^3*I(YNZFTH7IA.1(?3J&?1,#-^(-N` +MQ>4K3,?)_9^B%/Q77IGG^H0>0?$C;Q<))E2GT,%8=TR;/#G`O#T==BGT50CZ +MCHJ8APZ_0[]N''Y3V>$WFPQYX7&6KD._T?M'76?!:#L!NRJ)?]_`P-4P\>_O +M6#P_&VH0JQE?>)22.__QN+A\$:540>D2*_\G+M>ET5IQ24%*"VW*>'GSQ@0) +MG/G_$I!Z\4`1DW=I.TK_)"6?5YG)#K1[,)/J[=`YT1:_J- +M?63+#IH"/W48/O7^FKL[Y.Z.QG?3SX8G74!=B5<^@:`NYAF@VFUN-&'(2T>: +ML0.,D'\>P[AXQB6KQ'`Z3TSA40JL7%RP:]I:14%`2"B98I,XO_;Q'E.T&KTI +M@3YO='UI61;H6OH"9;E>O*MJBNY04H-@>NS9&*43UJX49@=,P=8')#E8YS,% +MB$Q>Y&%FNW6&(EX;/?P"VN8B4M:4SB5&VEG!LN#LOO8.4!'AGT[^9\HY@0;0 +M'F\NZ^?+^N$RJ^YG%^'%$W^ZGSN@>2!@-OY^-.B+/\(>>]$(=`P@CA-"0SK/[Z! +MK$,P@[F'^$+3-;^D,,QX$W1*W4;5HBEV%)"7O@!GAINU\=9S.W@0YTX.EO*` +M=S8>\):[>I9R24][M%OY+ZMBJUS3APXW:*4UZ-=3B)]5L_R]5.G(\;HC +M4_A2NJK62SM5O+1[;YV7-K/?9I"]!][5LZF[P;O%*IOJUYIBO5$'OQ&_!>(( +MYG;*:';HT;1>>I0!(*#",N*=;=A\_?7;-1IG=8W9'3C6HK[]IM[U/9IOO./(C8X@4A4CH]'^2 +M*;@D+.8C)M+MS:"%C9';L^^1L'Q=;6?<>:9D'.S`T,@J@C@9P6:@L="[$3C, +M4JA#8^<'W%4@`8G_=9315OF^[9W_IS=.&?U&OES!=$>#NDD(X +M_K@I,?Y_9DX"N9W.I-%@&"7ER)^I$\GCZRZ^-L/DYV\1>$!M/M+X]-E".%#T +MD+'$YDHZ_3Q";C-LC!(=5`"00*:J/ELA7VMKB8&F`74I!$+M>-X.S*N)&8\2,!=,)Q\_Q#O>42GWF8E%$D!!;" +M7C,QN@+H1.M(XO%_(K]EXK[/VL6HQ65(@7]C.1+=;CM+SEDXI0'],T47)<1R +M"*Q""Y*OT2=LW@>@;GZ]OA)?'B*I>@BC^90`W]F%;X'[_'$%-D/?%0 +M^&'BBMUKII,`Z>QNRFXF-B'!$]VF[72AM!L)!2K8+:C'!WVC/TL56<+$07_8 +MP=T@P7$>+Q(,)>99UB=U3"^N*0F;+H3.A%TY8LSU-TS>&^7!-$P,A:'8^Y3Y +M>;OG!*.K)#9=YX:)WT\S9E\,P;(TOS)?6"T).K[DW'AYS5FI"ZNI)08_A8E; +M]E+>#V2FC/.B8+N*I3!.B`C*X3NWUR1#&C%G.$&)A&[XL(X63'*&;X:4*%#C +MYU<("FWNK5>;Y;V4V-=JL]+)J20]IV*4>>IV_DL#HK[C'K>&"`RWS$`F2X4_ +MR)/).6N6-HI.=)V"@LKGI4^;DC>/F6SWX_I8K[6V>#]N<7G4.7@USDBLV)PD +M^?'AD:/,E+$[TDXX6]T'.V+LZU^SNEST!G6A(^*M-6N]H$J.PB)2:7C+'^>0 +M`U;:O1'+4S/]`;J!,)^'WWKT!$^&C5N9USA/F1*:HCM_0S.><.UF*L!4U!6% +MD.Z$*$7)/!:KV*(]$>!C_T>(T4I7@F)F(=NR+A$<939N&:O@<&N\O.J/WU"P +M\_X"NWM4PBQ3+,:3@I@9%YO6!&W,#]'67R*U&B8Z?7,7K7+.YLDBJ2X,XI0L +M;0,I(IG-4,29XRR8?PA:,7HY]4SDB.R4Z63"Q-P!$]Y"/_P@'BWH^-`>A8*5 +MZF!%P_3;]A+J)/'8!A.R@Z':0*52D'+3OKFNA)`.V=GTU]0/:B!,7H8ED1I` +M_WLCRN@G2SV-P3VB@J]A5]`\]'M=;"Q&TBNOCLR7%;C'K:UYU'3M<3K[P%"H +M,`?3V:[I:JOLCM2*<_">JBZ/($`X+=S#L6]<7L/@U%[9Z:[)%'E0^9#VSQ7: +M(ZHE:WS@HQHAJ:*L>2O2DB#%9"YE<1!=W5YK.?ZNKK\VJ$A'":9% +MD;5C!,;5)@H02IL>J@+4@]S?;0=6.3M/?NN90M_)R^%"TW2&*$G@SJI-W`S? +M3%&B#RE@*;EF>XL'G'4W'&]%"HL"5R-@*3RRXF&UK@?YR.8@9\V9R]%"BM`I +MAKH@'Y5![>19FP5L>976)7Q5B-.EEAN0>Y-.[XW$"@VW*.) +M?8.,'ZGZS?C-QX%V7\=GF:7R;!Q8[HG)=L(8]:T?>?DP!,:Z6I]3\*NH3;7RESC-'#.%,1 +MCS;,!J6*C0;I7X+Y%%W&RL+B2"!%^O0D$JOYKN^^-KN0S:J0%-?GU)VVIW-^ +MQ?GW+Y"F]:T=4./JE8!+MUM<&2S`_I.0\LO]T.%2(Q>6";RH\&QE_/$GJSS% +MH?\PD9DR;G0?N"8&LHHBM#HK05Y#WVW\:Z#B?X[/&9``WVMBZ"ZT0F$[:+)4 +M^`P1 +M#*KID=^+UT91W--A'SH?O5G!8[2_IY9'6B8)U"3GP#'2JC63<)NE`9&_-CEO +M6TTSYN4&:2;,G'GE.[.*0PF!$<)$X&FO4EY&*2?J'^AH(9S]&9 +MED:[A;N4WDWN:::\7::6(_H!H-O#*Q1L7O'?FBTN/WA9KGR)GS$);L?6'^2Q +M$"NIVI0&)6VJBT``PI,R?8&Z['10L7.G!_&6Y^[P_+*3O$FK"$VJBB/W>AYK +M"W7=JGM1QOQELD'L;:6_>,>RXQE)'Z,U),AK'R)H>H>I?XS6:<_]C4'_]X<, +M2*/T)359,'?DE*F+T$R3",T^6Q>A.?<'FXG0')+[&ZAKFB:2,-X*DMJ.[].5 +M3G/JB41LX`;=10&<-<<&)-#5G_%:^;:KW$]#1[GB6-`F75@A5\@0GXW#<@Y> +ML]2,06M@[F]9>_VN9WT_3AQKE_*1G9<7)STL^[1%-S(DW<>0`']-N0N9M,YO +M1;%"U]*R30=3.X/#\)@*FON"2:E)]N.EOH#)MB^6*=6LR)3^E*CCH_.&O?;; +M[=9G;<+*R8],5$M7ES\X]W_]'S&?SSZGA +M?'].9>YO'U_6G$FWXMO#-ZB<(MBD.#'4=MKY?;, +M38%UQYK*&Z4AZUG2(/5C\^W)/?^+!EO5KXW[7_N\2NQY6]FTU2N[[2T^>J-> +M-N0C"`3FKE&9`PUI5.4&LJU;@=BHU$92TYUY&*O$-HDEP?M&NP52(9C&=SJC: +M#V(48M4M[;<6`K$+B)T`1+#].>1_$?QO?([(&B$ZUI%MI--./[7WPZ/ +M!2N*`Q@4-6"@<%WIB$K3U1>1W'&+*IU""L1Q_G[BE4N$0SB#!.8".Z>O=>6% +M@+DKX^Y8R[B.A2;$M9#X9YX:(+7'ME!-"GEM7UMU13YROK[S7U.TFYVEDLG4 +MV=[9/@W6VJY+>DP?:A)',-.0//0ZAD0Z:IJ3V"F'@KL6NP^)P=_8I-WDTY$: +M?'M0[<&P(%]SX"HQ1'RBLQ*M#VAL,_7.''>?&F5BI^GA9 +M8);I`$./4@C.JK8GKNM?W<.%U^YZU@)=ZP0+I.][]]\Q'EFAN=;U*CQ_)'G0 +M$A&"+?T(Y,PP*NM#^.0A2@&\583BZDPH7-:I[6#\H%R^BI>E1'G +MS)OYK,Q@^16O-5)D)";F3D($*SDLA[Z#!'AZ;XNA.X-QPZ?WML@^1U%F&1R3 +M*6HH'_G&U=K[RQ_MNG&Q]U%0*$(ZR2WC"VJG:+?&:_6$35]Y@K*<_6R&"4-Y*1$+M\53 +M4N3D(&;L52DG-DT)Z#>73X[QB0CZ/\XH(OC+*Y-S05VHP"TVBEZWR#9UZTC3 +MX3N7*%;PPR]F&`7*2"X,$5A$@^(%);U90N=?WV(Q$>/@]3TKI=G@FC&Q^=Y5@B?`-5;( +M*#51"U@<9]C0$]-L7F7+N<&,D!Y2VA,-2("^&*K,@0P";OU,J!<)G0^_JKAU +M.52OS2N53(P!AIE[N>+,4"8_]*1-SRJ*?*0^9,Y8P*=@-0 +M,*#`[CW$6N`&():V`(\S]$SAKLIF!2X+_Q4'0?IHBLU,`O])C4F[:%ZC\X5!!#G"1(/JBX83KY%NR(X +M5X1@I,.FO2\6S)V6:WB'3J&%P6K:(%8WQW2CDN6003ZCT'EY)5<%U'4]Y0"# +M2=ZK`T>-(I&THC`2D*5C@`JOEHV53]S(SJ-#$F2%53OM5\>6N3X!K>G^#.?D +M"Z90FB-&)96A:WM]F60,3[?25_08JW)\B\LEY;7*<,J%&L@X$4%1>:#"Y&WC +M*(/8E^JG,.=G<35"7*J^HHE2*]%VK-$&=;-8%?&!0>YOO`RJVH$F\-C1*J*AZ4H:T07%43VE$.L*"F`:[+IT= +MNEA,T$[5SS#Q1E%WU92:U55/Z\MM6G$+V,WE5M07B/6\/]//*)A,BF_#H#*E +MP?0IUMU/O+/49RXSD(MK)OIE&)D*M-&H"JK3=A4V`$/+T!78LB7/Z"1);]Y\ +MQ5QL!*.SC-1`>.-?Y +MRH`O`0%+!T'5!B%4$MD_2TD#R[/H/'&!?B*JCCQF("AS5//FJ/_45TMX9P*I +M+9G^?LQ'+UK,YK@%PD3GI09^5EO7IU./6%IJ"?-BQ\S4OZVV'%TXR!0N;P/U +M!186JF`'[:;RLA4/;EG7[.&JI+2AH(N'7)@BH8P.]*RJY:<(I8=YL3-.N6LJ +MW-?O^3KLU"7V4.C<\2#Y1I7*HX("7IJ2AK5C&K71-V^A&CKPY!?WLHXP/2IA +MA;;B"4+CC' +MG#29$L<\A^@:$;J`LB>:8W+YOYL1?(:3T@*FW[]ZF&1.7T'+`\GPROT>,=*D +MRR8@G>:M%"9/)\H];81(2FX:MF"Z;)6+OO,[JIJRG9!I@>DI,R^)!^P`U9D- +M'YR;R5L-O/%FK%A=9)?VA9'#R<\*:[,MYI*GO2NT.9A`H%X-VKOCZQ0AV,`1 +M`G8HPPQ%JS+%0M["+%%+RV&O4]@@/7'$B9[4[\79 +M].02KFD:)K[07U7Q[SM6?RP:B2T=4D6`Q0JR_D`;;2 +M?D=0XL4^SRII3_6JDZUO*6DS2I6L2%B>8<=:D5C-.!I(#;Q@.(J7B-6[FWF^ +MQSXM=="*94SSJ%%;,JS76;4\"8Z7G-TNJ""3!D%1@C!YP;NRV$T\W`@W$JT> +M91X$FB_0[;4";L01X;SBV;-+K+#KK^\1K#>90)3JGL6$0`S;P=9>Q;60>Z-A +M*YI!"LWJFT==-WCV*\09QVY1+6Q\;WN:%/GHZ0([*ER_,RU&S_R>FFT +M',21IH.^QJX1C#2W,4_SA%2TJ;NKU_^,FXVJHESXD2ZJF,8X,QP/=6EY4]NG +M@]*VT[%S&Z<*5Y+G;5K)):]`H^J'C7W^?!CUE9&'I;QF%_)TEE;CY9PKXU"?$A$[>!/Q;`NJJV0OM+P$#NB-#/%_$?G56=%@SO^,Q8K*77ARQ% +MSPRC!*>N>2H7$NMZD?!_9EAV+GKA_("4)"XD1RW)XRGYH+V]/:`'!?!I!4*D +MZ2^<9$)%4VG2-!:&7;MQPK4'<0/'>NQV]-!K +M'.^J-=3'K/'&>G;)%SZ?*JLH'OM4*;Q,[>1;TL)WHED;M(F)43N=L;:]V!0,*UNAW8B/,XG,"4RNN^ +M0[\X[7!M%V]&<=147W2^ALZL;W,#\3.ST?$8""H=*D46^4SS$",%04[/3^B;D>9$KO/ +ML&QRK'26H&>2G[E<-JK8]WXLA4ZXT$HJ$DJ]X^G4`C*'L@[D8=//SD<6Z&\F +MN0AOQ7EB4/EH.?LNXU$))[B"/:#B&2[DF.)3X=.Y55MBA\[1)TF9!V4!PG&T +MX2QU',4(!S+YP3(^??[S:.;I=<%*(VB6Z*.0=4FK',M@TLXL(-HVF$"5D6NJ +M,TR7".&^6Q +M/_;##]:L6?_D4]>,^>H+&RX<<]D+$?ZT9N,M4SKQ^MTN_=W&IR]YBJ]_:NXW +MKUVS)MCHC$E<.&8[?&!?7V6;OG[SQ_3HO_J/M6LJG[WA^-$OAM_/FO)/.P)H +M:@%C'*[RL5-6;^[NR\;\]ZKY2BO'HP'7;F6WZ#.;O6F;DZ;]'M.-,U+UJ4>B +M]?T#J;;)[1V3*Q/.V6,S#:R]WND;@'$YY8;C+Z0Q*5YS.DS8V"LC&)CK1Q^8 +MIBE3-K[_X0=5*4EG=?:(W%49[@0LZ;IPLT-V-G?UJ*V^%Y7XPV?U/YDD_5W?0$O.;F5B*Z[+9FT3&TN;+GY/-C2^[H5\=L.N&3 +MN'&JL.RWM.XR"V^:W#ZUDY@1&JZORR^ZM*-]ZI'3\(KNAE<\-O6NJ4>T4Q,K +MM[P*_[-Z(NS'(T=]X#83;Q\_N7W:D=,;/[!NA$\^[-W)[3-&?X%M[AC_\XX9 +M^/.6E^%6#?M9F<$IE0/>W.[_Z:!/V]*@'S%CRF8'?=KT]H[_U:`?L:5!/V+R +MU@]Z1_ODR9L?]"/^+PXZ:6OY_LI^ZW\1&_?C@GVFP-K&9./;#]RZ\=\1GO'M-''Z*,[;]@]7WU_*KQ$QV9'O;/C_\*HCZA1IQ`YZ%A3*4Y?._+385]MQ.OE3& +M?'5NT-$QO;US\A&C#_U#;][7>>2,(]J/V,JQ?^.YCW=V;&Z^=[,V/C?LR_]NN8//6(+0[\Z1-N +MZ835.F/:9D>^\XAI[9U3IVUVY&=,GS9EJU?]ZT<5RV01IDA"(]#\VLNV>:NO3]L::]=>,^:28\9H +MDP0MH&NV>>ODJPC<^,'!8+TP^F2ZE*7ODI`*ANB+D"L>"B79R>8^"A +M\^%))03TZ*`A]9*I&P]WC%*?\A6J +MYK#W>66TJ`W2A>*7RM.1P<(3:4X[-%D+"G>$--U^*71>>E7&BP.IY!J@F,"R +M-4N\U3.FK*WL??C.*Z"G@T=LZEX-AYS"@:UV5['@556RJ(SQQ?.DWE>>/0^+ +M,^3BF^<62UYVDH".,%,[ASA[G\([R];,6S@#!GGW_V17(&G.GJ82#H5U_-*( +M<\<(HEA"YX77-G63Y*FV@J$=#6)2K\J.*!0CF/3(C=(P%&"2HW_`9!NJ%]=D +MBFB:?^D?3#M:@@'L15)GG"+H&O1I06'@R"/65O;\T8P5:"YCYGJ&."V^\2QZ +M\71,WLN'R1_NR,ZC.<@PGPY.+/L#5/!VVX,I!4;'7\EEFB([4)PJTLILN#Y' +M]1%>>-UTN>W8BO/"=T%_!-$^%:9]^]VIMSNX_9@,UM8WV%M&*&+;"3`8E#=1 +MSL>06\XK?\&P@:!8@IS7[X+Y#V\YX&&="JFWY0VEO$%,49!QK23W?R*6A:\P +M.*%S[G7HE1\J82R76D.'AK377FGZ[,E=%>?^.'^.6B-$NA5/E.1ZL7^<']\!6I8.?-- +MW3!XG0$O.]BFT2J80Y?;Q?)8.#RE5DGN>%M-=GP)%D!KF'CY +M-U0G$#93J0+WTNHP`*?DF;ZF&"[?+HH\SPS<,ED5E^)%<;1^@* +MAL54)Q6E,!>3V^/\)841Q_D"$I6Q$(:W8J%,F9C$3<*"3:=BPHJ"=3)N5Y!9 +M:I*S?B%TMO^FXCM7GHZ`TL@"*ZDON?=T%$I93KA'-%9_H8A4!C`XJU0701:- +M)'YR6BR[+4P\^U8=5%3[E:.ZL)M>?NDP\9'O-6"4F/,2RI]"GUUM/.OU@Z#- +M$8A!O8)>V1P8)YP>^>]"9\Q^1(+G:S9>S+6$'<9;AA*$%$^@`G0528X$O?#L +M-E-8<"7T9_8WZ;8PL=,G<+NF`Y[OR,QV@,XZF6H+($8'NUXI4@+F.X?.9K', +MAR^Z\0GZS))`IR[')\H20V'B]ZSY3*]9W,9(I8,G4NNY0@)O2C<-\6<"A97?H[`1ZR/.#?[^!)'*EX& +MO)SX6%`ZWG>MN@=.:A:D,RM-J>UYW9>+B+A000`2.+!\07I%DH9YK<9<)JZ^ +MCL>EZ`D:1@#A#;8<3:MZ;BK^JGJ=PVK]>C,"9T82%UV5P4P0^!RAX%5A`W5G +MI,*B&!5GF1/5GO#.GGT@'`T;)0S+GIM(V>*52XAL9D,ALO)R:;!<4B#,DTEO +M3:7,8D-A3$0+C$2<'5O5K.$^]'!G8/.54$B"A`+6Y[R;ZHJZ0YE<5$9X$\I> +MQ!Q.Z%>]QBO#Q`,[J8DN]`KO-*D&3+0>#5NP#*PXBFN2=`-:)(:])71N/8]B +M-&<0VR],M9='<`B<^7_[!P6%SRPSVU(&T2-P-<*.N52QFJG8893QVR@M(#G^ +M-E$_Z[&K4AHPP_&\M)?*I.W:BZ&S[:.F5"!!.I"'&S%G("\VB+R(GS]PBWW^ +MP%ND+2R^2LN);4@U-3I@<.O9L>7>.N(\V\1+%Y9E:\3$@\,!@6<4S2+W+DT` +M!U/=DJ%QYG#\PX>-.E=:DU,AHKY<.Z).O!)`9!9R[IG#2/W,1P" +M>81MP,[0$'C"+,Q]1)4C"I/;WF9O&N*=H<[B2HI*1!.%F&4Z\8;HF&9X*IEF +M"C.J@MSME7&_>)4CF,D3SU$EO'1LG/"-U#QTXMJ?2*,6_!09TL)D\UDV#$>+ +MF-C))0',`A:U@J?$(ZM(XDKKF-1GAB:BG-0S@VJ=`8:+B0P0J3-*Q_I+I-4 +M(^@_'HD65$3S$F0(NB;59VXZ!A%X7_T6$]KC1F)`FZ_AL?#FN#RC4ALN3F-Y +MV52RU6U1L +M`!I;2D?1SK=;N2ZR50B!9>\B>099)WUR2J$P4@\R9T686.H5!"GHYDS2@BM@ +M%]!'R@0X3_7#&>A$P^*.?IZ6Z:`^9YB[BY +M'R;%^>?O%F#ES,3ZKPN4PJK^5DGX:.!#0H]OC"B?;+"&*_1\'!$_NI) +MY/'B2526K@P2_9@G;JJQQ1=H-?()E7<%/8?,)D&<5MEY^E,6SS>.OI0U\(.S +MJ18D:AXK\Z"'J[+)Y9+DS\-*_7"\CT<8`:`U-+E0&DFVO*D3KD`(Y<%L#H8C +MOXP<(K"6:8:C0F!U'F3P*9^>GX_(7RERF#!XA/%"R@:` +M_GSD"4P.&*`$=D;*I&A'N>/P8P-MT3JD.B5V`R-!6Q1SIMC +M'C`-3>4CD$[[54/H$\!,CSREIR%XM,$Z!NEY]*\93,LH$$.=@,,U/)(X\EY8 +MNF:!XBDSB/X?3$GKI^P@'`8P1XL>>O%(&/2"C=I?8!18).H((YQ+7'ILQ/G* +M0?X`;`5$H*$URWM)HXV8!K7S`+=J;Q/G!*S0HV8PG(XBE +MT35;O7)LL1*I:@S&$A$Z.@Y6[37;#V]A!3`=='1./SAH5CNF12,V54'4\0]\ +M9!1W*%-FY!@;!1IWF\:@V4>#%K0+%]"2Z%IH$UNP@.1U$J`IGJDAR+@Q5WD`JDU)F +M6?C$J#?R:=:J-$)_,&O8)BC%*TRVW0[KOTR%YM+"-D>YQ;#1O(LH^0MTQ&"` +M0(-MMW-!#O".-EFX&9"V-@6Y,IQN/`:60(=>Z-R+AE80]S%@S78I[! +M!KO[85V#TRVB`T!#\I04B!IJT&9;EF0M(2CYW(?A('.F[\UZ%JT)786TS/2L<5[L4'?T($B"6N9T'%=&DG +MZ4-Z@^:B#YVAKYNSO#K)UVL/&\<,&P4!/*/0RZQ,.+V3?*L:@G/F;&46:/^* +M95"L5^/0-/F3BQ!>API@%A8E]/1+1\'G"C20SAB%%'=#B:D?_]*4R1L54R^% +MP\4/`&L8]:Z8F-![I"8]*?'&,PPGE_QW_(*L8EZ6@E\G_W:1Z2F)/];4_(9Y +M,-E";CI,7+M<>/5RT"*>42/P%8J!0D3G3,3.9:;$\OE\Q/H?G*[.+H\!=U`/ +M)6@T15A<="2_L<(4(9>>:.^8D$W6.LE,P9#^`55X"AUFZ"BS\O31VUF70AB' +M$AXA4,+]M@Y*>-=%FRG:*?&X*12/.Y%M$LP%7[W^_BL+07&E%7WK'DX5"WW( +M\Y9X8W]=.T[2^()E:^#W(R>OK>QSW^=6!%Q,),L,1;5$"3KZ9G$EO/>4RH10 +M)H%58@"+-JE0GX_CA3(4%+GMM26,?A)4W4<2R_X*BZ>X,@*3"D9P-F*+#&A;N1)A\\A<+&F7$T"2X[5Q3J48 +MYY[->2(.D,3M#\5OI?>TR^M4G/>.6@@;@B)X*LO)5^%&NZE#QQX+9GC;/#>_ +M,I-OZ^K%,5DY;,W"L?.ZCIRVMK+_MWM7*(T'_69<[4=Y>JB8<7*W"\U@8YAB +M`K,?%&!6**6TC[:/Y$;T+$:AQ2=,&JR=29I/0KH;.D_^8MD:N0##?/L^%*TP +MM9)]#*A@1(0"*XBR%7L][2'\&H5VKW;C$#=`,MD.IGA;H:]-1QS0:;=>N&I! +M'7[EO_,UIQTH77A'SDU[>L-7X`O-?LMEYL+$];O'G`^^>.]P3L@`)F,\0^57 +M%9D,G(G5[^5<,&\)_YW1418Y;,0YE,B]0O36N"O([6=76#+E,I:MF3=O1L?: +MRIX?.VH%M'RIAV^I9H9>=KV\[(AS[D$<7PD\/^+H<0='CY%(,X(3,SLLH8-< +M5!-=;OK,K^;H&`ZG22=^]@#S9J,5Q,(65O]ZS'D&E01_IKYUYRJ77>,ZI^#R!M=$:KCPJ5GJ1Y+!*,!<-.G2^_6][<;,.R!XIK?GJ +MLJ.9$GNL,-.>#Q;M720Z7T/9F+;CEE)X,TR^9K+ +M26^!3UN#=EE6>%Q002_9,2U_)/'!TVD\E[,%3-:/>MU4L)*$E]\:.LZG0>^' +MSI!JQLZPUL#(N^1N?P=Y]\'CO:0[K]31,CI&TS#$]^ZI90#M4)_W)_M"2<%&H! +MM2G4S!LY&B:.V5.G:*CDPEJA^E%0S!0M`F5JZ#,\.'K^`^",JCK?" +M\NC6L(PQ>2"*@Q@`@(3YK0_K+I#4H`01SH50#JE8IRMP!R8LP:N_>_EB/>DV +M;7CH_.V/>D:Q42*TR&"0&_O02*`J\F\0\@<<;USW*7>0[.8P^F>+W55 +MG*O_:/;LU\:9]!A<4Q9SA*SVT/G-;L;OB4OAI'EX^NQ]>Q(A-JMN7>A2+K<< +MD/%CB%A\5!2."W:'RQ2S*'5S"%UG[RHH:T(X5R9OBU;>V\I$[#P,IF3SS +M>HN**'1>_"<,$;I&^\K90!J&JR:<5--(PV=AQREK20D@JG%+8:X-%.:JCZ8N +M6_.I>0OQE-B_^9D5M3P9SA^?$2HT[A--^IZEQL_V345.N(\V:UI3U.!8\A66;A0%E',)J09Y'=#:`RD$LO>Y7>84=-%` +MH0]W\W6=*QZFDTAYPUK*`]>$SW,T/I/U,5U,2&-L07+QRY;XTKR\.'[0]V@E +MO:M>OH@'^]2)7@I%F\JV3ES?KO*+UQ24QA#)S[3H='27?`%S@TL2BE9VTPE=>&[[]/&]."<]4D2J#W`XQ0FWSH(=!'2 +M=_DD2`?+T1+&O,<@[9:03%?<4_[$H'GVG"5^"TS>ID5'KZTTC?.K*_26PM*' +MR2.^"`^97<;N3/*UC,9S$]Z:*&CP5%1J.*X0N/C(Z;!";OWW"H5UP(>$SN=_ +M6JMX6WN'/?-%K]]E3E_7[/&E4R]CD?E)CGXHXVV.RO?G@2`WGT(@^=?2_%\"6.''%)D=Y.\@Q+TQ(- +M62WS@JE5*I0W?&9FD%BBZ0,-1L&P`%:)R1U'0+PZ&G8??9-1B;&"I!W5L%.U +M5IIV.[^W7`J3WYG#9Y7$ES!8H2ITJ;7/,>.TZ']31/+:ZR)Y^+WX@L;)1M$2 +M]A]0%,5>*Q+=M@N.O\8<*M__/GE`827D7%-B&:&M@P.&CCU0\@/>7"01[1%M +M/J#3+'G<-Q=YF:P08B];LZ`;%_0>9[T+-Z\Q3B4!]W]MM8?,(:; +M?+^6^(L87EQUI\LH>+8 +M9('XN>J\^7D5*V3U=S5IC,HEH-I28Q(FSOF]\*V(9`8]X:I6C@T8]R@2Z'`% +M,C2R%D?><`E6+:UNW3O063]Q*2QJ\LZD$3A79%<*A[LP!KF!8Y#8ZS:]L)0@ +MB]4E)?57&!(1AH>2,.:8L.9R\6S4Q_:8<>D*K!)E"A1,5P6+YZZ__TJ&/)#7 +M,S`^3ZFJ2M[T,+GHP1I/!D9,\JE"F5\$MNZCMRSBD]'XSY-7[R4EA@P52"8+ +MY\+?'G(#)*XQ4O]O#W&U*,,@6F,^:X)26OA]-@&5)+@?^X+A;#0D#6ZY5,`K +MF,R,;;@(+3_R;M1B&`2GC2@L*G3+^G\^$&H`Y8?@PG_(,8NZ(*D[T2!JBV4B +M9D!:\@:D'IL6'97#_9Z$0^O1%6KH$WOO +M2YL*Y4BA6!S6%!%T)'['-3Q\.">,7>'&2)*,ZI%3S5AAI:M?TIHX^WUD-!FR +MBV!ZY\VKNRJ)JQ_016XY-$25F*@U2F@A_\5CW_SPY +M&$"'2&4PTLR0-D("2J0`V\J[3(,5.C]8C29)"YY8.:;!9W2<4/T*\H8*CI5= +M!2,A-@X/K(/CP7B+^3SA/9[[!^)B5D>D;_4%BS)@P;#"IS\O6[-HD?(%JO84 +M3W*8.,+CF&`_V*X6O@`;TZ6'%0TQ/._GJQ022[$'4WM,0Q8F+YN$2]L'.?C/ +M922/4,DNYW@[%/%WUII4V):)N:B[O6H$#PA>JSA!WFF2[GA;="W`18UY$F]BSI%$;,F*?5/VRHABK9=4)D\O?1/[@Z4CN +M]6G2-=.%#9K&$MX[HH!N`8.&L80)U8K$*^'^-W;Y5+DWXZZ$-K_B(7-BC4(! +ML^CV>\*&2P%K_4+Z5,L*%FSCSE.F;DD>K$-YX.S83Z6X/_4]*_Q5*+R@YZY+I[1W&;P%_IS'4@-*6$--VK1WXD=R<=,1-TEPZ +M-=&WRKAK=U\DQKX1[)=$Q(B9[/JJG8.&/FE/KZ4BFMCKR)\8)D>>;<,IXU7` +MX2/T]A(./(M\$4$;`=]0+NBW8J\(`E%>?YA\WO@NL&K!PYRMKB@K.F?BM#4I?G5!$-[E=6T4]-)#E+!U`M):&)JMVTVY-/ +MP9W[]%\O9:MF(L=4-W=--IY?HC$J5XA3)[4\@PB$N +M5UO69=RADZHA0N(E'LE"/Q&!IX3:(UEE>VD5`[3"9Z=R#4%&Q-OL/XP=[*UY +M=:(JKTJ-%]!L*!*HG'+L&VJSB\!AV1DE?1<52K#QCI]@T!DECW1SP@HSIH+7 +MI.*.I!.30CHQ<3F2^,9#<1:O.*5$6&_0A>=9K2*$T]1S#\[KZ2AS90^]X^^L3AMIL@6QRG$)G:%LL)IP7BFL\Y&'DYZP[*9ZM +M1*]?]+#^M!;M;ICXV$8&)<$[#B*Y=`174/B;B;:S"NLOT!7MBN%UV*I:ZN6* +M453ETBY6B*(@[CBI(X(Z4M`;^V\=>N-7/]L,>F/-FLI[ZDBM)/%$G8,TMS!* +M31?<0`LM5X#3-(VL/840T8A"!A4ZHX`9T$X_@G[V?;,W:]:X<[N]#,.KR$FR$IC,0%BZA5GOH%@6%`8R,O])U.Y +MO3(NG>9]T+YDIZ6J:-:`VW(B*#LGPS%[Y(RUE;W;?HZN@IX?=$ESYLXP6>FI +MY^M$P]#WQ7E)3K[^;*&7$LD%7P*-L!]^VU5O=W/GP^1O6A5HBN#7L6'B+#ZT +M<]C_`PV(+^GC%S"_N4RJ\;Z"WC+_[3IFW^1`MZ632E.H),KS7K:FR[CF5-$[>TC(]0\/ +MDL90;PR3C\^RK<(-NJ36MI]H[3$"B2A;!9#1L7H1U7C +M$@QH1)[[!>Q220IEB!6.#0QFLF+-/[>:%5/?0&BX=`K%!"A53`!5>O;U`LT1 +MRVT^HZGOKJ1B":`PQ@?>DU`FF[*PRD>.%L@(-$,08V7KAXGO]I$L%-`EG&IN +MSF/S4112IB'P)I1(_.*Q(@T99U;H%&Y64PZGTD7'(-UJ3K:OJ_0@G2.B-H.T +M8V\)D/@WW;BD+#ZY*[_G&B>?P(JX;ZB1I]0FPA:0=GH#0Z?H\5Y)!F>,I#[H:6[0(<.)A8*]YEY0Y'BII +M@X,`8?*F"SD%4,K-*`BKL,S:Y3Y]5FF,&*%:::'C[B#GK^(\($EKI7FJP<%1 +M]]\S0`1H`D)&1OO6\DIJ#Q3M,BFV>?6M:@CC@X9B +M_NX+<-\JZ(A*VB_JU<9#<V8&0B./12[Z[@S#EM%K2P=?>E4&ZY#D`UTVQ?+ZQF*+VWU>Q`FL@`G?)J`4 +M-.H6\]YP,"^35?PB7$,8D[^4\[&7BB7Z&0N7I.-H83)YJ>^A,[>DLH9Y<.59 +MH-C][0"K^J>%WJ#DS3#QSUUS`IGF)2-U05&$X:JSDE-J1;F5">^<<%:\9*QS +M:I)4C7(I2_FY=L'2-NODQ\BBZA!%&,/$;W&=+!$@!%5`A=V[W=KCO<+V11@J +M!%_2QICCY6$-SY.DI`K:)TT>U#6H$(C'"P;KR(2XG`.VX[^A>T59^?/P3<@2GV?ZISN^I5- +M)UH$H0ON6KCAXGTQ&0#4H@4WFRCJPD@T5FBFOXRE`F`%92];##IIQ>D[?_Y\ +MK/TVZ8E"/\6B +M"EFW%;WJQY\7@`U+"[O8WQHMX7"DEV^-.F8<>00(B)WN>59>5A@ +MQ:AKW0_7@A8Y0#DMH)H&GMP_NY"'>84V8&H#3/I>],G9A4'0;0:@$1@,6,L8 +M'.*:ZPO*>2_HF#%C"A4HYK$!\36C0\;F^/8P>>>[\`TL*SAN7BMW59)WKH4S +MAL3CZ#SVTA>LP/ORIVL@619B:=MS+@0SY<3V!>W=[8(9:95;O72F5,"2%/]Y +MK>%H.F_^3$9S0A^FD\)PS.ZN.&]^,X67XA`$-`"J)W"03K^Q=HGBRI71)?&C +M1I>:*T8PNFI62AXTR^.,O$,7SJWQI,_\X[3.*6BO+_3(4`C0GT+I4;-%#85& +MJ.W0.3M<0D@BG)SUAU`5C6#*]"/.GG+$D:W1;!<]$KW%#!Q=K5&WZZN;?:9J +M1C%5*ODT>YW3SYXR.>!%B[/8T1XLP:H?_;`V/\.`DZP+IC*Q&C?]\#JB$!MS +MVH?7;!S_W/8XW=L5S]GX_GO%VU#4['CRU;=C-*\=63LK[XY&[X(&%-/,85@27N@L/7L +MP^9`,]Y,KNC*[PA+3!"KNF`MVS,Q9`'Y#>!F:TF-[[X$]^"YGVZ\!Z_\MZR: +MDT"/]0=@8W`Y>6Q%KN^'PQK+>3WZ'],[QU./T^[IKOS:4IJS@; +M_C"U\^SIG:W!G/F?6MJJ6H'-1NE9O-W"L2^^+3NN->@XXNR.&>'8O9\_(54J +M]")X"B33M'9U9X.YPUE>N&CVDJ"S@R38+S^CQGX9C#*):3WTE<2K[^/0@^AZ +M?OM-)^(2QOV)TB15&G%:6N;G:8L&LD=)GN`1N5CQ^D-#;G;=T,M9+QLZ'[QZ +MW"H=)H5!J]T[Z\S>`4D^]C./@217K8@T#Y/G_<_\G)S+B&D\8C&5/(>5'2S- +M<[9ET2>`8Z$O6EC(IY4O"-H`!8>T,E3S6(#?8+_[C,FQ9>><\T-^]Z9/-W55 +MG'-NM-%S00U_!5QLB2[][K8`"Q,KSW:9.:`15A7&./D&B*Y-)W8<41JH).YH +MP>$V3>6Q*+HS]SDEEN;^TZ:W!$E!&.-'"-=U(9?Q4@40%+;U@ +M`6F%9;0Z0%Q,AMT8S>ZN'=B.^*(:+LBBVO>V32?*61\F'GRWP7'//9Q9<=[N +M5:LO@C%6O9'U!PM'#W+P225V1<>%I93XZ9XG>E0KF:8_,?^9[D+>'AD$[H3) +M??/HOL:CGDDA$/'2\'Q>R. +MZY?F=6_;`P5G4BW%A1%C=\?.V&\.&F$E]M0T13)4O +MD*?AZJ>6D,EO"2XLIM-TQ3M=&WZXUJ`ZNR*8WCI5\_]3V;4`1U&?\;"[%T!` +M="KU4>L+%5(O9^[RCE@]$T)(2#SR(+YFY,A=R$ER%^\2DICJ5*WU-8ZL6[8K +M9QDL5=$J:+4SPJ"U8H=.2ZOCN[ZPG5J=(J,VK:)%[?=]_\?^=^^BMAW'<;/W +MW_U__^_Y^Q[KFCC4+;ND;"@B9PUMR53MO9@3Q-KM&8^6FP` +M(H]AI64.2)C>UE7(*N(9(`/:S]^HPG*)RVM)9R]/Y[5WY@X7N`=BWA;J1H?A +M/&-.=$*Z&8)XNM' +MU+?!OCCQ,EW)-2!9*KEE$&3),.'LABY$W.&KS1PE>;J5!;0L+R36B4 +MR+O_P-*P3;PTK,&<^5N.6F%(Q5!IY7`3;1C+B-YA0W[ +M[0KWK#U>._V>]>MF1K&&Q1FGH7YBY;GCB*AL?M+3W)A*%_LZ)-_PA4G%FC9>O5!WM]!%BEDK8C#*5!PL68TRS\@ +M:5PUU6VY1>XF_$B4U\!*K.G=UO8_XK9ML>7<#H2F.7L6=\^Z!%-Z8H#@LC3#ZH$#C*^E@:-4TXFTX*V,H)S[-B+]/Q(>( +MZ$W)/L6&6DR/^?*\]3S/>](WR_-^ +M;H)[20PFM*)@X!P:\T`@D?;F?P@-$TE>$>3G`U=O(@P!40,%HVDP9VW^3=0, +M7#UGY6@\/4(5ENN3#NH=$/UXWP`99%RF/9-%WU&OK&F+CZ+ZER85\PVVWK!] +M>;HO1'Z_"3?!J20S`CMIC"I6Z7Y6)D;0#HB]9Z.5`TP1P$;NOR7F"758L.V# +M;IA#)A`)EGM:N=@-BHQ]QW$#:^LWU(IXUEJ%TDGQK(4JRM1O**NLJY=;)8:--'\`TU)V(V0PX/QB+8>Y6M2)02-Y/7[*D9N(E'CW#AV2"$QS:.^7ZGD!^KL:OQ[+K:LSLK03:Z#O6D)3RDLKAQ +M_65RSAKJ3[CWK3=55Y+=(,,3OH00&J2"B'TM-_`5F_:RJO'6"6+3LZ_X@@]3 +M+6??"_)-?)!(%E,;I<>?Y&Y\WH(GEV-8LD$R>3<;6I?&+Z:6OC8_F7"1,$3E +MM+;F`YV=J+UQ.@OBD+;6?WIW'@W>,&@&-)#-SM?XG;A:-)'`&4#EO7F:I3V8 +MG+!G1?^K.(^X)Y;*=(+F[-L6,J9F/V[.TV"!(5M[[B8T&T@MZV*JQJ1XFK;' +M3*GV5IM7$[D()="[FYX^'L\%0=%CKB1H=3OXWS[:5ZJTUVOW"-H;/UP'L3Q+ +M[O"O`&]04L5NBQ1_:E^"YL"0B*K0*S:M\$=@,XNM;9K1%.)9'I2,*&AZBP\, +M`:,:VTOPU#PV6U060L"O6>/>LS/=.G!1@",+*]E\!K7W1N406_OW1A9I-YC& +MW*.B#)!4)S/!\_\^1-+>DUZ7SHQA@JBFC.<-814VBH#F?74LH>B7@[16H>,M +MO&@1##!B9`8(6\3%ND/V3*,6R<[`^?G/]ZR("U.1P$%]_2A*#>:!Q-C:Q_N`)PI<%B?CK,TZC&$5.$5T"Q*TSPRL:=QW +ML)AU`3?'.'`[NV#Y>0DM<4' +MD)?Z5R43\O28TCET>O%40/#7TR56O%J'KZ;"_K;QPEW%D?^1I(-4=8J<(B)8 +MP++:L\<2K6WMB9O"U563X=K*H@`\,WK:$U=&:JO$"13%"SRZGJI].-4QV6L; +M%7>3)@`[U3^7`5_4R.GK:$&S[D[*GWG>^P,V=JB+:P\'L*^WK-: +M94K(*1JGL-(ES5X5-;5%?2()3A:*3;-!RN;UT[?[W&ET`KRP+NN,RI-T0WQ*Y4J$Z/EM8T_:\?*F#YK(+D>=K]\"YS`QJN'.1#KY$;6E@_% +M:5Q>DO[<'D=WGXTV^H[,#N2--VHD_["/H%^[I"@'3>-HX2,<'>%\[3XKJ(0#.^:)0UJJ;&EF^6?&/1/M26LK*^8/=$;CL#V +MKW(JN"ZG6C16E,ZN.A/ELF(;U-N-560LJT8&3#USB+!PZ4CS3Y#8V@>'_7D" +MKUU`K;-G&=/PVO8]D9IZOL1DI"X,VG]PE"D&'"-/0.R2KL?!$L*`XCBF7D'4!]27"7FG]13F+99)<5@GA44>SJ:N`2%87 +M?@W#*D1LB^0G+\5.*Q&>-\,J^PZJ'5DM(1!9?@$.?\G!9OQL<9*$&[^=(DIW +M9;0-,M3\.>K7N0HT1FB2@C4;#^WC0813$'^[.<(AG@N^[WW.Y984!2QO`?NW +MSXS&LYCN->$FW*ZE1,PYUH:';BN/G'F*L=E!$)XG>"(R^F/D8+SADJ07NR9+ +MMV^.$8"#)9`A\\@7HHA%'FA/9_I3:ZQ=13Z#I,`&@>,+Q`CIO,`:6F36;_#Z4&`G!//CJ1W:5@R%ZX$YM3)?27PCXX_>U3 +M<8M*"ZT"_S4.4K&/6;K^S.94.J$D8;P#S6SM[-]_)>RG;;T;]BQ2W.Y1K9NP +MM4_WT0.5?+BM?=G!;$,.C8,W6VOJ51_*;*T+^/"ZTSK\8GL3%23@-$R"$$RX +MJB8)35VK$UP&JN+S*T6C"`.D4\!ZAQ9%W<%0J(XK7J>@,SZ,RC<<#CJL-"%2 +M53,9J7'3U$L'P5=`%+J%#1OB4X5$F?'D+:&53._;TY9Z, +MKZM[3SVFBU(8O&C#8X-"EKJ2^#FNB-*WG)>_B+6LQ3UM9=:*D430XOD.JX`V +M-`[`2YD=2WV4`3=HSXY&=$4&4W%KE:GM.`L?&73:<*8:<)++9<#FB:!I//8) +MP?/QEU&T+56N9Q[:@7*]5DPV$FD&"<7R6M8&4W]M4]S6S/M&5`R153Q17;:I +M-Y[%P5R_*VYJ+RUQ\7V:H?-%4T^;J7U1T8K]/\T($""RBU7.&3Z@<[E2/@I1 +M-Q9:#&1<8#:#R;`)8.B.)6WPH,'D+E_DS`G:J@#^1,X;;_0)/;QYY'[!7VS\ +M!DVQ]2!"'`P6X8'>MY6&Z5&J&'M3+)SPC/AV$@+CG?/8%PC`T<$.1G`PU[J` +M,EP`>K0N*V^7$Y;A#1Y9)[,AMOZMOL+""I6GW>/E(/:"[LCB2%E#.%(+D5V$ +MVWC+KP%IH*$@1NLH,$\ZK[V6A>3UA7?X8&']E)W]]6Z5U\NF8.U&R#]YT]R>>$5XNJLIJ1Q!6 +MU7Z0D@`>0VK460RPZ"FW*&&;G,TPK5&D&9:^U]1?G*.\9FGG0O4U"_G!S:BR +M;_89KU[G?:?9EW1.HQ=LX_U7>(B._JTG!X2.KJW/?QU]71[1*H5'5#6&S4^8 +M;[#6H'G,P:+%2K9,8^2O<):IX=%!_A4PX\E;8DMC[?40\#1F\*FB*DO\_*MJ +M(1G=Y.!5F>6A]-B*4%Y//-!K\01TH+2AJY!!=>Y%L%HEG^!,GCJLV\CT+ZM1RFKL_Q^AJG_:0%';YD,LB*"\@\+*\16 +M=_DKQ"`J;4I:KI=!]M5UWD1!4N`JR_4<\L:7!\.@FLAY<"(UX#S45H<<\AJ< +MEHSKP]+T$^8[F$;N!3"7(3BR/^8:J8^"AW.]_!N+>$<7MNB/!ZVEZ;64FE.* +M"&J+G)F2F:.2`=OHT]2J@9F'R]$B4E<9B_*\@Y'5BB/R+D+FK'//P>+"\5>* +M,_E/#G(F#]?SDE01Q#.SI(1VMO[RE13=^2O`?!B@C]A!!%.[0!KBS&Q`!-^1 +M'+/:D^,I1*4RTC9ZA!]'-WKY-Z^?5L:YE\H`.T-.:\AI#SD2T3Y_CB\?I!H# +MM?>H['PE_],35#`\6P^=,QU06NY69R#ESJW\9@B>"7>Z/IXG_YB]QHOA^;!1 +MDVYPZX*!4H$OCQ]6EZFLJYZLJJB%.+%C];0PGMZQ$F$\4[]LJP_#\[*C-VU9 +M6<'3EB=_H[2E?N+8UZVWZ`R5LP0N^YK*HJ1WW0#HY +MAG]7`*Q$]7QQPO;RSL(K6Z +M&"RXN=NNB&+-2#J>P\)]G`F>EADB.,SUW)0C]X,UE_U8L?9E%I6ZPPM@6T'' +MDG"MS"54RQ$9A&D0I(G-IR*'$VH!XCP8Y]=IIEMZ-X]##NZ#?Z&LV],=$MH7TTP3L+">4C9VD3#<'OOK,8DF;JB2MD'1+Z1`YY1(XG +M.=!.G,.)6%_`R6'@Y$,E>GUHQO5W/'7B.<2N[R&SSGAGU]]*YI>,AR-31UWTRY5SY%6Z-3(U +M/_/8K7OEXW'-^JDC/UH7;:'_QC5GP8YRL$#%U+Q33PMNHFO\K7(3<'7.PV]4 +MI$L"N*38?_54Z5^L+9TE,^'"3+YL[53@QWK^$GDC7JO^M$0_YY"VG_WO?U[$ +&'!]T/0,` +` +end diff --git a/contrib/bzip2/sample3.bz2.uu b/contrib/bzip2/sample3.bz2.uu new file mode 100644 index 000000000000..3ea32a084a88 --- /dev/null +++ b/contrib/bzip2/sample3.bz2.uu @@ -0,0 +1,9 @@ +begin 644 sample3.bz2 +M0EIH,S%!62936;K-,\D`.K;?@``00&4P```@!``_[][@,`#:VT-3`IDGZIFF +MHT](;4T&@H]-0R`!HT`BD%'I--&)H&C32IEOWIG15$$195,\[7SNV^DXEM\G +M0\ZRK;7W3[@]P7B>KPBU87N[XI5>!/TRY1JZE9UN&;!6ZH,60K?O=56)J;1@ +MAMLR":K)YTDE0*\.``1`$""QGH`*"(N^C.#]!@VC7I&-,2#+KPCP^J.FQY.Z +MF8"5*83K]+=A;.A$:#-(KY':7&T/24RT:&EIR)5"L%+S'``4$1985NZ$GE_% +*W)%.%"0NLTSR0.A$ +` +end diff --git a/contrib/bzip2/sample3.ref.gz.uu b/contrib/bzip2/sample3.ref.gz.uu new file mode 100644 index 000000000000..e087f833216a --- /dev/null +++ b/contrib/bzip2/sample3.ref.gz.uu @@ -0,0 +1,11 @@ +begin 644 sample3.ref.gz +M'XL("$_07C<"`W-A;7!L93,N4$"`)T;M%]+Z!F +MZ-B(8P>2@S:W'R7HNB=XBP=1$#\E_9KF%N.\9/0U_YXSO^;ULCSC]U9[<8KX +M.<9S>_2>]>M5U);+.-0LK[Z8]V/V%G]>)_N44;/ML8WO^OV.5I[M&*7?]O%YB)9YC7O=QAZ:M[4L +MPY3+_30,]];?UD,UHW3K%N.COO9]0#V7ML_G/OM6ZK7%O/;.?__LT<=E`@`` +M```````````````````````````````````````````````````````````` +M```````````````````````````````````````````````````````````` +C``````````````````````````````#@/[X!M4V7,;35`0`` +` +end diff --git a/contrib/bzip2/spewG.c b/contrib/bzip2/spewG.c new file mode 100644 index 000000000000..7934e765818a --- /dev/null +++ b/contrib/bzip2/spewG.c @@ -0,0 +1,39 @@ + +/* spew out a thoroughly gigantic file designed so that bzip2 + can compress it reasonably rapidly. This is to help test + support for large files (> 2GB) in a reasonable amount of time. + I suggest you use the undocumented --exponential option to + bzip2 when compressing the resulting file; this saves a bit of + time. Note: *don't* bother with --exponential when compressing + Real Files; it'll just waste a lot of CPU time :-) + (but is otherwise harmless). +*/ + +#define _FILE_OFFSET_BITS 64 + +#include +#include + +/* The number of megabytes of junk to spew out (roughly) */ +#define MEGABYTES 5000 + +#define N_BUF 1000000 +char buf[N_BUF]; + +int main ( int argc, char** argv ) +{ + int ii, kk, p; + srandom(1); + setbuffer ( stdout, buf, N_BUF ); + for (kk = 0; kk < MEGABYTES * 515; kk+=3) { + p = 25+random()%50; + for (ii = 0; ii < p; ii++) + printf ( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" ); + for (ii = 0; ii < p-1; ii++) + printf ( "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" ); + for (ii = 0; ii < p+1; ii++) + printf ( "ccccccccccccccccccccccccccccccccccccc" ); + } + fflush(stdout); + return 0; +} diff --git a/contrib/bzip2/unzcrash.c b/contrib/bzip2/unzcrash.c new file mode 100644 index 000000000000..f0f17fcca533 --- /dev/null +++ b/contrib/bzip2/unzcrash.c @@ -0,0 +1,126 @@ + +/* A test program written to test robustness to decompression of + corrupted data. Usage is + unzcrash filename + and the program will read the specified file, compress it (in memory), + and then repeatedly decompress it, each time with a different bit of + the compressed data inverted, so as to test all possible one-bit errors. + This should not cause any invalid memory accesses. If it does, + I want to know about it! + + p.s. As you can see from the above description, the process is + incredibly slow. A file of size eg 5KB will cause it to run for + many hours. +*/ + +#include +#include +#include "bzlib.h" + +#define M_BLOCK 1000000 + +typedef unsigned char uchar; + +#define M_BLOCK_OUT (M_BLOCK + 1000000) +uchar inbuf[M_BLOCK]; +uchar outbuf[M_BLOCK_OUT]; +uchar zbuf[M_BLOCK + 600 + (M_BLOCK / 100)]; + +int nIn, nOut, nZ; + +static char *bzerrorstrings[] = { + "OK" + ,"SEQUENCE_ERROR" + ,"PARAM_ERROR" + ,"MEM_ERROR" + ,"DATA_ERROR" + ,"DATA_ERROR_MAGIC" + ,"IO_ERROR" + ,"UNEXPECTED_EOF" + ,"OUTBUFF_FULL" + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ + ,"???" /* for future */ +}; + +void flip_bit ( int bit ) +{ + int byteno = bit / 8; + int bitno = bit % 8; + uchar mask = 1 << bitno; + //fprintf ( stderr, "(byte %d bit %d mask %d)", + // byteno, bitno, (int)mask ); + zbuf[byteno] ^= mask; +} + +int main ( int argc, char** argv ) +{ + FILE* f; + int r; + int bit; + int i; + + if (argc != 2) { + fprintf ( stderr, "usage: unzcrash filename\n" ); + return 1; + } + + f = fopen ( argv[1], "r" ); + if (!f) { + fprintf ( stderr, "unzcrash: can't open %s\n", argv[1] ); + return 1; + } + + nIn = fread ( inbuf, 1, M_BLOCK, f ); + fprintf ( stderr, "%d bytes read\n", nIn ); + + nZ = M_BLOCK; + r = BZ2_bzBuffToBuffCompress ( + zbuf, &nZ, inbuf, nIn, 9, 0, 30 ); + + assert (r == BZ_OK); + fprintf ( stderr, "%d after compression\n", nZ ); + + for (bit = 0; bit < nZ*8; bit++) { + fprintf ( stderr, "bit %d ", bit ); + flip_bit ( bit ); + nOut = M_BLOCK_OUT; + r = BZ2_bzBuffToBuffDecompress ( + outbuf, &nOut, zbuf, nZ, 0, 0 ); + fprintf ( stderr, " %d %s ", r, bzerrorstrings[-r] ); + + if (r != BZ_OK) { + fprintf ( stderr, "\n" ); + } else { + if (nOut != nIn) { + fprintf(stderr, "nIn/nOut mismatch %d %d\n", nIn, nOut ); + return 1; + } else { + for (i = 0; i < nOut; i++) + if (inbuf[i] != outbuf[i]) { + fprintf(stderr, "mismatch at %d\n", i ); + return 1; + } + if (i == nOut) fprintf(stderr, "really ok!\n" ); + } + } + + flip_bit ( bit ); + } + +#if 0 + assert (nOut == nIn); + for (i = 0; i < nOut; i++) { + if (inbuf[i] != outbuf[i]) { + fprintf ( stderr, "difference at %d !\n", i ); + return 1; + } + } +#endif + + fprintf ( stderr, "all ok\n" ); + return 0; +} diff --git a/contrib/bzip2/words0 b/contrib/bzip2/words0 new file mode 100644 index 000000000000..164a8ed287aa --- /dev/null +++ b/contrib/bzip2/words0 @@ -0,0 +1,5 @@ + +If compilation produces errors, or a large number of warnings, +please read README.COMPILATION.PROBLEMS -- you might be able to +adjust the flags in this Makefile to improve matters. + diff --git a/contrib/bzip2/words1 b/contrib/bzip2/words1 new file mode 100644 index 000000000000..2e83de9f083f --- /dev/null +++ b/contrib/bzip2/words1 @@ -0,0 +1,4 @@ + +Doing 6 tests (3 compress, 3 uncompress) ... +If there's a problem, things might stop at this point. + diff --git a/contrib/bzip2/words2 b/contrib/bzip2/words2 new file mode 100644 index 000000000000..203ee39c4c28 --- /dev/null +++ b/contrib/bzip2/words2 @@ -0,0 +1,5 @@ + +Checking test results. If any of the four "cmp"s which follow +report any differences, something is wrong. If you can't easily +figure out what, please let me know (jseward@acm.org). + diff --git a/contrib/bzip2/words3 b/contrib/bzip2/words3 new file mode 100644 index 000000000000..8486a84c8b39 --- /dev/null +++ b/contrib/bzip2/words3 @@ -0,0 +1,23 @@ + +If you got this far and the "cmp"s didn't complain, it looks +like you're in business. + +To install in /usr/bin, /usr/lib, /usr/man and /usr/include, type + make install +To install somewhere else, eg, /xxx/yyy/{bin,lib,man,include}, type + make install PREFIX=/xxx/yyy +If you are (justifiably) paranoid and want to see what 'make install' +is going to do, you can first do + make -n install or + make -n install PREFIX=/xxx/yyy respectively. +The -n instructs make to show the commands it would execute, but +not actually execute them. + +Instructions for use are in the preformatted manual page, in the file +bzip2.txt. For more detailed documentation, read the full manual. +It is available in Postscript form (manual.ps) and HTML form +(manual_toc.html). + +You can also do "bzip2 --help" to see some helpful information. +"bzip2 -L" displays the software license. +