bzip2-0.9.0cbzip2-0.9.0c

33 files changed, 8332 insertions, 4104 deletions

diff --git a/ALGORITHMS b/ALGORITHMS
deleted file mode 100644
index 7c7d2ca..0000000
--- a/ALGORITHMS
+++ /dev/null
@@ -1,47 +0,0 @@
-
-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 bzip2:
- 
-   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
-
-   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/pub/user/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
-
-The following paper gives valuable additional insights into the
-algorithm, but is not immediately the basis of any code
-used in bzip2.
-
-   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
-      
-All three are well written, and make fascinating reading.  If you want
-to modify bzip2 in any non-trivial way, I strongly suggest you obtain,
-read and understand these papers.
-
-I am much indebted to the various authors for their help, support and
-advice.
-
diff --git a/CHANGES b/CHANGES
new file mode 100644
index 0000000..ac00f3a
--- /dev/null
+++ b/CHANGES
@@ -0,0 +1,45 @@
+
+
+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.
+
diff --git a/LICENSE b/LICENSE
index a43ea21..3de0301 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,339 +1,39 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
 
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-                          675 Mass Ave, Cambridge, MA 02139, USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
+This program, "bzip2" and associated library "libbzip2", are
+copyright (C) 1996-1998 Julian R Seward.  All rights reserved.
 
-                            Preamble
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
 
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
 
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
+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.
 
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
+3. Altered source versions must be plainly marked as such, and must
+   not be misrepresented as being the original software.
 
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
+4. The name of the author may not be used to endorse or promote 
+   products derived from this software without specific prior written 
+   permission.
 
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
+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.
 
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
+Julian Seward, Guildford, Surrey, UK.
+jseward@acm.org
+bzip2/libbzip2 version 0.9.0 of 28 June 1998
 
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-                            NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-        Appendix: How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) 19yy  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) 19yy name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
-Public License instead of this License.
diff --git a/Makefile b/Makefile
index 9d35b43..8ebea66 100644
--- a/Makefile
+++ b/Makefile
@@ -1,30 +1,46 @@
 
-CC = gcc
-SH = /bin/sh
-
-CFLAGS = -O3 -fomit-frame-pointer -funroll-loops
-
+CC=gcc
+CFLAGS=-Wall -O2 -fomit-frame-pointer -fno-strength-reduce
+
+OBJS= blocksort.o  \
+      huffman.o    \
+      crctable.o   \
+      randtable.o  \
+      compress.o   \
+      decompress.o \
+      bzlib.o
+
+all: lib bzip2 test
+
+bzip2: lib
+        $(CC) $(CFLAGS) -c bzip2.c
+        $(CC) $(CFLAGS) -o bzip2 bzip2.o -L. -lbz2
+        $(CC) $(CFLAGS) -o bzip2recover bzip2recover.c
 
+lib: $(OBJS)
+        rm -f libbz2.a
+        ar clq libbz2.a $(OBJS)
 
-all:
-        cat words0
-        $(CC) $(CFLAGS) -o bzip2 bzip2.c
-        $(CC) $(CFLAGS) -o bzip2recover bzip2recover.c
-        rm -f bunzip2
-        ln -s ./bzip2 ./bunzip2
-        cat words1
+test: bzip2
+        @cat words1
         ./bzip2 -1 < sample1.ref > sample1.rb2
         ./bzip2 -2 < sample2.ref > sample2.rb2
-        ./bunzip2 < sample1.bz2 > sample1.tst
-        ./bunzip2 < sample2.bz2 > sample2.tst
-        cat words2
+        ./bzip2 -d < sample1.bz2 > sample1.tst
+        ./bzip2 -d < sample2.bz2 > sample2.tst
+        @cat words2
         cmp sample1.bz2 sample1.rb2 
         cmp sample2.bz2 sample2.rb2
         cmp sample1.tst sample1.ref
         cmp sample2.tst sample2.ref
-        cat words3
+        @cat words3
+
+
+clean: 
+        rm -f *.o libbz2.a bzip2 bzip2recover sample1.rb2 sample2.rb2 sample1.tst sample2.tst
 
+.c.o: $*.o bzlib.h bzlib_private.h
+        $(CC) $(CFLAGS) -c $*.c -o $*.o
 
-clean:
-        rm -f bzip2 bunzip2 bzip2recover sample*.tst sample*.rb2
+tarfile:
+        tar cvf interim.tar *.c *.h Makefile manual.texi manual.ps LICENSE bzip2.1 bzip2.1.preformatted bzip2.txt words1 words2 words3 sample1.ref sample2.ref sample1.bz2 sample2.bz2 *.html README CHANGES libbz2.def libbz2.dsp dlltest.dsp 
 
diff --git a/README b/README
index d58bb49..2f59ef7 100644
--- a/README
+++ b/README
@@ -1,194 +1,61 @@
 
-GREETINGS!
 
-   This is the README for bzip2, my block-sorting file compressor,
-   version 0.1.  
+This is the README for bzip2, a block-sorting file compressor, version
+0.9.0.  This version is fully compatible with the previous public
+release, bzip2-0.1pl2.
 
-   bzip2 is distributed under the GNU General Public License version 2;
-   for details, see the file LICENSE.  Pointers to the algorithms used
-   are in ALGORITHMS.  Instructions for use are in bzip2.1.preformatted.
+bzip2-0.9.0 is distributed under a BSD-style license.  For details,
+see the file LICENSE.
 
-   Please read all of this file carefully.
+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.
 
 
+HOW TO BUILD -- UNIX
 
-HOW TO BUILD
+Type `make'.
 
-   -- for UNIX:
+This creates binaries "bzip2" and "bzip2recover".
 
-        Type `make'.     (tough, huh? :-)
+It also runs four compress-decompress tests to make sure things are
+working properly.  If all goes well, you should be up & running.
+Please be sure to read the output from `make' just to be sure that the
+tests went ok.
 
-        This creates binaries "bzip2", and "bunzip2",
-        which is a symbolic link to "bzip2".
+To install bzip2 properly:
 
-        It also runs four compress-decompress tests to make sure
-        things are working properly.  If all goes well, you should be up &
-        running.  Please be sure to read the output from `make'
-        just to be sure that the tests went ok.
+* Copy the binaries "bzip2" and "bzip2recover" to a publically visible 
+  place, possibly /usr/bin or /usr/local/bin.
 
-        To install bzip2 properly:
+* In that directory, make "bunzip2" and "bzcat" be symbolic links
+  to "bzip2".
 
-           -- Copy the binary "bzip2" to a publically visible place,
-              possibly /usr/bin, /usr/common/bin or /usr/local/bin.
-
-           -- In that directory, make "bunzip2" be a symbolic link
-              to "bzip2".
-
-           -- Copy the manual page, bzip2.1, to the relevant place.
-              Probably the right place is /usr/man/man1/.
-   
-   -- for Windows 95 and NT: 
+* Copy the manual page, bzip2.1, to the relevant place.
+  Probably the right place is /usr/man/man1/.
 
-        For a start, do you *really* want to recompile bzip2?  
-        The standard distribution includes a pre-compiled version
-        for Windows 95 and NT, `bzip2.exe'.
+If you want to program with the library, you'll need to copy libbz2.a
+and bzlib.h to /usr/lib and /usr/include respectively.
+  
 
-        This executable was created with Jacob Navia's excellent
-        port to Win32 of Chris Fraser & David Hanson's excellent
-        ANSI C compiler, "lcc".  You can get to it at the pages
-        of the CS department of Princeton University, 
-        www.cs.princeton.edu.  
-        I have not tried to compile this version of bzip2 with
-        a commercial C compiler such as MS Visual C, as I don't
-        have one available.
-
-        Note that lcc is designed primarily to be portable and
-        fast.  Code quality is a secondary aim, so bzip2.exe
-        runs perhaps 40% slower than it could if compiled with
-        a good optimising compiler.
-
-        I compiled a previous version of bzip (0.21) with Borland
-        C 5.0, which worked fine, and with MS VC++ 2.0, which
-        didn't.  Here is an comment from the README for bzip-0.21.
-
-           MS VC++ 2.0's optimising compiler has a bug which, at 
-           maximum optimisation, gives an executable which produces 
-           garbage compressed files.  Proceed with caution. 
-           I do not know whether or not this happens with later 
-           versions of VC++.
-
-           Edit the defines starting at line 86 of bzip.c to 
-           select your platform/compiler combination, and then compile.
-           Then check that the resulting executable (assumed to be 
-           called bzip.exe) works correctly, using the SELFTEST.BAT file.  
-           Bearing in mind the previous paragraph, the self-test is
-           important.
-
-        Note that the defines which bzip-0.21 had, to support 
-        compilation with VC 2.0 and BC 5.0, are gone.  Windows
-        is not my preferred operating system, and I am, for the
-        moment, content with the modestly fast executable created
-        by lcc-win32.
-
-   A manual page is supplied, unformatted (bzip2.1),
-   preformatted (bzip2.1.preformatted), and preformatted
-   and sanitised for MS-DOS (bzip2.txt).
-
-   
-
-COMPILATION NOTES
-
-   bzip2 should work on any 32 or 64-bit machine.  It is known to work
-   [meaning: it has compiled and passed self-tests] on the 
-   following platform-os combinations:
-
-      Intel i386/i486        running Linux 2.0.21
-      Sun Sparcs (various)   running SunOS 4.1.4 and Solaris 2.5
-      Intel i386/i486        running Windows 95 and NT
-      DEC Alpha              running Digital Unix 4.0
-
-   Following the release of bzip-0.21, many people mailed me
-   from around the world to say they had made it work on all sorts
-   of weird and wonderful machines.  Chances are, if you have
-   a reasonable ANSI C compiler and a 32-bit machine, you can
-   get it to work.
-
-   The #defines starting at around line 82 of bzip2.c supply some
-   degree of platform-independance.  If you configure bzip2 for some
-   new far-out platform which is not covered by the existing definitions,
-   please send me the relevant definitions.
-
-   I recommend GNU C for compilation.  The code is standard ANSI C,
-   except for the Unix-specific file handling, so any ANSI C compiler
-   should work.  Note however that the many routines marked INLINE
-   should be inlined by your compiler, else performance will be very
-   poor.  Asking your compiler to unroll loops gives some
-   small improvement too; for gcc, the relevant flag is
-   -funroll-loops.
-
-   On a 386/486 machines, I'd recommend giving gcc the
-   -fomit-frame-pointer flag; this liberates another register for
-   allocation, which measurably improves performance.
-
-   I used the abovementioned lcc compiler to develop bzip2.
-   I would highly recommend this compiler for day-to-day development;
-   it is fast, reliable, lightweight, has an excellent profiler,
-   and is generally excellent.  And it's fun to retarget, if you're
-   into that kind of thing.
-
-   If you compile bzip2 on a new platform or with a new compiler,
-   please be sure to run the four compress-decompress tests, either
-   using the Makefile, or with the test.bat (MSDOS) or test.cmd (OS/2)
-   files.  Some compilers have been seen to introduce subtle bugs
-   when optimising, so this check is important.  Ideally you should
-   then go on to test bzip2 on a file several megabytes or even
-   tens of megabytes long, just to be 110% sure.  ``Professional
-   programmers are paranoid programmers.'' (anon).
+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 my web page (http://www.muraroa.demon.co.uk).  Look there.
 
 
 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.  As test 
-   material, I used several runs over several filesystems of differing
-   sizes.
-
-   One set of tests was done on my base Linux filesystem,
-   410 megabytes in 23,000 files.  There were several runs over
-   this filesystem, in various configurations designed to break bzip2.
-   That filesystem also contained some specially constructed test
-   files designed to exercise boundary cases in the code.
-   This included files of zero length, various long, highly repetitive 
-   files, and some files which generate blocks with all values the same.
+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.
 
-   The other set of tests was done just with the "normal" configuration,
-   but on a much larger quantity of data.
-
-      Tests are:
-
-         Linux FS, 410M, 23000 files
-
-         As above, with --repetitive-fast
-
-         As above, with -1
-
-         Low level disk image of a disk containing
-            Windows NT4.0; 420M in a single huge file
-
-         Linux distribution, incl Slackware, 
-            all GNU sources.   1900M in 2300 files.
-
-         Approx ~100M compiler sources and related
-            programming tools, running under Purify.
-
-         About 500M of data in 120 files of around
-            4 M each.  This is raw data from a 
-            biomagnetometer (SQUID-based thing).
-
-      Overall, total volume of test data is about
-         3300 megabytes in 25000 files.
-
-   The distribution does four tests after building bzip.  These tests
-   include test decompressions of pre-supplied compressed files, so
-   they not only test that bzip works correctly on the machine it was
-   built on, but can also decompress files compressed on a different
-   machine.  This guards against unforseen interoperability problems.
 
 
 Please read and be aware of the following:
@@ -234,14 +101,30 @@ PATENTS:
 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)
+
+
 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 0.15 and 0.21, 
-and the changes in bzip2 are largely a result of this feedback.
-I thank you for your comments.
+comments, suggestions and patches after the releases of bzip-0.15,
+bzip-0.21 and bzip2-0.1pl2, 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 
+http://www.muraroa.demon.co.uk.
 
 Julian Seward
+jseward@acm.org
 
 Manchester, UK
 18 July 1996 (version 0.15)
@@ -250,4 +133,5 @@ Manchester, UK
 Guildford, Surrey, UK
 7 August 1997 (bzip2, version 0.1)
 29 August 1997 (bzip2, version 0.1pl2)
+23 August 1998 (bzip2, version 0.9.0)
 
diff --git a/README.DOS b/README.DOS
deleted file mode 100644
index 048de8c..0000000
--- a/README.DOS
+++ /dev/null
@@ -1,16 +0,0 @@
-

-As of today (3 March 1998) I've removed the 

-Win95/NT executables from this distribution, sorry.

-

-You can still get an executable from 

-http://www.muraroa.demon.co.uk, or (as a last

-resort) by mailing me at jseward@acm.org.

-

-The reason for this change of packaging is that it

-makes it easier for me to fix problems with specific

-executables if they are not included in the main

-distribution.

-

-J

-

-
diff --git a/blocksort.c b/blocksort.c
new file mode 100644
index 0000000..d8bb26a
--- /dev/null
+++ b/blocksort.c
@@ -0,0 +1,709 @@
+
+/*-------------------------------------------------------------*/
+/*--- 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-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
+
+  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"
+
+/*---------------------------------------------*/
+/*--
+  Compare two strings in block.  We assume (see
+  discussion above) that i1 and i2 have a max
+  offset of 10 on entry, and that the first
+  bytes of both block and quadrant have been
+  copied into the "overshoot area", ie
+  into the subscript range
+  [nblock .. nblock+NUM_OVERSHOOT_BYTES-1].
+--*/
+static __inline__ Bool fullGtU ( UChar*  block,
+                                 UInt16* quadrant,
+                                 UInt32  nblock,
+                                 Int32*  workDone, 
+                                 Int32   i1, 
+                                 Int32   i2
+                               )
+{
+   Int32 k;
+   UChar c1, c2;
+   UInt16 s1, s2;
+
+   AssertD ( i1 != i2, "fullGtU(1)" );
+
+   c1 = block[i1];
+   c2 = block[i2];
+   if (c1 != c2) return (c1 > c2);
+   i1++; i2++;
+
+   c1 = block[i1];
+   c2 = block[i2];
+   if (c1 != c2) return (c1 > c2);
+   i1++; i2++;
+
+   c1 = block[i1];
+   c2 = block[i2];
+   if (c1 != c2) return (c1 > c2);
+   i1++; i2++;
+
+   c1 = block[i1];
+   c2 = block[i2];
+   if (c1 != c2) return (c1 > c2);
+   i1++; i2++;
+
+   c1 = block[i1];
+   c2 = block[i2];
+   if (c1 != c2) return (c1 > c2);
+   i1++; i2++;
+
+   c1 = block[i1];
+   c2 = block[i2];
+   if (c1 != c2) return (c1 > c2);
+   i1++; i2++;
+
+   k = nblock;
+
+   do {
+
+      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++;
+
+      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++;
+
+      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++;
+
+      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 -= 4;
+      (*workDone)++;
+   }
+      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 simpleSort ( EState* s, Int32 lo, Int32 hi, Int32 d )
+{
+   Int32 i, j, h, bigN, hp;
+   Int32 v;
+
+   UChar*  block        = s->block;
+   UInt32* zptr         = s->zptr;
+   UInt16* quadrant     = s->quadrant;
+   Int32*  workDone     = &(s->workDone);
+   Int32   nblock       = s->nblock;
+   Int32   workLimit    = s->workLimit;
+   Bool    firstAttempt = s->firstAttempt;
+
+   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 = zptr[i];
+         j = i;
+         while ( fullGtU ( block, quadrant, nblock, workDone,
+                           zptr[j-h]+d, v+d ) ) {
+            zptr[j] = zptr[j-h];
+            j = j - h;
+            if (j <= (lo + h - 1)) break;
+         }
+         zptr[j] = v;
+         i++;
+
+         /*-- copy 2 --*/
+         if (i > hi) break;
+         v = zptr[i];
+         j = i;
+         while ( fullGtU ( block, quadrant, nblock, workDone,
+                 zptr[j-h]+d, v+d ) ) {
+            zptr[j] = zptr[j-h];
+            j = j - h;
+            if (j <= (lo + h - 1)) break;
+         }
+         zptr[j] = v;
+         i++;
+
+         /*-- copy 3 --*/
+         if (i > hi) break;
+         v = zptr[i];
+         j = i;
+         while ( fullGtU ( block, quadrant, nblock, workDone,
+                           zptr[j-h]+d, v+d ) ) {
+            zptr[j] = zptr[j-h];
+            j = j - h;
+            if (j <= (lo + h - 1)) break;
+         }
+         zptr[j] = v;
+         i++;
+
+         if (*workDone > workLimit && firstAttempt) 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 swap(lv1, lv2) \
+   { Int32 tmp = lv1; lv1 = lv2; lv2 = tmp; }
+
+static void vswap ( UInt32* zptr, Int32 p1, Int32 p2, Int32 n )
+{
+   while (n > 0) {
+      swap(zptr[p1], zptr[p2]);
+      p1++; p2++; n--;
+   }
+}
+
+static UChar med3 ( UChar a, UChar b, UChar c )
+{
+   UChar t;
+   if (a > b) { t = a; a = b; b = t; };
+   if (b > c) { t = b; b = c; c = t; };
+   if (a > b)          b = a;
+   return b;
+}
+
+
+#define min(a,b) ((a) < (b)) ? (a) : (b)
+
+typedef
+   struct { Int32 ll; Int32 hh; Int32 dd; }
+   StackElem;
+
+#define push(lz,hz,dz) { stack[sp].ll = lz; \
+                         stack[sp].hh = hz; \
+                         stack[sp].dd = dz; \
+                         sp++; }
+
+#define pop(lz,hz,dz) { sp--;               \
+                        lz = stack[sp].ll;  \
+                        hz = stack[sp].hh;  \
+                        dz = stack[sp].dd; }
+
+#define SMALL_THRESH 20
+#define DEPTH_THRESH 10
+
+/*--
+   If you are ever unlucky/improbable enough
+   to get a stack overflow whilst sorting,
+   increase the following constant and try
+   again.  In practice I have never seen the
+   stack go above 27 elems, so the following
+   limit seems very generous.
+--*/
+#define QSORT_STACK_SIZE 1000
+
+
+static void qSort3 ( EState* s, Int32 loSt, Int32 hiSt, Int32 dSt )
+{
+   Int32 unLo, unHi, ltLo, gtHi, med, n, m;
+   Int32 sp, lo, hi, d;
+   StackElem stack[QSORT_STACK_SIZE];
+
+   UChar*  block        = s->block;
+   UInt32* zptr         = s->zptr;
+   Int32*  workDone     = &(s->workDone);
+   Int32   workLimit    = s->workLimit;
+   Bool    firstAttempt = s->firstAttempt;
+
+   sp = 0;
+   push ( loSt, hiSt, dSt );
+
+   while (sp > 0) {
+
+      AssertH ( sp < QSORT_STACK_SIZE, 1001 );
+
+      pop ( lo, hi, d );
+
+      if (hi - lo < SMALL_THRESH || d > DEPTH_THRESH) {
+         simpleSort ( s, lo, hi, d );
+         if (*workDone > workLimit && firstAttempt) return;
+         continue;
+      }
+
+      med = med3 ( block[zptr[ lo         ]+d],
+                   block[zptr[ hi         ]+d],
+                   block[zptr[ (lo+hi)>>1 ]+d] );
+
+      unLo = ltLo = lo;
+      unHi = gtHi = hi;
+
+      while (True) {
+         while (True) {
+            if (unLo > unHi) break;
+            n = ((Int32)block[zptr[unLo]+d]) - med;
+            if (n == 0) { swap(zptr[unLo], zptr[ltLo]); ltLo++; unLo++; continue; };
+            if (n >  0) break;
+            unLo++;
+         }
+         while (True) {
+            if (unLo > unHi) break;
+            n = ((Int32)block[zptr[unHi]+d]) - med;
+            if (n == 0) { swap(zptr[unHi], zptr[gtHi]); gtHi--; unHi--; continue; };
+            if (n <  0) break;
+            unHi--;
+         }
+         if (unLo > unHi) break;
+         swap(zptr[unLo], zptr[unHi]); unLo++; unHi--;
+      }
+
+      AssertD ( unHi == unLo-1, "bad termination in qSort3" );
+
+      if (gtHi < ltLo) {
+         push(lo, hi, d+1 );
+         continue;
+      }
+
+      n = min(ltLo-lo, unLo-ltLo); vswap(zptr, lo, unLo-n, n);
+      m = min(hi-gtHi, gtHi-unHi); vswap(zptr, unLo, hi-m+1, m);
+
+      n = lo + unLo - ltLo - 1;
+      m = hi - (gtHi - unHi) + 1;
+
+      push ( lo, n, d );
+      push ( n+1, m-1, d+1 );
+      push ( m, hi, d );
+   }
+}
+
+
+/*---------------------------------------------*/
+
+#define BIGFREQ(b) (ftab[((b)+1) << 8] - ftab[(b) << 8])
+
+#define SETMASK (1 << 21)
+#define CLEARMASK (~(SETMASK))
+
+static void sortMain ( EState* s )
+{
+   Int32 i, j, k, ss, sb;
+   Int32 runningOrder[256];
+   Int32 copy[256];
+   Bool  bigDone[256];
+   UChar c1, c2;
+   Int32 numQSorted;
+
+   UChar*  block        = s->block;
+   UInt32* zptr         = s->zptr;
+   UInt16* quadrant     = s->quadrant;
+   Int32*  ftab         = s->ftab;
+   Int32*  workDone     = &(s->workDone);
+   Int32   nblock       = s->nblock;
+   Int32   workLimit    = s->workLimit;
+   Bool    firstAttempt = s->firstAttempt;
+
+   /*--
+      In the various block-sized structures, live data runs
+      from 0 to last+NUM_OVERSHOOT_BYTES inclusive.  First,
+      set up the overshoot area for block.
+   --*/
+
+   if (s->verbosity >= 4)
+      VPrintf0( "        sort initialise ...\n" );
+
+   for (i = 0; i < BZ_NUM_OVERSHOOT_BYTES; i++)
+       block[nblock+i] = block[i % nblock];
+   for (i = 0; i < nblock+BZ_NUM_OVERSHOOT_BYTES; i++)
+       quadrant[i] = 0;
+
+
+   if (nblock <= 4000) {
+
+      /*--
+         Use simpleSort(), since the full sorting mechanism
+         has quite a large constant overhead.
+      --*/
+      if (s->verbosity >= 4) VPrintf0( "        simpleSort ...\n" );
+      for (i = 0; i < nblock; i++) zptr[i] = i;
+      firstAttempt = False;
+      *workDone = workLimit = 0;
+      simpleSort ( s, 0, nblock-1, 0 );
+      if (s->verbosity >= 4) VPrintf0( "        simpleSort done.\n" );
+
+   } else {
+
+      numQSorted = 0;
+      for (i = 0; i <= 255; i++) bigDone[i] = False;
+
+      if (s->verbosity >= 4) VPrintf0( "        bucket sorting ...\n" );
+
+      for (i = 0; i <= 65536; i++) ftab[i] = 0;
+
+      c1 = block[nblock-1];
+      for (i = 0; i < nblock; i++) {
+         c2 = block[i];
+         ftab[(c1 << 8) + c2]++;
+         c1 = c2;
+      }
+
+      for (i = 1; i <= 65536; i++) ftab[i] += ftab[i-1];
+
+      c1 = block[0];
+      for (i = 0; i < nblock-1; i++) {
+         c2 = block[i+1];
+         j = (c1 << 8) + c2;
+         c1 = c2;
+         ftab[j]--;
+         zptr[ftab[j]] = i;
+      }
+      j = (block[nblock-1] << 8) + block[0];
+      ftab[j]--;
+      zptr[ftab[j]] = nblock-1;
+
+      /*--
+         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++) 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.
+      --*/
+
+      for (i = 0; i <= 255; i++) {
+
+         /*--
+            Process big buckets, starting with the least full.
+            Basically this is a 4-step process in which we call
+            qSort3 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 (s->verbosity >= 4)
+                        VPrintf4( "        qsort [0x%x, 0x%x]   done %d   this %d\n",
+                                  ss, j, numQSorted, hi - lo + 1 );
+                     qSort3 ( s, lo, hi, 2 );
+                     numQSorted += ( hi - lo + 1 );
+                     if (*workDone > workLimit && firstAttempt) return;
+                  }
+               }
+               ftab[sb] |= SETMASK;
+            }
+         }
+
+         /*--
+            Step 2:
+            Deal specially with case [ss, ss].  This establishes the
+            sorted order for [ss, ss] without any comparisons.  
+            A clever trick, cryptically described as steps Q6b and Q6c
+            in SRC-124 (aka BW94).  This makes it entirely practical to
+            not use a preliminary run-length coder, but unfortunately
+            we are now stuck with the .bz2 file format.
+         --*/
+         {
+            Int32 put0, get0, put1, get1;
+            Int32 sbn = (ss << 8) + ss;
+            Int32 lo = ftab[sbn] & CLEARMASK;
+            Int32 hi = (ftab[sbn+1] & CLEARMASK) - 1;
+            UChar ssc = (UChar)ss;
+            put0 = lo;
+            get0 = ftab[ss << 8] & CLEARMASK;
+            put1 = hi;
+            get1 = (ftab[(ss+1) << 8] & CLEARMASK) - 1;
+            while (get0 < put0) {
+               j = zptr[get0]-1; if (j < 0) j += nblock;
+               c1 = block[j];
+               if (c1 == ssc) { zptr[put0] = j; put0++; };
+               get0++;
+            }
+            while (get1 > put1) {
+               j = zptr[get1]-1; if (j < 0) j += nblock;
+               c1 = block[j];
+               if (c1 == ssc) { zptr[put1] = j; put1--; };
+               get1--;
+            }
+            ftab[sbn] |= 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
+            randomisation for very repetitive data.)
+
+            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 = 0; j < bbSize; j++) {
+               Int32 a2update     = zptr[bbStart + j];
+               UInt16 qVal        = (UInt16)(j >> shifts);
+               quadrant[a2update] = qVal;
+               if (a2update < BZ_NUM_OVERSHOOT_BYTES)
+                  quadrant[a2update + nblock] = qVal;
+            }
+
+            AssertH ( ( ((bbSize-1) >> shifts) <= 65535 ), 1002 );
+         }
+
+         /*--
+            Step 4:
+            Now scan this big bucket [ss] so as to synthesise the
+            sorted order for small buckets [t, ss] for all t != ss.
+            This will avoid doing Real Work in subsequent Step 1's.
+         --*/
+         for (j = 0; j <= 255; j++)
+            copy[j] = ftab[(j << 8) + ss] & CLEARMASK;
+
+         for (j = ftab[ss << 8] & CLEARMASK;
+              j < (ftab[(ss+1) << 8] & CLEARMASK);
+              j++) {
+            k = zptr[j]-1; if (k < 0) k += nblock;
+            c1 = block[k];
+            if ( ! bigDone[c1] ) {
+               zptr[copy[c1]] = k;
+               copy[c1] ++;
+            }
+         }
+
+         for (j = 0; j <= 255; j++) ftab[(j << 8) + ss] |= SETMASK;
+      }
+      if (s->verbosity >= 4)
+         VPrintf3( "        %d pointers, %d sorted, %d scanned\n",
+                   nblock, numQSorted, nblock - numQSorted );
+   }
+}
+
+
+/*---------------------------------------------*/
+static void randomiseBlock ( EState* s )
+{
+   Int32 i;
+   BZ_RAND_INIT_MASK;
+   for (i = 0; i < 256; i++) s->inUse[i] = False;
+
+   for (i = 0; i < s->nblock; i++) {
+      BZ_RAND_UPD_MASK;
+      s->block[i] ^= BZ_RAND_MASK;
+      s->inUse[s->block[i]] = True;
+   }
+}
+
+
+/*---------------------------------------------*/
+void blockSort ( EState* s )
+{
+   Int32 i;
+
+   s->workLimit       = s->workFactor * (s->nblock - 1);
+   s->workDone        = 0;
+   s->blockRandomised = False;
+   s->firstAttempt    = True;
+
+   sortMain ( s );
+
+   if (s->verbosity >= 3)
+      VPrintf3( "      %d work, %d block, ratio %5.2f\n",
+                s->workDone, s->nblock-1, 
+                (float)(s->workDone) / (float)(s->nblock-1) );
+
+   if (s->workDone > s->workLimit && s->firstAttempt) {
+      if (s->verbosity >= 2)
+         VPrintf0( "    sorting aborted; randomising block\n" );
+      randomiseBlock ( s );
+      s->workLimit = s->workDone = 0;
+      s->blockRandomised = True;
+      s->firstAttempt = False;
+      sortMain ( s );
+      if (s->verbosity >= 3)
+         VPrintf3( "      %d work, %d block, ratio %f\n",
+                   s->workDone, s->nblock-1, 
+                   (float)(s->workDone) / (float)(s->nblock-1) );
+   }
+
+   s->origPtr = -1;
+   for (i = 0; i < s->nblock; i++)
+       if (s->zptr[i] == 0)
+          { s->origPtr = i; break; };
+
+   AssertH( s->origPtr != -1, 1003 );
+}
+
+/*-------------------------------------------------------------*/
+/*--- end                                       blocksort.c ---*/
+/*-------------------------------------------------------------*/
diff --git a/bzip2.1 b/bzip2.1
index 489668f..a6789a4 100644
--- a/bzip2.1
+++ b/bzip2.1
@@ -1,21 +1,29 @@
 .PU
 .TH bzip2 1
 .SH NAME
-bzip2, bunzip2 \- a block-sorting file compressor, v0.1
+bzip2, bunzip2 \- a block-sorting file compressor, v0.9.0
+.br
+bzcat \- decompresses files to stdout
 .br
 bzip2recover \- recovers data from damaged bzip2 files
 
 .SH SYNOPSIS
 .ll +8
 .B bzip2
-.RB [ " \-cdfkstvVL123456789 " ]
+.RB [ " \-cdfkstvzVL123456789 " ]
 [
 .I "filenames \&..."
 ]
 .ll -8
 .br
 .B bunzip2
-.RB [ " \-kvsVL " ]
+.RB [ " \-fkvsVL " ]
+[
+.I "filenames \&..."
+]
+.br 
+.B bzcat
+.RB [ " \-s " ]
 [
 .I "filenames \&..."
 ]
@@ -24,7 +32,7 @@ bzip2recover \- recovers data from damaged bzip2 files
 .I "filename"
 
 .SH DESCRIPTION
-.I Bzip2
+.I bzip2
 compresses files using the Burrows-Wheeler block-sorting 
 text compression algorithm, and Huffman coding.
 Compression is generally considerably
@@ -38,7 +46,7 @@ those of
 .I GNU Gzip,
 but they are not identical.
 
-.I Bzip2 
+.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".
@@ -50,11 +58,11 @@ original file names, permissions and dates in filesystems
 which lack these concepts, or have serious file name length
 restrictions, such as MS-DOS.
 
-.I Bzip2
+.I bzip2
 and
 .I bunzip2
-will not overwrite existing files; if you want this to happen,
-you should delete them first.
+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
@@ -64,7 +72,7 @@ In this case,
 will decline to write compressed output to a terminal, as
 this would be entirely incomprehensible and therefore pointless.
 
-.I Bunzip2
+.I bunzip2
 (or
 .I bzip2 \-d
 ) decompresses and restores all specified files whose names
@@ -73,12 +81,28 @@ Files without this suffix are ignored.
 Again, 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.
-You can decompress multiple files like this, but you may
-only compress a single file this way, since it would otherwise
-be difficult to separate out the compressed representations of
-the original files.
+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.
 
 Compression is always performed, even if the compressed file is
 slightly larger than the original.  Files of less than about
@@ -132,7 +156,7 @@ Compression and decompression requirements, in bytes, can be estimated as:
 
       Compression:   400k + ( 7 x block size )
 
-      Decompression: 100k + ( 5 x block size ), or
+      Decompression: 100k + ( 4 x block size ), or
 .br
                      100k + ( 2.5 x block size )
 
@@ -147,7 +171,7 @@ choice of block size.
 
 For files compressed with the default 900k block size, 
 .I bunzip2
-will require about 4600 kbytes to decompress.
+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
@@ -168,8 +192,8 @@ For example, compressing a file 20,000 bytes long with the flag
 \-9
 will cause the compressor to allocate around
 6700k of memory, but only touch 400k + 20000 * 7 = 540
-kbytes of it.  Similarly, the decompressor will allocate 4600k but
-only touch 100k + 20000 * 5 = 200 kbytes.
+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
@@ -182,71 +206,73 @@ Corpus is dominated by smaller files.
            Compress   Decompress   Decompress   Corpus
     Flag     usage      usage       -s usage     Size
 
-     -1      1100k       600k         350k      914704
-     -2      1800k      1100k         600k      877703
-     -3      2500k      1600k         850k      860338
-     -4      3200k      2100k        1100k      846899
-     -5      3900k      2600k        1350k      845160
-     -6      4600k      3100k        1600k      838626
-     -7      5400k      3600k        1850k      834096
-     -8      6000k      4100k        2100k      828642
-     -9      6700k      4600k        2350k      828642
+     -1      1100k       500k         350k      914704
+     -2      1800k       900k         600k      877703
+     -3      2500k      1300k         850k      860338
+     -4      3200k      1700k        1100k      846899
+     -5      3900k      2100k        1350k      845160
+     -6      4600k      2500k        1600k      838626
+     -7      5400k      2900k        1850k      834096
+     -8      6000k      3300k        2100k      828642
+     -9      6700k      3700k        2350k      828642
 
 .SH OPTIONS
 .TP
-.B \-c  --stdout
+.B \-c --stdout
 Compress or decompress to standard output.  \-c will decompress
 multiple files to stdout, but will only compress a single file to
 stdout.
 .TP
 .B \-d --decompress
 Force decompression.
-.I Bzip2
-and
+.I bzip2,
 .I bunzip2
-are really the same program, and the decision about whether to
-compress or decompress is done on the basis of which name is
+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 \-f --compress
+.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,
-using the low-memory decompression algorithm (see \-s).
+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.
 .TP
 .B \-k --keep
 Keep (don't delete) input files during compression or decompression.
 .TP
 .B \-s --small
-Reduce memory usage, both for compression and decompression.
-Files are decompressed using a modified algorithm which only
+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 somewhat more slowly than
-usual.
+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 above.
-
 .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
+.B \-L --license -V --version
 Display the software version, license terms and conditions.
 .TP
-.B \-V --version
-Same as \-L.
-.TP
 .B \-1 to \-9 
 Set the block size to 100 k, 200 k .. 900 k when
 compressing.  Has no effect when decompressing.
@@ -329,10 +355,6 @@ to compress the latter.
 If you do get a file which causes severe slowness in compression,
 try making the block size as small as possible, with flag \-1.
 
-Incompressible or virtually-incompressible data may decompress
-rather more slowly than one would hope.  This is due to 
-a naive implementation of the move-to-front coder.
-
 .I bzip2
 usually allocates several megabytes of memory to operate in,
 and then charges all over it in a fairly random fashion.  This
@@ -346,28 +368,19 @@ I imagine
 .I bzip2
 will perform best on machines with very large caches.
 
-Test mode (\-t) uses the low-memory decompression algorithm
-(\-s).  This means test mode does not run as fast as it could;
-it could run as fast as the normal decompression machinery.
-This could easily be fixed at the cost of some code bloat.
-
 .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 0.1 of 
+This manual page pertains to version 0.9.0 of 
 .I bzip2.  
-It may well happen that some future version will
-use a different compressed file format.  If you try to 
-decompress, using 0.1, a .bz2 file created with some
-future version which uses a different compressed file format,
-0.1 will complain that your file "is not a bzip2 file".
-If that happens, you should obtain a more recent version
-of 
-.I bzip2
-and use that to decompress the file.
+Compressed data created by this version is entirely forwards and
+backwards compatible with the previous public release, version 0.1pl2,
+but with the following exception: 0.9.0 can correctly decompress
+multiple concatenated compressed files.  0.1pl2 cannot do this; it
+will stop after decompressing just the first file in the stream.
 
 Wildcard expansion for Windows 95 and NT 
 is flaky.
@@ -377,63 +390,25 @@ 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.
 
-.I bzip2recover
-sometimes reports a very small, incomplete final block.
-This is spurious and can be safely ignored.
-
-.SH RELATIONSHIP TO bzip-0.21
-This program is a descendant of the 
-.I bzip
-program, version 0.21, which I released in August 1996.  
-The primary difference of
-.I bzip2
-is its avoidance of the possibly patented algorithms
-which were used in 0.21.  
-.I bzip2
-also brings various useful refinements (\-s, \-t),
-uses less memory, decompresses significantly faster, and
-has support for recovering data from damaged files.
-
-Because
-.I bzip2
-uses Huffman coding to construct the compressed bitstream,
-rather than the arithmetic coding used in 0.21,
-the compressed representations generated by the two programs
-are incompatible, and they will not interoperate.  The change
-in suffix from .bz to .bz2 reflects this.  It would have been
-helpful to at least allow
-.I bzip2
-to decompress files created by 0.21, but this would
-defeat the primary aim of having a patent-free compressor.
-
-For a more precise statement about patent issues in
-bzip2, please see the README file in the distribution.
-
-Huffman coding necessarily involves some coding inefficiency
-compared to arithmetic coding.  This means that
-.I bzip2
-compresses about 1% worse than 0.21, an unfortunate but
-unavoidable fact-of-life.  On the other hand, decompression
-is approximately 50% faster for the same reason, and the
-change in file format gave an opportunity to add data-recovery
-features.  So it is not all bad.
-
 .SH AUTHOR
 Julian Seward, jseward@acm.org.
 
+http://www.muraroa.demon.co.uk
+
 The ideas embodied in 
-.I bzip
-and
 .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 0.21, 
+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 0.21).  I am much indebted for their help, support and advice.
-See the file ALGORITHMS in the source distribution for pointers to
+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.
diff --git a/bzip2.1.preformatted b/bzip2.1.preformatted
index 5206e05..8c4fab1 100644
--- a/bzip2.1.preformatted
+++ b/bzip2.1.preformatted
@@ -5,18 +5,20 @@ bzip2(1)                                                 bzip2(1)
 
 
 NNAAMMEE
-       bzip2, bunzip2 - a block-sorting file compressor, v0.1
+       bzip2, bunzip2 - a block-sorting file compressor, v0.9.0
+       bzcat - decompresses files to stdout
        bzip2recover - recovers data from damaged bzip2 files
 
 
 SSYYNNOOPPSSIISS
-       bbzziipp22 [ --ccddffkkssttvvVVLL112233445566778899 ] [ _f_i_l_e_n_a_m_e_s _._._.  ]
-       bbuunnzziipp22 [ --kkvvssVVLL ] [ _f_i_l_e_n_a_m_e_s _._._.  ]
+       bbzziipp22 [ --ccddffkkssttvvzzVVLL112233445566778899 ] [ _f_i_l_e_n_a_m_e_s _._._.  ]
+       bbuunnzziipp22 [ --ffkkvvssVVLL ] [ _f_i_l_e_n_a_m_e_s _._._.  ]
+       bbzzccaatt [ --ss ] [ _f_i_l_e_n_a_m_e_s _._._.  ]
        bbzziipp22rreeccoovveerr _f_i_l_e_n_a_m_e
 
 
 DDEESSCCRRIIPPTTIIOONN
-       _B_z_i_p_2  compresses  files  using the Burrows-Wheeler block-
+       _b_z_i_p_2  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,
@@ -26,7 +28,7 @@ DDEESSCCRRIIPPTTIIOONN
        The command-line options are deliberately very similar  to
        those of _G_N_U _G_z_i_p_, but they are not identical.
 
-       _B_z_i_p_2  expects  a list of file names to accompany the com-
+       _b_z_i_p_2  expects  a list of file names to accompany the com-
        mand-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  and
@@ -38,8 +40,8 @@ DDEESSCCRRIIPPTTIIOONN
        cepts, or have serious file name length restrictions, such
        as MS-DOS.
 
-       _B_z_i_p_2  and  _b_u_n_z_i_p_2  will not overwrite existing files; if
-       you want this to happen, you should delete them first.
+       _b_z_i_p_2  and  _b_u_n_z_i_p_2 will by default not overwrite existing
+       files; if you want this to happen, specify the -f flag.
 
        If no file names  are  specified,  _b_z_i_p_2  compresses  from
        standard  input  to  standard output.  In this case, _b_z_i_p_2
@@ -47,17 +49,15 @@ DDEESSCCRRIIPPTTIIOONN
        this  would  be  entirely  incomprehensible  and therefore
        pointless.
 
-       _B_u_n_z_i_p_2 (or _b_z_i_p_2 _-_d ) decompresses and restores all spec-
+       _b_u_n_z_i_p_2 (or _b_z_i_p_2 _-_d ) decompresses and restores all spec-
        ified files whose names end in ".bz2".  Files without this
        suffix are ignored.  Again, supplying no filenames  causes
        decompression from standard input to standard output.
 
-       You  can also compress or decompress files to the standard
-       output by giving the -c flag.  You can decompress multiple
-       files  like  this, but you may only compress a single file
-       this way, since it would otherwise be difficult  to  sepa-
-       rate  out  the  compressed representations of the original
-       files.
+       _b_u_n_z_i_p_2 will correctly decompress a file which is the con-
+       catenation of two or more compressed files.  The result is
+       the concatenation of the corresponding uncompressed files.
+       Integrity testing (-t) of concatenated compressed files is
 
 
 
@@ -70,6 +70,21 @@ DDEESSCCRRIIPPTTIIOONN
 bzip2(1)                                                 bzip2(1)
 
 
+       also supported.
+
+       You  can also compress or decompress files to the standard
+       output by giving the -c flag.  Multiple files may be  com-
+       pressed and decompressed like this.  The resulting outputs
+       are fed sequentially to stdout.  Compression  of  multiple
+       files  in this manner generates a stream containing multi-
+       ple compressed file representations.  Such a stream can be
+       decompressed  correctly  only  by  _b_z_i_p_2  version 0.9.0 or
+       later.  Earlier versions of _b_z_i_p_2 will stop  after  decom-
+       pressing the first file in the stream.
+
+       _b_z_c_a_t  (or _b_z_i_p_2 _-_d_c ) decompresses all specified files to
+       the standard output.
+
        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
@@ -108,36 +123,37 @@ MMEEMMOORRYY MMAANNAAGGEEMMEENNTT
        file, and _b_u_n_z_i_p_2 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.   Com-
-       pression  and decompression requirements, in bytes, can be
-       estimated as:
+       irrelevant  to  and  so  ignored   during   decompression.
 
-             Compression:   400k + ( 7 x block size )
 
-             Decompression: 100k + ( 5 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  _b_z_i_p_2  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.
+                                                                2
 
 
 
-                                                                2
 
 
+bzip2(1)                                                 bzip2(1)
 
 
+       Compression  and decompression requirements, in bytes, can
+       be estimated as:
 
-bzip2(1)                                                 bzip2(1)
+             Compression:   400k + ( 7 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  _b_z_i_p_2  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,
-       _b_u_n_z_i_p_2  will require about 4600 kbytes to decompress.  To
+       _b_u_n_z_i_p_2  will require about 3700 kbytes to decompress.  To
        support decompression of any file on a 4 megabyte machine,
        _b_u_n_z_i_p_2  has  an  option to decompress using approximately
        half this amount of memory, about 2300 kbytes.  Decompres-
@@ -157,8 +173,8 @@ bzip2(1)                                                 bzip2(1)
        file 20,000 bytes long with the flag  -9  will  cause  the
        compressor  to  allocate  around 6700k of memory, but only
        touch 400k + 20000 * 7 = 540 kbytes of it.  Similarly, the
-       decompressor  will  allocate  4600k  but only touch 100k +
-       20000 * 5 = 200 kbytes.
+       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
@@ -172,64 +188,66 @@ bzip2(1)                                                 bzip2(1)
                   Compress   Decompress   Decompress   Corpus
            Flag     usage      usage       -s usage     Size
 
-            -1      1100k       600k         350k      914704
-            -2      1800k      1100k         600k      877703
-            -3      2500k      1600k         850k      860338
-            -4      3200k      2100k        1100k      846899
-            -5      3900k      2600k        1350k      845160
-            -6      4600k      3100k        1600k      838626
-            -7      5400k      3600k        1850k      834096
-            -8      6000k      4100k        2100k      828642
-            -9      6700k      4600k        2350k      828642
+            -1      1100k       500k         350k      914704
+            -2      1800k       900k         600k      877703
 
 
-OOPPTTIIOONNSS
-       --cc ----ssttddoouutt
-              Compress or decompress to standard output.  -c will
-              decompress multiple files to stdout, but will  only
-              compress a single file to stdout.
-
 
+                                                                3
 
 
 
-                                                                3
 
 
+bzip2(1)                                                 bzip2(1)
 
 
+            -3      2500k      1300k         850k      860338
+            -4      3200k      1700k        1100k      846899
+            -5      3900k      2100k        1350k      845160
+            -6      4600k      2500k        1600k      838626
+            -7      5400k      2900k        1850k      834096
+            -8      6000k      3300k        2100k      828642
+            -9      6700k      3700k        2350k      828642
 
-bzip2(1)                                                 bzip2(1)
 
+OOPPTTIIOONNSS
+       --cc ----ssttddoouutt
+              Compress or decompress to standard output.  -c will
+              decompress multiple files to stdout, but will  only
+              compress a single file to stdout.
 
        --dd ----ddeeccoommpprreessss
-              Force  decompression.  _B_z_i_p_2 and _b_u_n_z_i_p_2 are really
-              the same program, and the decision about whether to
-              compress  or  decompress  is  done  on the basis of
-              which name is used.  This flag overrides that mech-
-              anism, and forces _b_z_i_p_2 to decompress.
+              Force  decompression.  _b_z_i_p_2_, _b_u_n_z_i_p_2 and _b_z_c_a_t 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 _b_z_i_p_2 to decompress.
 
-       --ff ----ccoommpprreessss
+       --zz ----ccoommpprreessss
               The  complement  to -d: forces compression, regard-
               less of the invokation name.
 
        --tt ----tteesstt
               Check integrity of the specified file(s), but don't
               decompress  them.   This  really  performs  a trial
-              decompression and throws away the result, using the
-              low-memory decompression algorithm (see -s).
+              decompression and throws away the result.
+
+       --ff ----ffoorrccee
+              Force overwrite of output files.   Normally,  _b_z_i_p_2
+              will not overwrite existing output files.
 
        --kk ----kkeeeepp
               Keep  (don't delete) input files during compression
               or decompression.
 
        --ss ----ssmmaallll
-              Reduce  memory  usage,  both  for  compression  and
-              decompression.  Files are decompressed using a mod-
-              ified algorithm which only requires 2.5  bytes  per
-              block  byte.   This  means  any  file can be decom-
-              pressed in 2300k of memory,  albeit  somewhat  more
-              slowly than usual.
+              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
@@ -239,35 +257,32 @@ bzip2(1)                                                 bzip2(1)
               MEMORY MANAGEMENT above.
 
 
+
+
+                                                                4
+
+
+
+
+
+bzip2(1)                                                 bzip2(1)
+
+
        --vv ----vveerrbboossee
               Verbose mode -- show the compression ratio for each
               file  processed.   Further  -v's  increase the ver-
               bosity level, spewing out lots of information which
               is primarily of interest for diagnostic purposes.
 
-       --LL ----lliicceennssee
+       --LL ----lliicceennssee --VV ----vveerrssiioonn
               Display  the  software  version,  license terms and
               conditions.
 
-       --VV ----vveerrssiioonn
-              Same as -L.
-
        --11 ttoo --99
               Set the block size to 100 k, 200 k ..  900  k  when
               compressing.   Has  no  effect  when decompressing.
               See MEMORY MANAGEMENT above.
 
-
-
-                                                                4
-
-
-
-
-
-bzip2(1)                                                 bzip2(1)
-
-
        ----rreeppeettiittiivvee--ffaasstt
               _b_z_i_p_2 injects some small  pseudo-random  variations
               into  very  repetitive  blocks  to limit worst-case
@@ -306,34 +321,34 @@ RREECCOOVVEERRIINNGG DDAATTAA FFRROOMM DDAAMMAAGGEEDD F
        _b_z_i_p_2_r_e_c_o_v_e_r takes a single argument, the name of the dam-
        aged 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 wild-
-       cards in subsequent processing -- for example, "bzip2  -dc
-       rec*file.bz2  >  recovered_data" -- lists the files in the
-       "right" order.
+       The  output  filenames  are  designed  so  that the use of
 
-       _b_z_i_p_2_r_e_c_o_v_e_r 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 min-
-       imise any potential data loss through media  or  transmis-
-       sion errors, you might consider compressing with a smaller
-       block size.
 
 
-PPEERRFFOORRMMAANNCCEE NNOOTTEESS
-       The sorting phase of compression gathers together  similar
+                                                                5
 
 
 
-                                                                5
 
 
+bzip2(1)                                                 bzip2(1)
 
 
+       wildcards in subsequent processing -- for example,  "bzip2
+       -dc  rec*file.bz2  > recovered_data" -- lists the files in
+       the "right" order.
 
-bzip2(1)                                                 bzip2(1)
+       _b_z_i_p_2_r_e_c_o_v_e_r 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 min-
+       imise any potential data loss through media  or  transmis-
+       sion errors, you might consider compressing with a smaller
+       block size.
 
 
+PPEERRFFOORRMMAANNCCEE NNOOTTEESS
+       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
@@ -348,10 +363,6 @@ bzip2(1)                                                 bzip2(1)
        severe slowness in compression, try making the block  size
        as small as possible, with flag -1.
 
-       Incompressible or virtually-incompressible data may decom-
-       press rather more slowly than one would hope.  This is due
-       to a naive implementation of the move-to-front coder.
-
        _b_z_i_p_2  usually  allocates  several  megabytes of memory to
        operate in, and then charges all over it in a fairly  ran-
        dom  fashion.   This means that performance, both for com-
@@ -362,12 +373,6 @@ bzip2(1)                                                 bzip2(1)
        large performance improvements.  I imagine _b_z_i_p_2 will per-
        form best on machines with very large caches.
 
-       Test mode (-t) uses the low-memory decompression algorithm
-       (-s).  This means test mode does not run  as  fast  as  it
-       could;  it  could  run as fast as the normal decompression
-       machinery.  This could easily be fixed at the cost of some
-       code bloat.
-
 
 CCAAVVEEAATTSS
        I/O  error  messages  are not as helpful as they could be.
@@ -375,19 +380,14 @@ CCAAVVEEAATTSS
        but  the  details  of  what  the problem is sometimes seem
        rather misleading.
 
-       This manual page pertains to version 0.1 of _b_z_i_p_2_.  It may
-       well  happen that some future version will use a different
-       compressed file format.  If you try to  decompress,  using
-       0.1,  a  .bz2  file created with some future version which
-       uses a different compressed file format, 0.1 will complain
-       that  your  file  "is not a bzip2 file".  If that happens,
-       you should obtain a more recent version of _b_z_i_p_2  and  use
-       that to decompress the file.
+       This manual page pertains to version 0.9.0 of _b_z_i_p_2_.  Com-
+       pressed  data created by this version is entirely forwards
+       and backwards compatible with the previous public release,
+       version  0.1pl2,  but  with the following exception: 0.9.0
+       can correctly decompress multiple concatenated  compressed
+       files.   0.1pl2  cannot do this; it will stop after decom-
+       pressing just the first file in the stream.
 
-       Wildcard expansion for Windows 95 and NT is flaky.
-
-       _b_z_i_p_2_r_e_c_o_v_e_r  uses  32-bit integers to represent bit posi-
-       tions in compressed files, so it cannot handle  compressed
 
 
 
@@ -400,61 +400,59 @@ CCAAVVEEAATTSS
 bzip2(1)                                                 bzip2(1)
 
 
-       files  more than 512 megabytes long.  This could easily be
+       Wildcard expansion for Windows 95 and NT is flaky.
+
+       _b_z_i_p_2_r_e_c_o_v_e_r uses 32-bit integers to represent  bit  posi-
+       tions  in compressed files, so it cannot handle compressed
+       files more than 512 megabytes long.  This could easily  be
        fixed.
 
-       _b_z_i_p_2_r_e_c_o_v_e_r sometimes reports a  very  small,  incomplete
-       final  block.  This is spurious and can be safely ignored.
+
+AAUUTTHHOORR
+       Julian Seward, jseward@acm.org.
+       http://www.muraroa.demon.co.uk
+
+       The ideas embodied in _b_z_i_p_2 are due to (at least) the fol-
+       lowing people: Michael Burrows and David Wheeler (for  the
+       block  sorting  transformation), David Wheeler (again, for
+       the Huffman coder), Peter Fenwick (for the structured cod-
+       ing model in the original _b_z_i_p_, and many refinements), and
+       Alistair Moffat, Radford Neal  and  Ian  Witten  (for  the
+       arithmetic  coder  in  the  original  _b_z_i_p_)_.   I  am  much
+       indebted for their help, support and advice.  See the man-
+       ual  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 compres-
+       sion.  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.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
-RREELLAATTIIOONNSSHHIIPP TTOO bbzziipp--00..2211
-       This program is a descendant of the _b_z_i_p program,  version
-       0.21,  which  I released in August 1996.  The primary dif-
-       ference of _b_z_i_p_2 is its avoidance of the possibly patented
-       algorithms  which  were  used  in 0.21.  _b_z_i_p_2 also brings
-       various useful refinements (-s,  -t),  uses  less  memory,
-       decompresses  significantly  faster,  and  has support for
-       recovering data from damaged files.
 
-       Because _b_z_i_p_2 uses Huffman coding to  construct  the  com-
-       pressed  bitstream, rather than the arithmetic coding used
-       in 0.21, the compressed representations generated  by  the
-       two  programs are incompatible, and they will not interop-
-       erate.  The change in suffix from  .bz  to  .bz2  reflects
-       this.   It would have been helpful to at least allow _b_z_i_p_2
-       to decompress files created by 0.21, but this would defeat
-       the primary aim of having a patent-free compressor.
 
-       For a more precise statement about patent issues in bzip2,
-       please see the README file in the distribution.
 
-       Huffman  coding  necessarily  involves some coding ineffi-
-       ciency compared to arithmetic  coding.   This  means  that
-       _b_z_i_p_2  compresses about 1% worse than 0.21, an unfortunate
-       but unavoidable fact-of-life.  On the other  hand,  decom-
-       pression  is approximately 50% faster for the same reason,
-       and the change in file format gave an opportunity  to  add
-       data-recovery features.  So it is not all bad.
 
 
-AAUUTTHHOORR
-       Julian Seward, jseward@acm.org.
 
-       The ideas embodied in _b_z_i_p and _b_z_i_p_2 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 0.21, and many refinements),
-       and Alistair Moffat, Radford Neal and Ian Witten (for  the
-       arithmetic  coder  in 0.21).  I am much indebted for their
-       help, support and advice.  See the file ALGORITHMS in  the
-       source  distribution for pointers to sources of documenta-
-       tion.  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  com-
-       pression  performance.   Many  people sent patches, helped
-       with portability problems, lent machines, gave advice  and
-       were generally helpful.
 
 
 
diff --git a/bzip2.c b/bzip2.c
index 53ce10d..6a3ab95 100644
--- a/bzip2.c
+++ b/bzip2.c
@@ -4,28 +4,45 @@
 /*-----------------------------------------------------------*/
 
 /*--
-  This program is bzip2, a lossless, block-sorting data compressor,
-  version 0.1pl2, dated 29-Aug-1997.
-
-  Copyright (C) 1996, 1997 by Julian Seward.
-     Guildford, Surrey, UK
-     email: jseward@acm.org
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-  The GNU General Public License is contained in the file LICENSE.
+  This file is a part of bzip2 and/or libbzip2, a program and
+  library for lossless, block-sorting data compression.
+
+  Copyright (C) 1996-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
 
   This program is based on (at least) the work of:
      Mike Burrows
@@ -37,21 +54,23 @@
      Robert Sedgewick
      Jon L. Bentley
 
-  For more information on these sources, see the file ALGORITHMS.
+  For more information on these sources, see the manual.
 --*/
 
+
 /*----------------------------------------------------*/
 /*--- IMPORTANT                                    ---*/
 /*----------------------------------------------------*/
 
 /*--
    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 disasterous loss of data.
+      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
@@ -65,18 +84,19 @@
       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.
+      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 has been
-      carefully constructed and extensively tested.
+      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 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.
+      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.
 --*/
 
 
@@ -103,6 +123,10 @@
 --*/
 #define BZ_LCCWIN32  0
 
+#ifdef _WIN32
+#define BZ_LCCWIN32 1
+#define BZ_UNIX 0
+#endif
 
 
 /*---------------------------------------------*/
@@ -112,12 +136,10 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#if DEBUG
-  #include <assert.h>
-#endif
 #include <string.h>
 #include <signal.h>
 #include <math.h>
+#include "bzlib.h"
 
 #define ERROR_IF_EOF(i)       { if ((i) == EOF)  ioError(); }
 #define ERROR_IF_NOT_ZERO(i)  { if ((i) != 0)    ioError(); }
@@ -130,68 +152,45 @@
 --*/
 
 #if BZ_UNIX
-   #include <sys/types.h>
-   #include <utime.h>
-   #include <unistd.h>
-   #include <malloc.h>
-   #include <sys/stat.h>
-   #include <sys/times.h>
-
-   #define Int32   int
-   #define UInt32  unsigned int
-   #define Char    char
-   #define UChar   unsigned char
-   #define Int16   short
-   #define UInt16  unsigned short
-
-   #define PATH_SEP    '/'
-   #define MY_LSTAT    lstat
-   #define MY_S_IFREG  S_ISREG
-   #define MY_STAT     stat
-
-   #define APPEND_FILESPEC(root, name) \
+#   include <sys/types.h>
+#   include <utime.h>
+#   include <unistd.h>
+#   include <sys/stat.h>
+#   include <sys/times.h>
+
+#   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 SET_BINARY_MODE(fd) /**/
-
-   /*--
-      You should try very hard to persuade your C compiler
-      to inline the bits marked INLINE.  Otherwise bzip2 will
-      run rather slowly.  gcc version 2.x is recommended.
-   --*/
-   #ifdef __GNUC__
-      #define INLINE   inline
-      #define NORETURN __attribute__ ((noreturn))
-   #else
-      #define INLINE   /**/
-      #define NORETURN /**/
-   #endif
+#   define SET_BINARY_MODE(fd) /**/
+
+#   ifdef __GNUC__
+#      define NORETURN __attribute__ ((noreturn))
+#   else
+#      define NORETURN /**/
+#   endif
 #endif
 
 
 
 #if BZ_LCCWIN32
-   #include <io.h>
-   #include <fcntl.h>
-   #include <sys\stat.h>
-
-   #define Int32   int
-   #define UInt32  unsigned int
-   #define Int16   short
-   #define UInt16  unsigned short
-   #define Char    char
-   #define UChar   unsigned char
-
-   #define INLINE         /**/
-   #define NORETURN       /**/
-   #define PATH_SEP       '\\'
-   #define MY_LSTAT       _stat
-   #define MY_STAT        _stat
-   #define MY_S_IFREG(x)  ((x) & _S_IFREG)
-
-   #if 0
+#   include <io.h>
+#   include <fcntl.h>
+#   include <sys\stat.h>
+
+#   define NORETURN       /**/
+#   define PATH_SEP       '\\'
+#   define MY_LSTAT       _stat
+#   define MY_STAT        _stat
+#   define MY_S_IFREG(x)  ((x) & _S_IFREG)
+
+#   if 0
    /*-- lcc-win32 seems to expand wildcards itself --*/
-   #define APPEND_FILESPEC(root, spec)                \
+#   define APPEND_FILESPEC(root, spec)                \
       do {                                            \
          if ((spec)[0] == '-') {                      \
             root = snocString((root), (spec));        \
@@ -211,12 +210,12 @@
             }                                         \
          }                                            \
       } while ( 0 )
-   #else
-   #define APPEND_FILESPEC(root, name)                \
+#   else
+#   define APPEND_FILESPEC(root, name)                \
       root = snocString ((root), (name))
-   #endif
+#   endif
 
-   #define SET_BINARY_MODE(fd)                        \
+#   define SET_BINARY_MODE(fd)                        \
       do {                                            \
          int retVal = setmode ( fileno ( fd ),        \
                                O_BINARY );            \
@@ -231,111 +230,32 @@
   Some more stuff for all platforms :-)
 --*/
 
-#define Bool   unsigned char
-#define True   1
-#define False  0
+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.
 --*/
-#define IntNative int
-
-
-/*--
-   change to 1, or compile with -DDEBUG=1 to debug
---*/
-#ifndef DEBUG
-#define DEBUG 0
-#endif
-
-
-/*---------------------------------------------------*/
-/*---                                             ---*/
-/*---------------------------------------------------*/
-
-/*--
-   Implementation notes, July 1997
-   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-   Memory allocation
-   ~~~~~~~~~~~~~~~~~
-   All large data structures are allocated on the C heap,
-   for better or for worse.  That includes the various
-   arrays of pointers, striped words, bytes, frequency
-   tables and buffers for compression and decompression.
-
-   bzip2 can operate at various block-sizes, ranging from
-   100k to 900k in 100k steps, and it allocates only as
-   much as it needs to.  When compressing, we know from the
-   command-line options what the block-size is going to be,
-   so all allocation can be done at start-up; if that
-   succeeds, there can be no further allocation problems.
-
-   Decompression is more complicated.  Each compressed file
-   contains, in its header, a byte indicating the block
-   size used for compression.  This means bzip2 potentially
-   needs to reallocate memory for each file it deals with,
-   which in turn opens the possibility for a memory allocation
-   failure part way through a run of files, by encountering
-   a file requiring a much larger block size than all the
-   ones preceding it.
-
-   The policy is to simply give up if a memory allocation
-   failure occurs.  During decompression, it would be
-   possible to move on to subsequent files in the hope that
-   some might ask for a smaller block size, but the
-   complications for doing this seem more trouble than they
-   are worth.
-
-
-   Compressed file formats
-   ~~~~~~~~~~~~~~~~~~~~~~~
-   [This is now entirely different from both 0.21, and from
-    any previous Huffman-coded variant of bzip.
-    See the associated file bzip2.txt for details.]
-
-
-   Error conditions
-   ~~~~~~~~~~~~~~~~
-   Dealing with error conditions is the least satisfactory
-   aspect of bzip2.  The policy is to try and leave the
-   filesystem in a consistent state, then quit, even if it
-   means not processing some of the files mentioned in the
-   command line.  `A consistent state' means that a file
-   exists either in its compressed or uncompressed form,
-   but not both.  This boils down to the rule `delete the
-   output file if an error condition occurs, leaving the
-   input intact'.  Input files are only deleted when we can
-   be pretty sure the output file has been written and
-   closed successfully.
-
-   Errors are a dog because there's so many things to
-   deal with.  The following can happen mid-file, and
-   require cleaning up.
-
-     internal `panics' -- indicating a bug
-     corrupted or inconsistent compressed file
-     can't allocate enough memory to decompress this file
-     I/O error reading/writing/opening/closing
-     signal catches -- Control-C, SIGTERM, SIGHUP.
-
-   Other conditions, primarily pertaining to file names,
-   can be checked in-between files, which makes dealing
-   with them easier.
---*/
-
+typedef int IntNative;
 
 
 /*---------------------------------------------------*/
 /*--- Misc (file handling) data decls             ---*/
 /*---------------------------------------------------*/
 
-UInt32  bytesIn, bytesOut;
 Int32   verbosity;
-Bool    keepInputFiles, smallMode, testFailsExist;
-UInt32  globalCrc;
-Int32   numFileNames, numFilesProcessed;
+Bool    keepInputFiles, smallMode;
+Bool    forceOverwrite, testFailsExist;
+Int32   numFileNames, numFilesProcessed, blockSize100k;
 
 
 /*-- source modes; F==file, I==stdin, O==stdout --*/
@@ -351,2691 +271,304 @@ Int32   numFileNames, numFilesProcessed;
 Int32   opMode;
 Int32   srcMode;
 
+#define FILE_NAME_LEN 1034
 
 Int32   longestFileName;
-Char    inName[1024];
-Char    outName[1024];
+Char    inName[FILE_NAME_LEN];
+Char    outName[FILE_NAME_LEN];
 Char    *progName;
-Char    progNameReally[1024];
+Char    progNameReally[FILE_NAME_LEN];
 FILE    *outputHandleJustInCase;
-
-void    panic                 ( Char* )          NORETURN;
-void    ioError               ( void )           NORETURN;
-void    compressOutOfMemory   ( Int32, Int32 )   NORETURN;
-void    uncompressOutOfMemory ( Int32, Int32 )   NORETURN;
-void    blockOverrun          ( void )           NORETURN;
-void    badBlockHeader        ( void )           NORETURN;
-void    badBGLengths          ( void )           NORETURN;
-void    crcError              ( UInt32, UInt32 ) NORETURN;
-void    bitStreamEOF          ( void )           NORETURN;
-void    cleanUpAndFail        ( Int32 )          NORETURN;
-void    compressedStreamEOF   ( void )           NORETURN;
-
+Int32   workFactor;
+
+void    panic                 ( Char* )   NORETURN;
+void    ioError               ( void )    NORETURN;
+void    outOfMemory           ( void )    NORETURN;
+void    blockOverrun          ( void )    NORETURN;
+void    badBlockHeader        ( void )    NORETURN;
+void    badBGLengths          ( void )    NORETURN;
+void    crcError              ( void )    NORETURN;
+void    bitStreamEOF          ( void )    NORETURN;
+void    cleanUpAndFail        ( Int32 )   NORETURN;
+void    compressedStreamEOF   ( void )    NORETURN;
+
+void    copyFileName ( Char*, Char* );
 void*   myMalloc ( Int32 );
 
 
 
 /*---------------------------------------------------*/
-/*--- Data decls for the front end                ---*/
-/*---------------------------------------------------*/
-
-/*--
-   The overshoot bytes allow us to avoid most of
-   the cost of pointer renormalisation during
-   comparison of rotations in sorting.
-   The figure of 20 is derived as follows:
-      qSort3 allows an overshoot of up to 10.
-      It then calls simpleSort, which calls
-      fullGtU, also with max overshoot 10.
-      fullGtU does up to 10 comparisons without
-      renormalising, giving 10+10 == 20.
---*/
-#define NUM_OVERSHOOT_BYTES 20
-
-/*--
-  These are the main data structures for
-  the Burrows-Wheeler transform.
---*/
-
-/*--
-  Pointers to compression and decompression
-  structures.  Set by
-     allocateCompressStructures   and
-     setDecompressStructureSizes
-
-  The structures are always set to be suitable
-  for a block of size 100000 * blockSize100k.
---*/
-UChar    *block;    /*-- compress   --*/
-UInt16   *quadrant; /*-- compress   --*/
-Int32    *zptr;     /*-- compress   --*/ 
-UInt16   *szptr;    /*-- overlays zptr ---*/
-Int32    *ftab;     /*-- compress   --*/
-
-UInt16   *ll16;     /*-- small decompress --*/
-UChar    *ll4;      /*-- small decompress --*/
-
-Int32    *tt;       /*-- fast decompress  --*/
-UChar    *ll8;      /*-- fast decompress  --*/
-
-
-/*--
-  freq table collected to save a pass over the data
-  during decompression.
---*/
-Int32   unzftab[256];
-
-
-/*--
-   index of the last char in the block, so
-   the block size == last + 1.
---*/
-Int32  last;
-
-
-/*--
-  index in zptr[] of original string after sorting.
---*/
-Int32  origPtr;
-
-
-/*--
-  always: in the range 0 .. 9.
-  The current block size is 100000 * this number.
---*/
-Int32  blockSize100k;
-
-
-/*--
-  Used when sorting.  If too many long comparisons
-  happen, we stop sorting, randomise the block 
-  slightly, and try again.
---*/
-
-Int32  workFactor;
-Int32  workDone;
-Int32  workLimit;
-Bool   blockRandomised;
-Bool   firstAttempt;
-Int32  nBlocksRandomised;
-
-
-
-/*---------------------------------------------------*/
-/*--- Data decls for the back end                 ---*/
-/*---------------------------------------------------*/
-
-#define MAX_ALPHA_SIZE 258
-#define MAX_CODE_LEN    23
-
-#define RUNA 0
-#define RUNB 1
-
-#define N_GROUPS 6
-#define G_SIZE   50
-#define N_ITERS  4
-
-#define MAX_SELECTORS (2 + (900000 / G_SIZE))
-
-Bool  inUse[256];
-Int32 nInUse;
-
-UChar seqToUnseq[256];
-UChar unseqToSeq[256];
-
-UChar selector   [MAX_SELECTORS];
-UChar selectorMtf[MAX_SELECTORS];
-
-Int32 nMTF;
-
-Int32 mtfFreq[MAX_ALPHA_SIZE];
-
-UChar len  [N_GROUPS][MAX_ALPHA_SIZE];
-
-/*-- decompress only --*/
-Int32 limit  [N_GROUPS][MAX_ALPHA_SIZE];
-Int32 base   [N_GROUPS][MAX_ALPHA_SIZE];
-Int32 perm   [N_GROUPS][MAX_ALPHA_SIZE];
-Int32 minLens[N_GROUPS];
-
-/*-- compress only --*/
-Int32  code [N_GROUPS][MAX_ALPHA_SIZE];
-Int32  rfreq[N_GROUPS][MAX_ALPHA_SIZE];
-
-
-/*---------------------------------------------------*/
-/*--- 32-bit CRC grunge                           ---*/
-/*---------------------------------------------------*/
-
-/*--
-  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 crc32Table[256] = {
-
-   /*-- Ugly, innit? --*/
-
-   0x00000000UL, 0x04c11db7UL, 0x09823b6eUL, 0x0d4326d9UL,
-   0x130476dcUL, 0x17c56b6bUL, 0x1a864db2UL, 0x1e475005UL,
-   0x2608edb8UL, 0x22c9f00fUL, 0x2f8ad6d6UL, 0x2b4bcb61UL,
-   0x350c9b64UL, 0x31cd86d3UL, 0x3c8ea00aUL, 0x384fbdbdUL,
-   0x4c11db70UL, 0x48d0c6c7UL, 0x4593e01eUL, 0x4152fda9UL,
-   0x5f15adacUL, 0x5bd4b01bUL, 0x569796c2UL, 0x52568b75UL,
-   0x6a1936c8UL, 0x6ed82b7fUL, 0x639b0da6UL, 0x675a1011UL,
-   0x791d4014UL, 0x7ddc5da3UL, 0x709f7b7aUL, 0x745e66cdUL,
-   0x9823b6e0UL, 0x9ce2ab57UL, 0x91a18d8eUL, 0x95609039UL,
-   0x8b27c03cUL, 0x8fe6dd8bUL, 0x82a5fb52UL, 0x8664e6e5UL,
-   0xbe2b5b58UL, 0xbaea46efUL, 0xb7a96036UL, 0xb3687d81UL,
-   0xad2f2d84UL, 0xa9ee3033UL, 0xa4ad16eaUL, 0xa06c0b5dUL,
-   0xd4326d90UL, 0xd0f37027UL, 0xddb056feUL, 0xd9714b49UL,
-   0xc7361b4cUL, 0xc3f706fbUL, 0xceb42022UL, 0xca753d95UL,
-   0xf23a8028UL, 0xf6fb9d9fUL, 0xfbb8bb46UL, 0xff79a6f1UL,
-   0xe13ef6f4UL, 0xe5ffeb43UL, 0xe8bccd9aUL, 0xec7dd02dUL,
-   0x34867077UL, 0x30476dc0UL, 0x3d044b19UL, 0x39c556aeUL,
-   0x278206abUL, 0x23431b1cUL, 0x2e003dc5UL, 0x2ac12072UL,
-   0x128e9dcfUL, 0x164f8078UL, 0x1b0ca6a1UL, 0x1fcdbb16UL,
-   0x018aeb13UL, 0x054bf6a4UL, 0x0808d07dUL, 0x0cc9cdcaUL,
-   0x7897ab07UL, 0x7c56b6b0UL, 0x71159069UL, 0x75d48ddeUL,
-   0x6b93dddbUL, 0x6f52c06cUL, 0x6211e6b5UL, 0x66d0fb02UL,
-   0x5e9f46bfUL, 0x5a5e5b08UL, 0x571d7dd1UL, 0x53dc6066UL,
-   0x4d9b3063UL, 0x495a2dd4UL, 0x44190b0dUL, 0x40d816baUL,
-   0xaca5c697UL, 0xa864db20UL, 0xa527fdf9UL, 0xa1e6e04eUL,
-   0xbfa1b04bUL, 0xbb60adfcUL, 0xb6238b25UL, 0xb2e29692UL,
-   0x8aad2b2fUL, 0x8e6c3698UL, 0x832f1041UL, 0x87ee0df6UL,
-   0x99a95df3UL, 0x9d684044UL, 0x902b669dUL, 0x94ea7b2aUL,
-   0xe0b41de7UL, 0xe4750050UL, 0xe9362689UL, 0xedf73b3eUL,
-   0xf3b06b3bUL, 0xf771768cUL, 0xfa325055UL, 0xfef34de2UL,
-   0xc6bcf05fUL, 0xc27dede8UL, 0xcf3ecb31UL, 0xcbffd686UL,
-   0xd5b88683UL, 0xd1799b34UL, 0xdc3abdedUL, 0xd8fba05aUL,
-   0x690ce0eeUL, 0x6dcdfd59UL, 0x608edb80UL, 0x644fc637UL,
-   0x7a089632UL, 0x7ec98b85UL, 0x738aad5cUL, 0x774bb0ebUL,
-   0x4f040d56UL, 0x4bc510e1UL, 0x46863638UL, 0x42472b8fUL,
-   0x5c007b8aUL, 0x58c1663dUL, 0x558240e4UL, 0x51435d53UL,
-   0x251d3b9eUL, 0x21dc2629UL, 0x2c9f00f0UL, 0x285e1d47UL,
-   0x36194d42UL, 0x32d850f5UL, 0x3f9b762cUL, 0x3b5a6b9bUL,
-   0x0315d626UL, 0x07d4cb91UL, 0x0a97ed48UL, 0x0e56f0ffUL,
-   0x1011a0faUL, 0x14d0bd4dUL, 0x19939b94UL, 0x1d528623UL,
-   0xf12f560eUL, 0xf5ee4bb9UL, 0xf8ad6d60UL, 0xfc6c70d7UL,
-   0xe22b20d2UL, 0xe6ea3d65UL, 0xeba91bbcUL, 0xef68060bUL,
-   0xd727bbb6UL, 0xd3e6a601UL, 0xdea580d8UL, 0xda649d6fUL,
-   0xc423cd6aUL, 0xc0e2d0ddUL, 0xcda1f604UL, 0xc960ebb3UL,
-   0xbd3e8d7eUL, 0xb9ff90c9UL, 0xb4bcb610UL, 0xb07daba7UL,
-   0xae3afba2UL, 0xaafbe615UL, 0xa7b8c0ccUL, 0xa379dd7bUL,
-   0x9b3660c6UL, 0x9ff77d71UL, 0x92b45ba8UL, 0x9675461fUL,
-   0x8832161aUL, 0x8cf30badUL, 0x81b02d74UL, 0x857130c3UL,
-   0x5d8a9099UL, 0x594b8d2eUL, 0x5408abf7UL, 0x50c9b640UL,
-   0x4e8ee645UL, 0x4a4ffbf2UL, 0x470cdd2bUL, 0x43cdc09cUL,
-   0x7b827d21UL, 0x7f436096UL, 0x7200464fUL, 0x76c15bf8UL,
-   0x68860bfdUL, 0x6c47164aUL, 0x61043093UL, 0x65c52d24UL,
-   0x119b4be9UL, 0x155a565eUL, 0x18197087UL, 0x1cd86d30UL,
-   0x029f3d35UL, 0x065e2082UL, 0x0b1d065bUL, 0x0fdc1becUL,
-   0x3793a651UL, 0x3352bbe6UL, 0x3e119d3fUL, 0x3ad08088UL,
-   0x2497d08dUL, 0x2056cd3aUL, 0x2d15ebe3UL, 0x29d4f654UL,
-   0xc5a92679UL, 0xc1683bceUL, 0xcc2b1d17UL, 0xc8ea00a0UL,
-   0xd6ad50a5UL, 0xd26c4d12UL, 0xdf2f6bcbUL, 0xdbee767cUL,
-   0xe3a1cbc1UL, 0xe760d676UL, 0xea23f0afUL, 0xeee2ed18UL,
-   0xf0a5bd1dUL, 0xf464a0aaUL, 0xf9278673UL, 0xfde69bc4UL,
-   0x89b8fd09UL, 0x8d79e0beUL, 0x803ac667UL, 0x84fbdbd0UL,
-   0x9abc8bd5UL, 0x9e7d9662UL, 0x933eb0bbUL, 0x97ffad0cUL,
-   0xafb010b1UL, 0xab710d06UL, 0xa6322bdfUL, 0xa2f33668UL,
-   0xbcb4666dUL, 0xb8757bdaUL, 0xb5365d03UL, 0xb1f740b4UL
-};
-
-
-/*---------------------------------------------*/
-void initialiseCRC ( void )
-{
-   globalCrc = 0xffffffffUL;
-}
-
-
-/*---------------------------------------------*/
-UInt32 getFinalCRC ( void )
-{
-   return ~globalCrc;
-}
-
-
-/*---------------------------------------------*/
-UInt32 getGlobalCRC ( void )
-{
-   return globalCrc;
-}
-
-
-/*---------------------------------------------*/
-void setGlobalCRC ( UInt32 newCrc )
-{
-   globalCrc = newCrc;
-}
-
-
-/*---------------------------------------------*/
-#define UPDATE_CRC(crcVar,cha)              \
-{                                           \
-   crcVar = (crcVar << 8) ^                 \
-            crc32Table[(crcVar >> 24) ^     \
-                       ((UChar)cha)];       \
-}
-
-
-/*---------------------------------------------------*/
-/*--- Bit stream I/O                              ---*/
+/*--- Processing of complete files and streams    ---*/
 /*---------------------------------------------------*/
 
-
-UInt32 bsBuff;
-Int32  bsLive;
-FILE*  bsStream;
-Bool   bsWriting;
-
-
-/*---------------------------------------------*/
-void bsSetStream ( FILE* f, Bool wr )
-{
-   if (bsStream != NULL) panic ( "bsSetStream" );
-   bsStream = f;
-   bsLive = 0;
-   bsBuff = 0;
-   bytesOut = 0;
-   bytesIn = 0;
-   bsWriting = wr;
-}
-
-
-/*---------------------------------------------*/
-void bsFinishedWithStream ( void )
-{
-   if (bsWriting)
-      while (bsLive > 0) {
-         fputc ( (UChar)(bsBuff >> 24), bsStream );
-         bsBuff <<= 8;
-         bsLive -= 8;
-         bytesOut++;
-      }
-   bsStream = NULL;
-}
-
-
-/*---------------------------------------------*/
-#define bsNEEDR(nz)                           \
-{                                             \
-   while (bsLive < nz) {                      \
-      Int32 zzi = fgetc ( bsStream );         \
-      if (zzi == EOF) compressedStreamEOF();  \
-      bsBuff = (bsBuff << 8) | (zzi & 0xffL); \
-      bsLive += 8;                            \
-   }                                          \
-}
-
-
-/*---------------------------------------------*/
-#define bsNEEDW(nz)                           \
-{                                             \
-   while (bsLive >= 8) {                      \
-      fputc ( (UChar)(bsBuff >> 24),          \
-               bsStream );                    \
-      bsBuff <<= 8;                           \
-      bsLive -= 8;                            \
-      bytesOut++;                             \
-   }                                          \
-}
-
-
-/*---------------------------------------------*/
-#define bsR1(vz)                              \
-{                                             \
-   bsNEEDR(1);                                \
-   vz = (bsBuff >> (bsLive-1)) & 1;           \
-   bsLive--;                                  \
-}
-
-
-/*---------------------------------------------*/
-INLINE UInt32 bsR ( Int32 n )
-{
-   UInt32 v;
-   bsNEEDR ( n );
-   v = (bsBuff >> (bsLive-n)) & ((1 << n)-1);
-   bsLive -= n;
-   return v;
-}
-
-
-/*---------------------------------------------*/
-INLINE void bsW ( Int32 n, UInt32 v )
-{
-   bsNEEDW ( n );
-   bsBuff |= (v << (32 - bsLive - n));
-   bsLive += n;
-}
-
-
-/*---------------------------------------------*/
-UChar bsGetUChar ( void )
-{
-   return (UChar)bsR(8);
-}
-
-
-/*---------------------------------------------*/
-void bsPutUChar ( UChar c )
-{
-   bsW(8, (UInt32)c );
-}
-
-
 /*---------------------------------------------*/
-Int32 bsGetUInt32 ( void )
+Bool myfeof ( FILE* f )
 {
-   UInt32 u;
-   u = 0;
-   u = (u << 8) | bsR(8);
-   u = (u << 8) | bsR(8);
-   u = (u << 8) | bsR(8);
-   u = (u << 8) | bsR(8);
-   return u;
-}
-
-
-/*---------------------------------------------*/
-UInt32 bsGetIntVS ( UInt32 numBits )
-{
-   return (UInt32)bsR(numBits);
-}
-
-
-/*---------------------------------------------*/
-UInt32 bsGetInt32 ( void )
-{
-   return (Int32)bsGetUInt32();
-}
-
-
-/*---------------------------------------------*/
-void bsPutUInt32 ( UInt32 u )
-{
-   bsW ( 8, (u >> 24) & 0xffL );
-   bsW ( 8, (u >> 16) & 0xffL );
-   bsW ( 8, (u >>  8) & 0xffL );
-   bsW ( 8,  u        & 0xffL );
-}
-
-
-/*---------------------------------------------*/
-void bsPutInt32 ( Int32 c )
-{
-   bsPutUInt32 ( (UInt32)c );
+   Int32 c = fgetc ( f );
+   if (c == EOF) return True;
+   ungetc ( c, f );
+   return False;
 }
 
 
 /*---------------------------------------------*/
-void bsPutIntVS ( Int32 numBits, UInt32 c )
+void compressStream ( FILE *stream, FILE *zStream )
 {
-   bsW ( numBits, c );
-}
-
-
-/*---------------------------------------------------*/
-/*--- Huffman coding low-level stuff              ---*/
-/*---------------------------------------------------*/
-
-#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;                                    \
-}
+   BZFILE* bzf = NULL;
+   UChar   ibuf[5000];
+   Int32   nIbuf;
+   UInt32  nbytes_in, nbytes_out;
+   Int32   bzerr, bzerr_dummy, ret;
 
+   SET_BINARY_MODE(stream);
+   SET_BINARY_MODE(zStream);
 
-/*---------------------------------------------*/
-void 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;
+   if (ferror(stream)) goto errhandler_io;
+   if (ferror(zStream)) goto errhandler_io;
 
-   Int32 heap   [ MAX_ALPHA_SIZE + 2 ];
-   Int32 weight [ MAX_ALPHA_SIZE * 2 ];
-   Int32 parent [ MAX_ALPHA_SIZE * 2 ]; 
+   bzf = bzWriteOpen ( &bzerr, zStream, 
+                       blockSize100k, verbosity, workFactor );   
+   if (bzerr != BZ_OK) goto errhandler;
 
-   for (i = 0; i < alphaSize; i++)
-      weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
+   if (verbosity >= 2) fprintf ( stderr, "\n" );
 
    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);
-      }
-      if (!(nHeap < (MAX_ALPHA_SIZE+2))) 
-         panic ( "hbMakeCodeLengths(1)" );
-   
-      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);
-      }
-      if (!(nNodes < (MAX_ALPHA_SIZE * 2)))
-         panic ( "hbMakeCodeLengths(2)" );
-
-      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;
+      if (myfeof(stream)) break;
+      nIbuf = fread ( ibuf, sizeof(UChar), 5000, stream );
+      if (ferror(stream)) goto errhandler_io;
+      if (nIbuf > 0) bzWrite ( &bzerr, bzf, (void*)ibuf, nIbuf );
+      if (bzerr != BZ_OK) goto errhandler;
 
-      for (i = 1; i < alphaSize; i++) {
-         j = weight[i] >> 8;
-         j = 1 + (j / 2);
-         weight[i] = j << 8;
-      }
    }
-}
-
 
-/*---------------------------------------------*/
-void hbAssignCodes ( Int32 *code,
-                     UChar *length,
-                     Int32 minLen,
-                     Int32 maxLen,
-                     Int32 alphaSize )
-{
-   Int32 n, vec, i;
+   bzWriteClose ( &bzerr, bzf, 0, &nbytes_in, &nbytes_out );
+   if (bzerr != BZ_OK) goto errhandler;
 
-   vec = 0;
-   for (n = minLen; n <= maxLen; n++) {
-      for (i = 0; i < alphaSize; i++)
-         if (length[i] == n) { code[i] = vec; vec++; };
-      vec <<= 1;
+   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;
    }
-}
-
-
-/*---------------------------------------------*/
-void 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 < MAX_CODE_LEN; i++) base[i] = 0;
-   for (i = 0; i < alphaSize; i++) base[length[i]+1]++;
+   if (ferror(stream)) goto errhandler_io;
+   ret = fclose ( stream );
+   if (ret == EOF) goto errhandler_io;
 
-   for (i = 1; i < MAX_CODE_LEN; i++) base[i] += base[i-1];
+   if (nbytes_in == 0) nbytes_in = 1;
 
-   for (i = 0; i < 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];
-}
-
-
-
-/*---------------------------------------------------*/
-/*--- Undoing the reversible transformation       ---*/
-/*---------------------------------------------------*/
-
-/*---------------------------------------------*/
-#define SET_LL4(i,n)                                          \
-   { if (((i) & 0x1) == 0)                                    \
-        ll4[(i) >> 1] = (ll4[(i) >> 1] & 0xf0) | (n); else    \
-        ll4[(i) >> 1] = (ll4[(i) >> 1] & 0x0f) | ((n) << 4);  \
-   }
-
-#define GET_LL4(i)                             \
-    (((UInt32)(ll4[(i) >> 1])) >> (((i) << 2) & 0x4) & 0xF)
-
-#define SET_LL(i,n)                       \
-   { ll16[i] = (UInt16)(n & 0x0000ffff);  \
-     SET_LL4(i, n >> 16);                 \
-   }
-
-#define GET_LL(i) \
-   (((UInt32)ll16[i]) | (GET_LL4(i) << 16))
-
-
-/*---------------------------------------------*/
-/*--
-  Manage memory for compression/decompression.
-  When compressing, a single block size applies to
-  all files processed, and that's set when the
-  program starts.  But when decompressing, each file
-  processed could have been compressed with a
-  different block size, so we may have to free
-  and reallocate on a per-file basis.
-
-  A call with argument of zero means
-  `free up everything.'  And a value of zero for
-  blockSize100k means no memory is currently allocated.
---*/
+   if (verbosity >= 1)
+      fprintf ( stderr, "%6.3f:1, %6.3f bits/byte, "
+                        "%5.2f%% saved, %d in, %d out.\n",
+                (float)nbytes_in / (float)nbytes_out,
+                (8.0 * (float)nbytes_out) / (float)nbytes_in,
+                100.0 * (1.0 - (float)nbytes_out / (float)nbytes_in),
+                nbytes_in,
+                nbytes_out
+              );
 
+   return;
 
-/*---------------------------------------------*/
-void allocateCompressStructures ( void )
-{
-   Int32 n  = 100000 * blockSize100k;
-   block    = malloc ( (n + 1 + NUM_OVERSHOOT_BYTES) * sizeof(UChar) );
-   quadrant = malloc ( (n     + NUM_OVERSHOOT_BYTES) * sizeof(Int16) );
-   zptr     = malloc ( n                             * sizeof(Int32) );
-   ftab     = malloc ( 65537                         * sizeof(Int32) );
-
-   if (block == NULL || quadrant == NULL ||
-       zptr == NULL  || ftab == NULL) {
-      Int32 totalDraw
-         = (n + 1 + NUM_OVERSHOOT_BYTES) * sizeof(UChar) +
-           (n     + NUM_OVERSHOOT_BYTES) * sizeof(Int16) +
-           n                             * sizeof(Int32) +
-           65537                         * sizeof(Int32);
-
-      compressOutOfMemory ( totalDraw, n );
+   errhandler:
+   bzWriteClose ( &bzerr_dummy, bzf, 1, &nbytes_in, &nbytes_out );
+   switch (bzerr) {
+      case BZ_MEM_ERROR:
+         outOfMemory ();
+      case BZ_IO_ERROR:
+         errhandler_io:
+         ioError(); break;
+      default:
+         panic ( "compress:unexpected error" );
    }
 
-   /*--
-      Since we want valid indexes for block of
-      -1 to n + NUM_OVERSHOOT_BYTES - 1
-      inclusive.
-   --*/
-   block++;
-
-   /*--
-      The back end needs a place to store the MTF values
-      whilst it calculates the coding tables.  We could
-      put them in the zptr array.  However, these values
-      will fit in a short, so we overlay szptr at the 
-      start of zptr, in the hope of reducing the number
-      of cache misses induced by the multiple traversals
-      of the MTF values when calculating coding tables.
-      Seems to improve compression speed by about 1%.
-   --*/
-   szptr = (UInt16*)zptr;
-}
-
-
-/*---------------------------------------------*/
-void setDecompressStructureSizes ( Int32 newSize100k )
-{
-   if (! (0 <= newSize100k   && newSize100k   <= 9 &&
-          0 <= blockSize100k && blockSize100k <= 9))
-      panic ( "setDecompressStructureSizes" );
-
-   if (newSize100k == blockSize100k) return;
-
-   blockSize100k = newSize100k;
-
-   if (ll16  != NULL) free ( ll16  );
-   if (ll4   != NULL) free ( ll4   );
-   if (ll8   != NULL) free ( ll8   );
-   if (tt    != NULL) free ( tt    );
-
-   if (newSize100k == 0) return;
-
-   if (smallMode) {
-
-      Int32 n = 100000 * newSize100k;
-      ll16    = malloc ( n * sizeof(UInt16) );
-      ll4     = malloc ( ((n+1) >> 1) * sizeof(UChar) );
-
-      if (ll4 == NULL || ll16 == NULL) {
-         Int32 totalDraw
-            = n * sizeof(Int16) + ((n+1) >> 1) * sizeof(UChar);
-         uncompressOutOfMemory ( totalDraw, n );
-      }
-
-   } else {
-
-      Int32 n = 100000 * newSize100k;
-      ll8     = malloc ( n * sizeof(UChar) );
-      tt      = malloc ( n * sizeof(Int32) );
-
-      if (ll8 == NULL || tt == NULL) {
-         Int32 totalDraw
-            = n * sizeof(UChar) + n * sizeof(UInt32);
-         uncompressOutOfMemory ( totalDraw, n );
-      }
-
-   }
+   panic ( "compress:end" );
+   /*notreached*/
 }
 
 
 
-/*---------------------------------------------------*/
-/*--- The new back end                            ---*/
-/*---------------------------------------------------*/
-
-/*---------------------------------------------*/
-void makeMaps ( void )
-{
-   Int32 i;
-   nInUse = 0;
-   for (i = 0; i < 256; i++)
-      if (inUse[i]) {
-         seqToUnseq[nInUse] = i;
-         unseqToSeq[i] = nInUse;
-         nInUse++;
-      }
-}
-
-
 /*---------------------------------------------*/
-void generateMTFValues ( void )
-{
-   UChar  yy[256];
-   Int32  i, j;
-   UChar  tmp;
-   UChar  tmp2;
-   Int32  zPend;
-   Int32  wr;
-   Int32  EOB;
-
-   makeMaps();
-   EOB = nInUse+1;
-
-   for (i = 0; i <= EOB; i++) mtfFreq[i] = 0;
-
-   wr = 0;
-   zPend = 0;
-   for (i = 0; i < nInUse; i++) yy[i] = (UChar) i;
-   
-
-   for (i = 0; i <= last; i++) {
-      UChar ll_i;
-
-      #if DEBUG
-         assert (wr <= i);
-      #endif
-
-      ll_i = unseqToSeq[block[zptr[i] - 1]];
-      #if DEBUG
-         assert (ll_i < nInUse);
-      #endif
-
-      j = 0;
-      tmp = yy[j];
-      while ( ll_i != tmp ) {
-         j++;
-         tmp2 = tmp;
-         tmp = yy[j];
-         yy[j] = tmp2;
-      };
-      yy[0] = tmp;
-
-      if (j == 0) {
-         zPend++;
-      } else {
-         if (zPend > 0) {
-            zPend--;
-            while (True) {
-               switch (zPend % 2) {
-                  case 0: szptr[wr] = RUNA; wr++; mtfFreq[RUNA]++; break;
-                  case 1: szptr[wr] = RUNB; wr++; mtfFreq[RUNB]++; break;
-               };
-               if (zPend < 2) break;
-               zPend = (zPend - 2) / 2;
-            };
-            zPend = 0;
-         }
-         szptr[wr] = j+1; wr++; mtfFreq[j+1]++;
-      }
-   }
-
-   if (zPend > 0) {
-      zPend--;
-      while (True) {
-         switch (zPend % 2) {
-            case 0:  szptr[wr] = RUNA; wr++; mtfFreq[RUNA]++; break;
-            case 1:  szptr[wr] = RUNB; wr++; mtfFreq[RUNB]++; break;
-         };
-         if (zPend < 2) break;
-         zPend = (zPend - 2) / 2;
-      };
-   }
-
-   szptr[wr] = EOB; wr++; mtfFreq[EOB]++;
-
-   nMTF = wr;
-}
-
-
-/*---------------------------------------------*/
-#define LESSER_ICOST  0
-#define GREATER_ICOST 15
-
-void sendMTFValues ( void )
+Bool uncompressStream ( FILE *zStream, FILE *stream )
 {
-   Int32 v, t, i, j, gs, ge, totc, bt, bc, iter;
-   Int32 nSelectors, alphaSize, minLen, maxLen, selCtr;
-   Int32 nGroups, nBytes;
-
-   /*--
-   UChar  len [N_GROUPS][MAX_ALPHA_SIZE];
-   is a global since the decoder also needs it.
-
-   Int32  code[N_GROUPS][MAX_ALPHA_SIZE];
-   Int32  rfreq[N_GROUPS][MAX_ALPHA_SIZE];
-   are also globals only used in this proc.
-   Made global to keep stack frame size small.
-   --*/
-
-
-   UInt16 cost[N_GROUPS];
-   Int32  fave[N_GROUPS];
-
-   if (verbosity >= 3)
-      fprintf ( stderr, 
-                "      %d in block, %d after MTF & 1-2 coding, %d+2 syms in use\n", 
-                last+1, nMTF, nInUse );
-
-   alphaSize = nInUse+2;
-   for (t = 0; t < N_GROUPS; t++)
-      for (v = 0; v < alphaSize; v++)
-         len[t][v] = GREATER_ICOST;
-
-   /*--- Decide how many coding tables to use ---*/
-   if (nMTF <= 0) panic ( "sendMTFValues(0)" );
-   if (nMTF < 200) nGroups = 2; else
-   if (nMTF < 800) nGroups = 4; else
-                   nGroups = 6;
-
-   /*--- Generate an initial set of coding tables ---*/
-   { 
-      Int32 nPart, remF, tFreq, aFreq;
-
-      nPart = nGroups;
-      remF  = nMTF;
-      gs = 0;
-      while (nPart > 0) {
-         tFreq = remF / nPart;
-         ge = gs-1;
-         aFreq = 0;
-         while (aFreq < tFreq && ge < alphaSize-1) {
-            ge++;
-            aFreq += mtfFreq[ge];
-         }
-
-         if (ge > gs 
-             && nPart != nGroups && nPart != 1 
-             && ((nGroups-nPart) % 2 == 1)) {
-            aFreq -= mtfFreq[ge];
-            ge--;
-         }
+   BZFILE* bzf = NULL;
+   Int32   bzerr, bzerr_dummy, ret, nread, streamNo, i;
+   UChar   obuf[5000];
+   UChar   unused[BZ_MAX_UNUSED];
+   Int32   nUnused;
+   UChar*  unusedTmp;
 
-         if (verbosity >= 3)
-            fprintf ( stderr, 
-                      "      initial group %d, [%d .. %d], has %d syms (%4.1f%%)\n",
-                              nPart, gs, ge, aFreq, 
-                              (100.0 * (float)aFreq) / (float)nMTF );
- 
-         for (v = 0; v < alphaSize; v++)
-            if (v >= gs && v <= ge) 
-               len[nPart-1][v] = LESSER_ICOST; else
-               len[nPart-1][v] = GREATER_ICOST;
- 
-         nPart--;
-         gs = ge+1;
-         remF -= aFreq;
-      }
-   }
-
-   /*--- 
-      Iterate up to N_ITERS times to improve the tables.
-   ---*/
-   for (iter = 0; iter < N_ITERS; iter++) {
-
-      for (t = 0; t < nGroups; t++) fave[t] = 0;
-
-      for (t = 0; t < nGroups; t++)
-         for (v = 0; v < alphaSize; v++)
-            rfreq[t][v] = 0;
-
-      nSelectors = 0;
-      totc = 0;
-      gs = 0;
-      while (True) {
-
-         /*--- Set group start & end marks. --*/
-         if (gs >= nMTF) break;
-         ge = gs + G_SIZE - 1; 
-         if (ge >= nMTF) ge = 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) {
-            register UInt16 cost0, cost1, cost2, cost3, cost4, cost5;
-            cost0 = cost1 = cost2 = cost3 = cost4 = cost5 = 0;
-            for (i = gs; i <= ge; i++) { 
-               UInt16 icv = szptr[i];
-               cost0 += len[0][icv];
-               cost1 += len[1][icv];
-               cost2 += len[2][icv];
-               cost3 += len[3][icv];
-               cost4 += len[4][icv];
-               cost5 += len[5][icv];
-            }
-            cost[0] = cost0; cost[1] = cost1; cost[2] = cost2;
-            cost[3] = cost3; cost[4] = cost4; cost[5] = cost5;
-         } else {
-            for (i = gs; i <= ge; i++) { 
-               UInt16 icv = szptr[i];
-               for (t = 0; t < nGroups; t++) cost[t] += 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]++;
-         selector[nSelectors] = bt;
-         nSelectors++;
-
-         /*-- 
-            Increment the symbol frequencies for the selected table.
-          --*/
-         for (i = gs; i <= ge; i++)
-            rfreq[bt][ szptr[i] ]++;
-
-         gs = ge+1;
-      }
-      if (verbosity >= 3) {
-         fprintf ( stderr, 
-                   "      pass %d: size is %d, grp uses are ", 
-                   iter+1, totc/8 );
-         for (t = 0; t < nGroups; t++)
-            fprintf ( stderr, "%d ", fave[t] );
-         fprintf ( stderr, "\n" );
-      }
-
-      /*--
-        Recompute the tables based on the accumulated frequencies.
-      --*/
-      for (t = 0; t < nGroups; t++)
-         hbMakeCodeLengths ( &len[t][0], &rfreq[t][0], alphaSize, 20 );
-   }
+   nUnused = 0;
+   streamNo = 0;
 
+   SET_BINARY_MODE(stream);
+   SET_BINARY_MODE(zStream);
 
-   if (!(nGroups < 8)) panic ( "sendMTFValues(1)" );
-   if (!(nSelectors < 32768 &&
-         nSelectors <= (2 + (900000 / G_SIZE))))
-                       panic ( "sendMTFValues(2)" );
-
-
-   /*--- Compute MTF values for the selectors. ---*/
-   {
-      UChar pos[N_GROUPS], ll_i, tmp2, tmp;
-      for (i = 0; i < nGroups; i++) pos[i] = i;
-      for (i = 0; i < nSelectors; i++) {
-         ll_i = selector[i];
-         j = 0;
-         tmp = pos[j];
-         while ( ll_i != tmp ) {
-            j++;
-            tmp2 = tmp;
-            tmp = pos[j];
-            pos[j] = tmp2;
-         };
-         pos[0] = tmp;
-         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 (len[t][i] > maxLen) maxLen = len[t][i];
-         if (len[t][i] < minLen) minLen = len[t][i];
-      }
-      if (maxLen > 20) panic ( "sendMTFValues(3)" );
-      if (minLen < 1)  panic ( "sendMTFValues(4)" );
-      hbAssignCodes ( &code[t][0], &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 (inUse[i * 16 + j]) inUse16[i] = True;
-      }
-     
-      nBytes = bytesOut;
-      for (i = 0; i < 16; i++)
-         if (inUse16[i]) bsW(1,1); else bsW(1,0);
-
-      for (i = 0; i < 16; i++)
-         if (inUse16[i])
-            for (j = 0; j < 16; j++)
-               if (inUse[i * 16 + j]) bsW(1,1); else bsW(1,0);
-
-      if (verbosity >= 3) 
-         fprintf ( stderr, "      bytes: mapping %d, ", bytesOut-nBytes );
-   }
-
-   /*--- Now the selectors. ---*/
-   nBytes = bytesOut;
-   bsW ( 3, nGroups );
-   bsW ( 15, nSelectors );
-   for (i = 0; i < nSelectors; i++) { 
-      for (j = 0; j < selectorMtf[i]; j++) bsW(1,1);
-      bsW(1,0);
-   }
-   if (verbosity >= 3)
-      fprintf ( stderr, "selectors %d, ", bytesOut-nBytes );
-
-   /*--- Now the coding tables. ---*/
-   nBytes = bytesOut;
-
-   for (t = 0; t < nGroups; t++) {
-      Int32 curr = len[t][0];
-      bsW ( 5, curr );
-      for (i = 0; i < alphaSize; i++) {
-         while (curr < len[t][i]) { bsW(2,2); curr++; /* 10 */ };
-         while (curr > len[t][i]) { bsW(2,3); curr--; /* 11 */ };
-         bsW ( 1, 0 );
-      }
-   }
-
-   if (verbosity >= 3)
-      fprintf ( stderr, "code lengths %d, ", bytesOut-nBytes );
+   if (ferror(stream)) goto errhandler_io;
+   if (ferror(zStream)) goto errhandler_io;
 
-   /*--- And finally, the block data proper ---*/
-   nBytes = bytesOut;
-   selCtr = 0;
-   gs = 0;
    while (True) {
-      if (gs >= nMTF) break;
-      ge = gs + G_SIZE - 1; 
-      if (ge >= nMTF) ge = nMTF-1;
-      for (i = gs; i <= ge; i++) { 
-         #if DEBUG
-            assert (selector[selCtr] < nGroups);
-         #endif
-         bsW ( len  [selector[selCtr]] [szptr[i]],
-               code [selector[selCtr]] [szptr[i]] );
-      }
 
-      gs = ge+1;
-      selCtr++;
-   }
-   if (!(selCtr == nSelectors)) panic ( "sendMTFValues(5)" );
-
-   if (verbosity >= 3)
-      fprintf ( stderr, "codes %d\n", bytesOut-nBytes );
-}
-
-
-/*---------------------------------------------*/
-void moveToFrontCodeAndSend ( void )
-{
-   bsPutIntVS ( 24, origPtr );
-   generateMTFValues();
-   sendMTFValues();
-}
-
-
-/*---------------------------------------------*/
-void recvDecodingTables ( void )
-{
-   Int32 i, j, t, nGroups, nSelectors, alphaSize;
-   Int32 minLen, maxLen;
-   Bool inUse16[16];
-
-   /*--- Receive the mapping table ---*/
-   for (i = 0; i < 16; i++)
-      if (bsR(1) == 1) 
-         inUse16[i] = True; else 
-         inUse16[i] = False;
-
-   for (i = 0; i < 256; i++) inUse[i] = False;
-
-   for (i = 0; i < 16; i++)
-      if (inUse16[i])
-         for (j = 0; j < 16; j++)
-            if (bsR(1) == 1) inUse[i * 16 + j] = True;
-
-   makeMaps();
-   alphaSize = nInUse+2;
-
-   /*--- Now the selectors ---*/
-   nGroups = bsR ( 3 );
-   nSelectors = bsR ( 15 );
-   for (i = 0; i < nSelectors; i++) {
-      j = 0;
-      while (bsR(1) == 1) j++;
-      selectorMtf[i] = j;
-   }
-
-   /*--- Undo the MTF values for the selectors. ---*/
-   {
-      UChar pos[N_GROUPS], tmp, v;
-      for (v = 0; v < nGroups; v++) pos[v] = v;
-   
-      for (i = 0; i < nSelectors; i++) {
-         v = selectorMtf[i];
-         tmp = pos[v];
-         while (v > 0) { pos[v] = pos[v-1]; v--; }
-         pos[0] = tmp;
-         selector[i] = tmp;
+      bzf = bzReadOpen ( 
+               &bzerr, zStream, verbosity, 
+               (int)smallMode, unused, nUnused
+            );
+      if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
+      streamNo++;
+
+      while (bzerr == BZ_OK) {
+         nread = 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;
       }
-   }
-
-   /*--- Now the coding tables ---*/
-   for (t = 0; t < nGroups; t++) {
-      Int32 curr = bsR ( 5 );
-      for (i = 0; i < alphaSize; i++) {
-         while (bsR(1) == 1) {
-            if (bsR(1) == 0) curr++; else curr--;
-         }
-         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 (len[t][i] > maxLen) maxLen = len[t][i];
-         if (len[t][i] < minLen) minLen = len[t][i];
-      }
-      hbCreateDecodeTables ( 
-         &limit[t][0], &base[t][0], &perm[t][0], &len[t][0],
-         minLen, maxLen, alphaSize
-      );
-      minLens[t] = minLen;
-   }
-}
-
-
-/*---------------------------------------------*/
-#define GET_MTF_VAL(lval)                 \
-{                                         \
-   Int32 zt, zn, zvec, zj;                \
-   if (groupPos == 0) {                   \
-      groupNo++;                          \
-      groupPos = G_SIZE;                  \
-   }                                      \
-   groupPos--;                            \
-   zt = selector[groupNo];                \
-   zn = minLens[zt];                      \
-   zvec = bsR ( zn );                     \
-   while (zvec > limit[zt][zn]) {         \
-      zn++; bsR1(zj);                     \
-      zvec = (zvec << 1) | zj;            \
-   };                                     \
-   lval = perm[zt][zvec - base[zt][zn]];  \
-}
-
-
-/*---------------------------------------------*/
-void getAndMoveToFrontDecode ( void )
-{
-   UChar  yy[256];
-   Int32  i, j, nextSym, limitLast;
-   Int32  EOB, groupNo, groupPos;
-
-   limitLast = 100000 * blockSize100k;
-   origPtr   = bsGetIntVS ( 24 );
-
-   recvDecodingTables();
-   EOB      = nInUse+1;
-   groupNo  = -1;
-   groupPos = 0;
-
-   /*--
-      Setting up the unzftab entries here is not strictly
-      necessary, but it does save having to do it later
-      in a separate pass, and so saves a block's worth of
-      cache misses.
-   --*/
-   for (i = 0; i <= 255; i++) unzftab[i] = 0;
-
-   for (i = 0; i <= 255; i++) yy[i] = (UChar) i;
-
-   last = -1;
+      if (bzerr != BZ_STREAM_END) goto errhandler;
 
-   GET_MTF_VAL(nextSym);
+      bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused );
+      if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
 
-   while (True) {
-
-      if (nextSym == EOB) break;
-
-      if (nextSym == RUNA || nextSym == RUNB) {
-         UChar ch;
-         Int32 s = -1;
-         Int32 N = 1;
-         do {
-            if (nextSym == RUNA) s = s + (0+1) * N; else
-            if (nextSym == RUNB) s = s + (1+1) * N;
-            N = N * 2;
-            GET_MTF_VAL(nextSym);
-         }
-            while (nextSym == RUNA || nextSym == RUNB);
+      for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
 
-         s++;
-         ch = seqToUnseq[yy[0]];
-         unzftab[ch] += s;
+      bzReadClose ( &bzerr, bzf );
+      if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
 
-         if (smallMode)
-            while (s > 0) {
-               last++; 
-               ll16[last] = ch;
-               s--;
-            }
-         else
-            while (s > 0) {
-               last++;
-               ll8[last] = ch;
-               s--;
-            };
-
-         if (last >= limitLast) blockOverrun();
-         continue;
-
-      } else {
-
-         UChar tmp;
-         last++; if (last >= limitLast) blockOverrun();
-
-         tmp = yy[nextSym-1];
-         unzftab[seqToUnseq[tmp]]++;
-         if (smallMode)
-            ll16[last] = seqToUnseq[tmp]; else
-            ll8[last]  = seqToUnseq[tmp];
-
-         /*--
-            This loop is hammered during decompression,
-            hence the unrolling.
-
-            for (j = nextSym-1; j > 0; j--) yy[j] = yy[j-1];
-         --*/
-
-         j = nextSym-1;
-         for (; j > 3; j -= 4) {
-            yy[j]   = yy[j-1];
-            yy[j-1] = yy[j-2];
-            yy[j-2] = yy[j-3];
-            yy[j-3] = yy[j-4];
-         }
-         for (; j > 0; j--) yy[j] = yy[j-1];
+      if (nUnused == 0 && myfeof(zStream)) break;
 
-         yy[0] = tmp;
-         GET_MTF_VAL(nextSym);
-         continue;
-      }
    }
-}
-
-
-/*---------------------------------------------------*/
-/*--- Block-sorting machinery                     ---*/
-/*---------------------------------------------------*/
 
-/*---------------------------------------------*/
-/*--
-  Compare two strings in block.  We assume (see
-  discussion above) that i1 and i2 have a max
-  offset of 10 on entry, and that the first
-  bytes of both block and quadrant have been
-  copied into the "overshoot area", ie
-  into the subscript range
-  [last+1 .. last+NUM_OVERSHOOT_BYTES].
---*/
-INLINE Bool fullGtU ( Int32 i1, Int32 i2 )
-{
-   Int32 k;
-   UChar c1, c2;
-   UInt16 s1, s2;
-
-   #if DEBUG
-      /*--
-        shellsort shouldn't ask to compare
-        something with itself.
-      --*/
-      assert (i1 != i2);
-   #endif
-
-   c1 = block[i1];
-   c2 = block[i2];
-   if (c1 != c2) return (c1 > c2);
-   i1++; i2++;
-
-   c1 = block[i1];
-   c2 = block[i2];
-   if (c1 != c2) return (c1 > c2);
-   i1++; i2++;
-
-   c1 = block[i1];
-   c2 = block[i2];
-   if (c1 != c2) return (c1 > c2);
-   i1++; i2++;
-
-   c1 = block[i1];
-   c2 = block[i2];
-   if (c1 != c2) return (c1 > c2);
-   i1++; i2++;
-
-   c1 = block[i1];
-   c2 = block[i2];
-   if (c1 != c2) return (c1 > c2);
-   i1++; i2++;
-
-   c1 = block[i1];
-   c2 = block[i2];
-   if (c1 != c2) return (c1 > c2);
-   i1++; i2++;
-
-   k = last + 1;
-
-   do {
-
-      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++;
-
-      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++;
-
-      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++;
-
-      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 > last) { i1 -= last; i1--; };
-      if (i2 > last) { i2 -= last; i2--; };
-
-      k -= 4;
-      workDone++;
-   }
-      while (k >= 0);
+   if (ferror(zStream)) goto errhandler_io;
+   ret = fclose ( zStream );
+   if (ret == EOF) goto errhandler_io;
 
-   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.
---*/
-Int32 incs[14] = { 1, 4, 13, 40, 121, 364, 1093, 3280,
-                   9841, 29524, 88573, 265720,
-                   797161, 2391484 };
-
-void simpleSort ( Int32 lo, Int32 hi, Int32 d )
-{
-   Int32 i, j, h, bigN, hp;
-   Int32 v;
-
-   bigN = hi - lo + 1;
-   if (bigN < 2) return;
-
-   hp = 0;
-   while (incs[hp] < bigN) hp++;
-   hp--;
-
-   for (; hp >= 0; hp--) {
-      h = incs[hp];
-      if (verbosity >= 5) 
-         fprintf ( stderr, "          shell increment %d\n", h );
-
-      i = lo + h;
-      while (True) {
-
-         /*-- copy 1 --*/
-         if (i > hi) break;
-         v = zptr[i];
-         j = i;
-         while ( fullGtU ( zptr[j-h]+d, v+d ) ) {
-            zptr[j] = zptr[j-h];
-            j = j - h;
-            if (j <= (lo + h - 1)) break;
-         }
-         zptr[j] = v;
-         i++;
-
-         /*-- copy 2 --*/
-         if (i > hi) break;
-         v = zptr[i];
-         j = i;
-         while ( fullGtU ( zptr[j-h]+d, v+d ) ) {
-            zptr[j] = zptr[j-h];
-            j = j - h;
-            if (j <= (lo + h - 1)) break;
-         }
-         zptr[j] = v;
-         i++;
-
-         /*-- copy 3 --*/
-         if (i > hi) break;
-         v = zptr[i];
-         j = i;
-         while ( fullGtU ( zptr[j-h]+d, v+d ) ) {
-            zptr[j] = zptr[j-h];
-            j = j - h;
-            if (j <= (lo + h - 1)) break;
-         }
-         zptr[j] = v;
-         i++;
-
-         if (workDone > workLimit && firstAttempt) 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 swap(lv1, lv2) \
-   { Int32 tmp = lv1; lv1 = lv2; lv2 = tmp; }
-
-INLINE void vswap ( Int32 p1, Int32 p2, Int32 n )
-{
-   while (n > 0) {
-      swap(zptr[p1], zptr[p2]);
-      p1++; p2++; n--;
-   }
-}
-
-INLINE UChar med3 ( UChar a, UChar b, UChar c )
-{
-   UChar t;
-   if (a > b) { t = a; a = b; b = t; };
-   if (b > c) { t = b; b = c; c = t; };
-   if (a > b)          b = a;
-   return b;
-}
-
-
-#define min(a,b) ((a) < (b)) ? (a) : (b)
-
-typedef
-   struct { Int32 ll; Int32 hh; Int32 dd; }
-   StackElem;
-
-#define push(lz,hz,dz) { stack[sp].ll = lz; \
-                         stack[sp].hh = hz; \
-                         stack[sp].dd = dz; \
-                         sp++; }
-
-#define pop(lz,hz,dz) { sp--;               \
-                        lz = stack[sp].ll;  \
-                        hz = stack[sp].hh;  \
-                        dz = stack[sp].dd; }
-
-#define SMALL_THRESH 20
-#define DEPTH_THRESH 10
-
-/*--
-   If you are ever unlucky/improbable enough
-   to get a stack overflow whilst sorting,
-   increase the following constant and try
-   again.  In practice I have never seen the
-   stack go above 27 elems, so the following
-   limit seems very generous.
---*/
-#define QSORT_STACK_SIZE 1000
-
-
-void qSort3 ( Int32 loSt, Int32 hiSt, Int32 dSt )
-{
-   Int32 unLo, unHi, ltLo, gtHi, med, n, m;
-   Int32 sp, lo, hi, d;
-   StackElem stack[QSORT_STACK_SIZE];
-
-   sp = 0;
-   push ( loSt, hiSt, dSt );
-
-   while (sp > 0) {
-
-      if (sp >= QSORT_STACK_SIZE) panic ( "stack overflow in qSort3" );
-
-      pop ( lo, hi, d );
-
-      if (hi - lo < SMALL_THRESH || d > DEPTH_THRESH) {
-         simpleSort ( lo, hi, d );
-         if (workDone > workLimit && firstAttempt) return;
-         continue;
-      }
-
-      med = med3 ( block[zptr[ lo         ]+d],
-                   block[zptr[ hi         ]+d],
-                   block[zptr[ (lo+hi)>>1 ]+d] );
-
-      unLo = ltLo = lo;
-      unHi = gtHi = hi;
-
-      while (True) {
-         while (True) {
-            if (unLo > unHi) break;
-            n = ((Int32)block[zptr[unLo]+d]) - med;
-            if (n == 0) { swap(zptr[unLo], zptr[ltLo]); ltLo++; unLo++; continue; };
-            if (n >  0) break;
-            unLo++;
-         }
-         while (True) {
-            if (unLo > unHi) break;
-            n = ((Int32)block[zptr[unHi]+d]) - med;
-            if (n == 0) { swap(zptr[unHi], zptr[gtHi]); gtHi--; unHi--; continue; };
-            if (n <  0) break;
-            unHi--;
-         }
-         if (unLo > unHi) break;
-         swap(zptr[unLo], zptr[unHi]); unLo++; unHi--;
-      }
-      #if DEBUG
-         assert (unHi == unLo-1);
-      #endif
-
-      if (gtHi < ltLo) {
-         push(lo, hi, d+1 );
-         continue;
-      }
-
-      n = min(ltLo-lo, unLo-ltLo); vswap(lo, unLo-n, n);
-      m = min(hi-gtHi, gtHi-unHi); vswap(unLo, hi-m+1, m);
-
-      n = lo + unLo - ltLo - 1;
-      m = hi - (gtHi - unHi) + 1;
-
-      push ( lo, n, d );
-      push ( n+1, m-1, d+1 );
-      push ( m, hi, d );
-   }
-}
-
-
-/*---------------------------------------------*/
-
-#define BIGFREQ(b) (ftab[((b)+1) << 8] - ftab[(b) << 8])
-
-#define SETMASK (1 << 21)
-#define CLEARMASK (~(SETMASK))
-
-void sortIt ( void )
-{
-   Int32 i, j, ss, sb;
-   Int32 runningOrder[256];
-   Int32 copy[256];
-   Bool bigDone[256];
-   UChar c1, c2;
-   Int32 numQSorted;
-
-   /*--
-      In the various block-sized structures, live data runs
-      from 0 to last+NUM_OVERSHOOT_BYTES inclusive.  First,
-      set up the overshoot area for block.
-   --*/
-
-   if (verbosity >= 4) fprintf ( stderr, "        sort initialise ...\n" );
-   for (i = 0; i < NUM_OVERSHOOT_BYTES; i++)
-       block[last+i+1] = block[i % (last+1)];
-   for (i = 0; i <= last+NUM_OVERSHOOT_BYTES; i++)
-       quadrant[i] = 0;
-
-   block[-1] = block[last];
-
-   if (last < 4000) {
-
-      /*--
-         Use simpleSort(), since the full sorting mechanism
-         has quite a large constant overhead.
-      --*/
-      if (verbosity >= 4) fprintf ( stderr, "        simpleSort ...\n" );
-      for (i = 0; i <= last; i++) zptr[i] = i;
-      firstAttempt = False;
-      workDone = workLimit = 0;
-      simpleSort ( 0, last, 0 );
-      if (verbosity >= 4) fprintf ( stderr, "        simpleSort done.\n" );
-
-   } else {
-
-      numQSorted = 0;
-      for (i = 0; i <= 255; i++) bigDone[i] = False;
-
-      if (verbosity >= 4) fprintf ( stderr, "        bucket sorting ...\n" );
-
-      for (i = 0; i <= 65536; i++) ftab[i] = 0;
-
-      c1 = block[-1];
-      for (i = 0; i <= last; i++) {
-         c2 = block[i];
-         ftab[(c1 << 8) + c2]++;
-         c1 = c2;
-      }
-
-      for (i = 1; i <= 65536; i++) ftab[i] += ftab[i-1];
-
-      c1 = block[0];
-      for (i = 0; i < last; i++) {
-         c2 = block[i+1];
-         j = (c1 << 8) + c2;
-         c1 = c2;
-         ftab[j]--;
-         zptr[ftab[j]] = i;
-      }
-      j = (block[last] << 8) + block[0];
-      ftab[j]--;
-      zptr[ftab[j]] = last;
-
-      /*--
-         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++) 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.
-      --*/
-
-      for (i = 0; i <= 255; i++) {
-
-         /*--
-            Process big buckets, starting with the least full.
-         --*/
-         ss = runningOrder[i];
-
-         /*--
-            Complete the big bucket [ss] by quicksorting
-            any unsorted small buckets [ss, j].  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++) {
-            sb = (ss << 8) + j;
-            if ( ! (ftab[sb] & SETMASK) ) {
-               Int32 lo = ftab[sb]   & CLEARMASK;
-               Int32 hi = (ftab[sb+1] & CLEARMASK) - 1;
-               if (hi > lo) {
-                  if (verbosity >= 4)
-                     fprintf ( stderr,
-                               "        qsort [0x%x, 0x%x]   done %d   this %d\n",
-                               ss, j, numQSorted, hi - lo + 1 );
-                  qSort3 ( lo, hi, 2 );
-                  numQSorted += ( hi - lo + 1 );
-                  if (workDone > workLimit && firstAttempt) return;
-               }
-               ftab[sb] |= SETMASK;
-            }
-         }
-
-         /*--
-            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.
-         --*/
-         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 = 0; j < bbSize; j++) {
-               Int32 a2update     = zptr[bbStart + j];
-               UInt16 qVal        = (UInt16)(j >> shifts);
-               quadrant[a2update] = qVal;
-               if (a2update < NUM_OVERSHOOT_BYTES)
-                  quadrant[a2update + last + 1] = qVal;
-            }
-
-            if (! ( ((bbSize-1) >> shifts) <= 65535 )) panic ( "sortIt" );
-         }
-
-         /*--
-            Now scan this big bucket so as to synthesise the
-            sorted order for small buckets [t, ss] for all t != ss.
-         --*/
-         for (j = 0; j <= 255; j++)
-            copy[j] = ftab[(j << 8) + ss] & CLEARMASK;
-
-         for (j = ftab[ss << 8] & CLEARMASK;
-              j < (ftab[(ss+1) << 8] & CLEARMASK);
-              j++) {
-            c1 = block[zptr[j]-1];
-            if ( ! bigDone[c1] ) {
-               zptr[copy[c1]] = zptr[j] == 0 ? last : zptr[j] - 1;
-               copy[c1] ++;
-            }
-         }
-
-         for (j = 0; j <= 255; j++) ftab[(j << 8) + ss] |= SETMASK;
-      }
-      if (verbosity >= 4)
-         fprintf ( stderr, "        %d pointers, %d sorted, %d scanned\n",
-                           last+1, numQSorted, (last+1) - numQSorted );
-   }
-}
-
-
-/*---------------------------------------------------*/
-/*--- Stuff for randomising repetitive blocks     ---*/
-/*---------------------------------------------------*/
-
-/*---------------------------------------------*/
-Int32 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
-};
-
-
-#define RAND_DECLS                                \
-   Int32 rNToGo = 0;                              \
-   Int32 rTPos  = 0;                              \
-
-#define RAND_MASK ((rNToGo == 1) ? 1 : 0)
-
-#define RAND_UPD_MASK                             \
-   if (rNToGo == 0) {                             \
-      rNToGo = rNums[rTPos];                      \
-      rTPos++; if (rTPos == 512) rTPos = 0;       \
-   }                                              \
-   rNToGo--;
-
-
-
-/*---------------------------------------------------*/
-/*--- The Reversible Transformation (tm)          ---*/
-/*---------------------------------------------------*/
-
-/*---------------------------------------------*/
-void randomiseBlock ( void )
-{
-   Int32 i;
-   RAND_DECLS;
-   for (i = 0; i < 256; i++) inUse[i] = False;
-
-   for (i = 0; i <= last; i++) {
-      RAND_UPD_MASK;
-      block[i] ^= RAND_MASK;
-      inUse[block[i]] = True;
-   }
-}
-
-
-/*---------------------------------------------*/
-void doReversibleTransformation ( void )
-{
-   Int32 i;
-
-   if (verbosity >= 2) fprintf ( stderr, "\n" );
-
-   workLimit       = workFactor * last;
-   workDone        = 0;
-   blockRandomised = False;
-   firstAttempt    = True;
-
-   sortIt ();
-
-   if (verbosity >= 3)
-      fprintf ( stderr, "      %d work, %d block, ratio %5.2f\n",
-                        workDone, last, (float)workDone / (float)(last) );
-
-   if (workDone > workLimit && firstAttempt) {
-      if (verbosity >= 2)
-         fprintf ( stderr, "    sorting aborted; randomising block\n" );
-      randomiseBlock ();
-      workLimit = workDone = 0;
-      blockRandomised = True;
-      firstAttempt = False;
-      sortIt();
-      if (verbosity >= 3)
-         fprintf ( stderr, "      %d work, %d block, ratio %f\n",
-                           workDone, last, (float)workDone / (float)(last) );
-   }
-
-   origPtr = -1;
-   for (i = 0; i <= last; i++)
-       if (zptr[i] == 0)
-          { origPtr = i; break; };
-
-   if (origPtr == -1) panic ( "doReversibleTransformation" );
-}
-
-
-/*---------------------------------------------*/
-
-INLINE Int32 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;
-}
-
-
-#define GET_SMALL(cccc)                     \
-                                            \
-      cccc = indexIntoF ( tPos, cftab );    \
-      tPos = GET_LL(tPos);
-
-
-void undoReversibleTransformation_small ( FILE* dst )
-{
-   Int32  cftab[257], cftabAlso[257];
-   Int32  i, j, tmp, tPos;
-   UChar  ch;
-
-   /*--
-      We assume here that the global array unzftab will
-      already be holding the frequency counts for
-      ll8[0 .. last].
-   --*/
-
-   /*-- Set up cftab to facilitate generation of indexIntoF --*/
-   cftab[0] = 0;
-   for (i = 1; i <= 256; i++) cftab[i] = unzftab[i-1];
-   for (i = 1; i <= 256; i++) cftab[i] += cftab[i-1];
-
-   /*-- Make a copy of it, used in generation of T --*/
-   for (i = 0; i <= 256; i++) cftabAlso[i] = cftab[i];
-
-   /*-- compute the T vector --*/
-   for (i = 0; i <= last; i++) {
-      ch = (UChar)ll16[i];
-      SET_LL(i, cftabAlso[ch]);
-      cftabAlso[ch]++;
-   }
-
-   /*--
-      Compute T^(-1) by pointer reversal on T.  This is rather
-      subtle, in that, if the original block was two or more
-      (in general, N) concatenated copies of the same thing,
-      the T vector will consist of N cycles, each of length
-      blocksize / N, and decoding will involve traversing one
-      of these cycles N times.  Which particular cycle doesn't
-      matter -- they are all equivalent.  The tricky part is to
-      make sure that the pointer reversal creates a correct
-      reversed cycle for us to traverse.  So, the code below
-      simply reverses whatever cycle origPtr happens to fall into,
-      without regard to the cycle length.  That gives one reversed
-      cycle, which for normal blocks, is the entire block-size long.
-      For repeated blocks, it will be interspersed with the other
-      N-1 non-reversed cycles.  Providing that the F-subscripting
-      phase which follows starts at origPtr, all then works ok.
-   --*/
-   i = origPtr;
-   j = GET_LL(i);
-   do {
-      tmp = GET_LL(j);
-      SET_LL(j, i);
-      i = j;
-      j = tmp;
-   }
-      while (i != origPtr);
-
-   /*--
-      We recreate the original by subscripting F through T^(-1).
-      The run-length-decoder below requires characters incrementally,
-      so tPos is set to a starting value, and is updated by
-      the GET_SMALL macro.
-   --*/
-   tPos   = origPtr;
-
-   /*-------------------------------------------------*/
-   /*--
-      This is pretty much a verbatim copy of the
-      run-length decoder present in the distribution
-      bzip-0.21; it has to be here to avoid creating
-      block[] as an intermediary structure.  As in 0.21,
-      this code derives from some sent to me by
-      Christian von Roques.
-
-      It allows dst==NULL, so as to support the test (-t)
-      option without slowing down the fast decompression
-      code.
-   --*/
-   {
-      IntNative retVal;
-      Int32     i2, count, chPrev, ch2;
-      UInt32    localCrc;
-
-      count    = 0;
-      i2       = 0;
-      ch2      = 256;   /*-- not a char and not EOF --*/
-      localCrc = getGlobalCRC();
-
-      {
-         RAND_DECLS;
-         while ( i2 <= last ) {
-            chPrev = ch2;
-            GET_SMALL(ch2);
-            if (blockRandomised) {
-               RAND_UPD_MASK;
-               ch2 ^= (UInt32)RAND_MASK;
-            }
-            i2++;
-   
-            if (dst)
-               retVal = putc ( ch2, dst );
-   
-            UPDATE_CRC ( localCrc, (UChar)ch2 );
-   
-            if (ch2 != chPrev) {
-               count = 1;
-            } else {
-               count++;
-               if (count >= 4) {
-                  Int32 j2;
-                  UChar z;
-                  GET_SMALL(z);
-                  if (blockRandomised) {
-                     RAND_UPD_MASK;
-                     z ^= RAND_MASK;
-                  }
-                  for (j2 = 0;  j2 < (Int32)z;  j2++) {
-                     if (dst) retVal = putc (ch2, dst);
-                     UPDATE_CRC ( localCrc, (UChar)ch2 );
-                  }
-                  i2++;
-                  count = 0;
-               }
-            }
-         }
-      }
-
-      setGlobalCRC ( localCrc );
-   }
-   /*-- end of the in-line run-length-decoder. --*/
-}
-#undef GET_SMALL
-
-
-/*---------------------------------------------*/
-
-#define GET_FAST(cccc)                       \
-                                             \
-      cccc = ll8[tPos];                      \
-      tPos = tt[tPos];
-
-
-void undoReversibleTransformation_fast ( FILE* dst )
-{
-   Int32  cftab[257];
-   Int32  i, tPos;
-   UChar  ch;
-
-   /*--
-      We assume here that the global array unzftab will
-      already be holding the frequency counts for
-      ll8[0 .. last].
-   --*/
-
-   /*-- Set up cftab to facilitate generation of T^(-1) --*/
-   cftab[0] = 0;
-   for (i = 1; i <= 256; i++) cftab[i] = unzftab[i-1];
-   for (i = 1; i <= 256; i++) cftab[i] += cftab[i-1];
-
-   /*-- compute the T^(-1) vector --*/
-   for (i = 0; i <= last; i++) {
-      ch = (UChar)ll8[i];
-      tt[cftab[ch]] = i;
-      cftab[ch]++;
+   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;
 
-   /*--
-      We recreate the original by subscripting L through T^(-1).
-      The run-length-decoder below requires characters incrementally,
-      so tPos is set to a starting value, and is updated by
-      the GET_FAST macro.
-   --*/
-   tPos   = tt[origPtr];
-
-   /*-------------------------------------------------*/
-   /*--
-      This is pretty much a verbatim copy of the
-      run-length decoder present in the distribution
-      bzip-0.21; it has to be here to avoid creating
-      block[] as an intermediary structure.  As in 0.21,
-      this code derives from some sent to me by
-      Christian von Roques.
-   --*/
-   {
-      IntNative retVal;
-      Int32     i2, count, chPrev, ch2;
-      UInt32    localCrc;
-
-      count    = 0;
-      i2       = 0;
-      ch2      = 256;   /*-- not a char and not EOF --*/
-      localCrc = getGlobalCRC();
-
-      if (blockRandomised) {
-         RAND_DECLS;
-         while ( i2 <= last ) {
-            chPrev = ch2;
-            GET_FAST(ch2);
-            RAND_UPD_MASK;
-            ch2 ^= (UInt32)RAND_MASK;
-            i2++;
-   
-            retVal = putc ( ch2, dst );
-            UPDATE_CRC ( localCrc, (UChar)ch2 );
-   
-            if (ch2 != chPrev) {
-               count = 1;
-            } else {
-               count++;
-               if (count >= 4) {
-                  Int32 j2;
-                  UChar z;
-                  GET_FAST(z);
-                  RAND_UPD_MASK;
-                  z ^= RAND_MASK;
-                  for (j2 = 0;  j2 < (Int32)z;  j2++) {
-                     retVal = putc (ch2, dst);
-                     UPDATE_CRC ( localCrc, (UChar)ch2 );
-                  }
-                  i2++;
-                  count = 0;
-               }
-            }
-         }
-
-      } else {
-
-         while ( i2 <= last ) {
-            chPrev = ch2;
-            GET_FAST(ch2);
-            i2++;
-   
-            retVal = putc ( ch2, dst );
-            UPDATE_CRC ( localCrc, (UChar)ch2 );
-   
-            if (ch2 != chPrev) {
-               count = 1;
-            } else {
-               count++;
-               if (count >= 4) {
-                  Int32 j2;
-                  UChar z;
-                  GET_FAST(z);
-                  for (j2 = 0;  j2 < (Int32)z;  j2++) {
-                     retVal = putc (ch2, dst);
-                     UPDATE_CRC ( localCrc, (UChar)ch2 );
-                  }
-                  i2++;
-                  count = 0;
-               }
-            }
+   errhandler:
+   bzReadClose ( &bzerr_dummy, bzf );
+   switch (bzerr) {
+      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 (streamNo == 1) {
+            return False;
+         } else {
+            fprintf ( stderr, 
+                      "\n%s: %s: trailing garbage after EOF ignored\n",
+                      progName, inName );
+            return True;       
          }
-
-      }   /*-- if (blockRandomised) --*/
-
-      setGlobalCRC ( localCrc );
-   }
-   /*-- end of the in-line run-length-decoder. --*/
-}
-#undef GET_FAST
-
-
-/*---------------------------------------------------*/
-/*--- The block loader and RLEr                   ---*/
-/*---------------------------------------------------*/
-
-/*---------------------------------------------*/
-/*  Top 16:   run length, 1 to 255.
-*   Lower 16: the char, or MY_EOF for EOF.
-*/
-
-#define MY_EOF 257
-
-INLINE Int32 getRLEpair ( FILE* src )
-{
-   Int32     runLength;
-   IntNative ch, chLatest;
-
-   ch = getc ( src );
-
-   /*--- Because I have no idea what kind of a value EOF is. ---*/
-   if (ch == EOF) {
-      ERROR_IF_NOT_ZERO ( ferror(src));
-      return (1 << 16) | MY_EOF;
-   }
-
-   runLength = 0;
-   do {
-      chLatest = getc ( src );
-      runLength++;
-      bytesIn++;
-   }
-      while (ch == chLatest && runLength < 255);
-
-   if ( chLatest != EOF ) {
-      if ( ungetc ( chLatest, src ) == EOF )
-         panic ( "getRLEpair: ungetc failed" );
-   } else {
-      ERROR_IF_NOT_ZERO ( ferror(src) );
-   }
-
-   /*--- Conditional is just a speedup hack. ---*/
-   if (runLength == 1) {
-      UPDATE_CRC ( globalCrc, (UChar)ch );
-      return (1 << 16) | ch;
-   } else {
-      Int32 i;
-      for (i = 1; i <= runLength; i++)
-         UPDATE_CRC ( globalCrc, (UChar)ch );
-      return (runLength << 16) | ch;
+      default:
+         panic ( "decompress:unexpected error" );
    }
-}
 
-
-/*---------------------------------------------*/
-void loadAndRLEsource ( FILE* src )
-{
-   Int32 ch, allowableBlockSize, i;
-
-   last = -1;
-   ch   = 0;
-
-   for (i = 0; i < 256; i++) inUse[i] = False;
-
-   /*--- 20 is just a paranoia constant ---*/
-   allowableBlockSize = 100000 * blockSize100k - 20;
-
-   while (last < allowableBlockSize && ch != MY_EOF) {
-      Int32 rlePair, runLen;
-      rlePair = getRLEpair ( src );
-      ch      = rlePair & 0xFFFF;
-      runLen  = (UInt32)rlePair >> 16;
-
-      #if DEBUG
-         assert (runLen >= 1 && runLen <= 255);
-      #endif
-
-      if (ch != MY_EOF) {
-         inUse[ch] = True;
-         switch (runLen) {
-            case 1:
-               last++; block[last] = (UChar)ch; break;
-            case 2:
-               last++; block[last] = (UChar)ch;
-               last++; block[last] = (UChar)ch; break;
-            case 3:
-               last++; block[last] = (UChar)ch;
-               last++; block[last] = (UChar)ch;
-               last++; block[last] = (UChar)ch; break;
-            default:
-               inUse[runLen-4] = True;
-               last++; block[last] = (UChar)ch;
-               last++; block[last] = (UChar)ch;
-               last++; block[last] = (UChar)ch;
-               last++; block[last] = (UChar)ch;
-               last++; block[last] = (UChar)(runLen-4); break;
-         }
-      }
-   }
+   panic ( "decompress:end" );
+   return True; /*notreached*/
 }
 
 
-/*---------------------------------------------------*/
-/*--- Processing of complete files and streams    ---*/
-/*---------------------------------------------------*/
-
 /*---------------------------------------------*/
-void compressStream ( FILE *stream, FILE *zStream )
+Bool testStream ( FILE *zStream )
 {
-   IntNative  retVal;
-   UInt32     blockCRC, combinedCRC;
-   Int32      blockNo;
+   BZFILE* bzf = NULL;
+   Int32   bzerr, bzerr_dummy, ret, nread, streamNo, i;
+   UChar   obuf[5000];
+   UChar   unused[BZ_MAX_UNUSED];
+   Int32   nUnused;
+   UChar*  unusedTmp;
 
-   blockNo  = 0;
-   bytesIn  = 0;
-   bytesOut = 0;
-   nBlocksRandomised = 0;
+   nUnused = 0;
+   streamNo = 0;
 
-   SET_BINARY_MODE(stream);
    SET_BINARY_MODE(zStream);
-
-   ERROR_IF_NOT_ZERO ( ferror(stream) );
-   ERROR_IF_NOT_ZERO ( ferror(zStream) );
-
-   bsSetStream ( zStream, True );
-
-   /*--- Write `magic' bytes B and Z,
-         then h indicating file-format == huffmanised,
-         followed by a digit indicating blockSize100k.
-   ---*/
-   bsPutUChar ( 'B' );
-   bsPutUChar ( 'Z' );
-   bsPutUChar ( 'h' );
-   bsPutUChar ( '0' + blockSize100k );
-
-   combinedCRC = 0;
-
-   if (verbosity >= 2) fprintf ( stderr, "\n" );
+   if (ferror(zStream)) goto errhandler_io;
 
    while (True) {
 
-      blockNo++;
-      initialiseCRC ();
-      loadAndRLEsource ( stream );
-      ERROR_IF_NOT_ZERO ( ferror(stream) );
-      if (last == -1) break;
-
-      blockCRC = getFinalCRC ();
-      combinedCRC = (combinedCRC << 1) | (combinedCRC >> 31);
-      combinedCRC ^= blockCRC;
-
-      if (verbosity >= 2)
-         fprintf ( stderr, "    block %d: crc = 0x%8x, combined CRC = 0x%8x, size = %d",
-                           blockNo, blockCRC, combinedCRC, last+1 );
-
-      /*-- sort the block and establish posn of original string --*/
-      doReversibleTransformation ();
-
-      /*--
-        A 6-byte block header, the value chosen arbitrarily
-        as 0x314159265359 :-).  A 32 bit value does not really
-        give a strong enough guarantee that the value will not
-        appear by chance in the compressed datastream.  Worst-case
-        probability of this event, for a 900k block, is about
-        2.0e-3 for 32 bits, 1.0e-5 for 40 bits and 4.0e-8 for 48 bits.
-        For a compressed file of size 100Gb -- about 100000 blocks --
-        only a 48-bit marker will do.  NB: normal compression/
-        decompression do *not* rely on these statistical properties.
-        They are only important when trying to recover blocks from
-        damaged files.
-      --*/
-      bsPutUChar ( 0x31 ); bsPutUChar ( 0x41 );
-      bsPutUChar ( 0x59 ); bsPutUChar ( 0x26 );
-      bsPutUChar ( 0x53 ); bsPutUChar ( 0x59 );
-
-      /*-- Now the block's CRC, so it is in a known place. --*/
-      bsPutUInt32 ( blockCRC );
-
-      /*-- Now a single bit indicating randomisation. --*/
-      if (blockRandomised) {
-         bsW(1,1); nBlocksRandomised++;
-      } else
-         bsW(1,0);
-
-      /*-- Finally, block's contents proper. --*/
-      moveToFrontCodeAndSend ();
-
-      ERROR_IF_NOT_ZERO ( ferror(zStream) );
-   }
-
-   if (verbosity >= 2 && nBlocksRandomised > 0)
-      fprintf ( stderr, "    %d block%s needed randomisation\n", 
-                        nBlocksRandomised,
-                        nBlocksRandomised == 1 ? "" : "s" );
-
-   /*--
-      Now another magic 48-bit number, 0x177245385090, to
-      indicate the end of the last block.  (sqrt(pi), if
-      you want to know.  I did want to use e, but it contains
-      too much repetition -- 27 18 28 18 28 46 -- for me
-      to feel statistically comfortable.  Call me paranoid.)
-   --*/
-
-   bsPutUChar ( 0x17 ); bsPutUChar ( 0x72 );
-   bsPutUChar ( 0x45 ); bsPutUChar ( 0x38 );
-   bsPutUChar ( 0x50 ); bsPutUChar ( 0x90 );
-
-   bsPutUInt32 ( combinedCRC );
-   if (verbosity >= 2)
-      fprintf ( stderr, "    final combined CRC = 0x%x\n   ", combinedCRC );
+      bzf = bzReadOpen ( 
+               &bzerr, zStream, verbosity, 
+               (int)smallMode, unused, nUnused
+            );
+      if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
+      streamNo++;
 
-   /*-- Close the files in an utterly paranoid way. --*/
-   bsFinishedWithStream ();
-
-   ERROR_IF_NOT_ZERO ( ferror(zStream) );
-   retVal = fflush ( zStream );
-   ERROR_IF_EOF ( retVal );
-   retVal = fclose ( zStream );
-   ERROR_IF_EOF ( retVal );
-
-   ERROR_IF_NOT_ZERO ( ferror(stream) );
-   retVal = fclose ( stream );
-   ERROR_IF_EOF ( retVal );
-
-   if (bytesIn == 0) bytesIn = 1;
-   if (bytesOut == 0) bytesOut = 1;
+      while (bzerr == BZ_OK) {
+         nread = bzRead ( &bzerr, bzf, obuf, 5000 );
+         if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler;
+      }
+      if (bzerr != BZ_STREAM_END) goto errhandler;
 
-   if (verbosity >= 1)
-      fprintf ( stderr, "%6.3f:1, %6.3f bits/byte, "
-                        "%5.2f%% saved, %d in, %d out.\n",
-                (float)bytesIn / (float)bytesOut,
-                (8.0 * (float)bytesOut) / (float)bytesIn,
-                100.0 * (1.0 - (float)bytesOut / (float)bytesIn),
-                bytesIn,
-                bytesOut
-              );
-}
+      bzReadGetUnused ( &bzerr, bzf, (void**)(&unusedTmp), &nUnused );
+      if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
 
+      for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
 
-/*---------------------------------------------*/
-Bool uncompressStream ( FILE *zStream, FILE *stream )
-{
-   UChar      magic1, magic2, magic3, magic4;
-   UChar      magic5, magic6;
-   UInt32     storedBlockCRC, storedCombinedCRC;
-   UInt32     computedBlockCRC, computedCombinedCRC;
-   Int32      currBlockNo;
-   IntNative  retVal;
+      bzReadClose ( &bzerr, bzf );
+      if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
+      if (nUnused == 0 && myfeof(zStream)) break;
 
-   SET_BINARY_MODE(stream);
-   SET_BINARY_MODE(zStream);
-
-   ERROR_IF_NOT_ZERO ( ferror(stream) );
-   ERROR_IF_NOT_ZERO ( ferror(zStream) );
-
-   bsSetStream ( zStream, False );
-
-   /*--
-      A bad magic number is `recoverable from';
-      return with False so the caller skips the file.
-   --*/
-   magic1 = bsGetUChar ();
-   magic2 = bsGetUChar ();
-   magic3 = bsGetUChar ();
-   magic4 = bsGetUChar ();
-   if (magic1 != 'B' ||
-       magic2 != 'Z' ||
-       magic3 != 'h' ||
-       magic4 < '1'  ||
-       magic4 > '9') {
-     bsFinishedWithStream();
-     retVal = fclose ( stream );
-     ERROR_IF_EOF ( retVal );
-     return False;
    }
 
-   setDecompressStructureSizes ( magic4 - '0' );
-   computedCombinedCRC = 0;
-
-   if (verbosity >= 2) fprintf ( stderr, "\n    " );
-   currBlockNo = 0;
-
-   while (True) {
-      magic1 = bsGetUChar ();
-      magic2 = bsGetUChar ();
-      magic3 = bsGetUChar ();
-      magic4 = bsGetUChar ();
-      magic5 = bsGetUChar ();
-      magic6 = bsGetUChar ();
-      if (magic1 == 0x17 && magic2 == 0x72 &&
-          magic3 == 0x45 && magic4 == 0x38 &&
-          magic5 == 0x50 && magic6 == 0x90) break;
-
-      if (magic1 != 0x31 || magic2 != 0x41 ||
-          magic3 != 0x59 || magic4 != 0x26 ||
-          magic5 != 0x53 || magic6 != 0x59) badBlockHeader();
-
-      storedBlockCRC = bsGetUInt32 ();
-
-      if (bsR(1) == 1)
-         blockRandomised = True; else
-         blockRandomised = False;
-
-      currBlockNo++;
-      if (verbosity >= 2)
-         fprintf ( stderr, "[%d: huff+mtf ", currBlockNo );
-      getAndMoveToFrontDecode ();
-      ERROR_IF_NOT_ZERO ( ferror(zStream) );
-
-      initialiseCRC();
-      if (verbosity >= 2) fprintf ( stderr, "rt+rld" );
-      if (smallMode)
-         undoReversibleTransformation_small ( stream );
-         else
-         undoReversibleTransformation_fast  ( stream );
-
-      ERROR_IF_NOT_ZERO ( ferror(stream) );
-
-      computedBlockCRC = getFinalCRC();
-      if (verbosity >= 3)
-         fprintf ( stderr, " {0x%x, 0x%x}", storedBlockCRC, computedBlockCRC );
-      if (verbosity >= 2) fprintf ( stderr, "] " );
-
-      /*-- A bad CRC is considered a fatal error. --*/
-      if (storedBlockCRC != computedBlockCRC)
-         crcError ( storedBlockCRC, computedBlockCRC );
-
-      computedCombinedCRC = (computedCombinedCRC << 1) | (computedCombinedCRC >> 31);
-      computedCombinedCRC ^= computedBlockCRC;
-   };
+   if (ferror(zStream)) goto errhandler_io;
+   ret = fclose ( zStream );
+   if (ret == EOF) goto errhandler_io;
 
    if (verbosity >= 2) fprintf ( stderr, "\n    " );
-
-   storedCombinedCRC  = bsGetUInt32 ();
-   if (verbosity >= 2)
-      fprintf ( stderr,
-                "combined CRCs: stored = 0x%x, computed = 0x%x\n    ",
-                storedCombinedCRC, computedCombinedCRC );
-   if (storedCombinedCRC != computedCombinedCRC)
-      crcError ( storedCombinedCRC, computedCombinedCRC );
-
-
-   bsFinishedWithStream ();
-   ERROR_IF_NOT_ZERO ( ferror(zStream) );
-   retVal = fclose ( zStream );
-   ERROR_IF_EOF ( retVal );
-
-   ERROR_IF_NOT_ZERO ( ferror(stream) );
-   retVal = fflush ( stream );
-   ERROR_IF_NOT_ZERO ( retVal );
-   if (stream != stdout) {
-      retVal = fclose ( stream );
-      ERROR_IF_EOF ( retVal );
-   }
    return True;
-}
-
-
-/*---------------------------------------------*/
-Bool testStream ( FILE *zStream )
-{
-   UChar      magic1, magic2, magic3, magic4;
-   UChar      magic5, magic6;
-   UInt32     storedBlockCRC, storedCombinedCRC;
-   UInt32     computedBlockCRC, computedCombinedCRC;
-   Int32      currBlockNo;
-   IntNative  retVal;
-
-   SET_BINARY_MODE(zStream);
-   ERROR_IF_NOT_ZERO ( ferror(zStream) );
-
-   bsSetStream ( zStream, False );
-
-   magic1 = bsGetUChar ();
-   magic2 = bsGetUChar ();
-   magic3 = bsGetUChar ();
-   magic4 = bsGetUChar ();
-   if (magic1 != 'B' ||
-       magic2 != 'Z' ||
-       magic3 != 'h' ||
-       magic4 < '1'  ||
-       magic4 > '9') {
-     bsFinishedWithStream();
-     fclose ( zStream );
-     fprintf ( stderr, "\n%s: bad magic number (ie, not created by bzip2)\n",
-                       inName );
-     return False;
-   }
 
-   smallMode = True;
-   setDecompressStructureSizes ( magic4 - '0' );
-   computedCombinedCRC = 0;
-
-   if (verbosity >= 2) fprintf ( stderr, "\n" );
-   currBlockNo = 0;
-
-   while (True) {
-      magic1 = bsGetUChar ();
-      magic2 = bsGetUChar ();
-      magic3 = bsGetUChar ();
-      magic4 = bsGetUChar ();
-      magic5 = bsGetUChar ();
-      magic6 = bsGetUChar ();
-      if (magic1 == 0x17 && magic2 == 0x72 &&
-          magic3 == 0x45 && magic4 == 0x38 &&
-          magic5 == 0x50 && magic6 == 0x90) break;
-
-      currBlockNo++;
-      if (magic1 != 0x31 || magic2 != 0x41 ||
-          magic3 != 0x59 || magic4 != 0x26 ||
-          magic5 != 0x53 || magic6 != 0x59) {
-         bsFinishedWithStream();
-         fclose ( zStream );
+   errhandler:
+   bzReadClose ( &bzerr_dummy, bzf );
+   switch (bzerr) {
+      case BZ_IO_ERROR:
+         errhandler_io:
+         ioError(); break;
+      case BZ_DATA_ERROR:
          fprintf ( stderr,
-                   "\n%s, block %d: bad header (not == 0x314159265359)\n",
-                   inName, currBlockNo );
+                   "\n%s: data integrity (CRC) error in data\n",
+                   inName );
          return False;
-      }
-      storedBlockCRC = bsGetUInt32 ();
-
-      if (bsR(1) == 1)
-         blockRandomised = True; else
-         blockRandomised = False;
-
-      if (verbosity >= 2)
-         fprintf ( stderr, "    block [%d: huff+mtf ", currBlockNo );
-      getAndMoveToFrontDecode ();
-      ERROR_IF_NOT_ZERO ( ferror(zStream) );
-
-      initialiseCRC();
-      if (verbosity >= 2) fprintf ( stderr, "rt+rld" );
-      undoReversibleTransformation_small ( NULL );
-
-      computedBlockCRC = getFinalCRC();
-      if (verbosity >= 3)
-         fprintf ( stderr, " {0x%x, 0x%x}", storedBlockCRC, computedBlockCRC );
-      if (verbosity >= 2) fprintf ( stderr, "] " );
-
-      if (storedBlockCRC != computedBlockCRC) {
-         bsFinishedWithStream();
-         fclose ( zStream );
-         fprintf ( stderr, "\n%s, block %d: computed CRC does not match stored one\n",
-                           inName, currBlockNo );
+      case BZ_MEM_ERROR:
+         outOfMemory();
+      case BZ_UNEXPECTED_EOF:
+         fprintf ( stderr,
+                   "\n%s: file ends unexpectedly\n",
+                   inName );
          return False;
-      }
-
-      if (verbosity >= 2) fprintf ( stderr, "ok\n" );
-      computedCombinedCRC = (computedCombinedCRC << 1) | (computedCombinedCRC >> 31);
-      computedCombinedCRC ^= computedBlockCRC;
-   };
-
-   storedCombinedCRC  = bsGetUInt32 ();
-   if (verbosity >= 2)
-      fprintf ( stderr,
-                "    combined CRCs: stored = 0x%x, computed = 0x%x\n    ",
-                storedCombinedCRC, computedCombinedCRC );
-   if (storedCombinedCRC != computedCombinedCRC) {
-      bsFinishedWithStream();
-      fclose ( zStream );
-      fprintf ( stderr, "\n%s: computed CRC does not match stored one\n",
-                        inName );
-      return False;
+      case BZ_DATA_ERROR_MAGIC:
+         if (streamNo == 1) {
+          fprintf ( stderr, 
+                    "\n%s: bad magic number (ie, not created by bzip2)\n",
+                    inName );
+            return False;
+         } else {
+            fprintf ( stderr, 
+                      "\n%s: %s: trailing garbage after EOF ignored\n",
+                      progName, inName );
+            return True;       
+         }
+      default:
+         panic ( "test:unexpected error" );
    }
 
-   bsFinishedWithStream ();
-   ERROR_IF_NOT_ZERO ( ferror(zStream) );
-   retVal = fclose ( zStream );
-   ERROR_IF_EOF ( retVal );
-   return True;
+   panic ( "test:end" );
+   return True; /*notreached*/
 }
 
 
-
 /*---------------------------------------------------*/
 /*--- Error [non-] handling grunge                ---*/
 /*---------------------------------------------------*/
@@ -3059,8 +592,7 @@ void showFileNames ( void )
    fprintf (
       stderr,
       "\tInput file = %s, output file = %s\n",
-      inName==NULL  ? "(null)" : inName,
-      outName==NULL ? "(null)" : outName
+      inName, outName 
    );
 }
 
@@ -3072,8 +604,7 @@ void cleanUpAndFail ( Int32 ec )
 
    if ( srcMode == SM_F2F && opMode != OM_TEST ) {
       fprintf ( stderr, "%s: Deleting output file %s, if it exists.\n",
-                progName,
-                outName==NULL ? "(null)" : outName );
+                progName, outName );
       if (outputHandleJustInCase != NULL)
          fclose ( outputHandleJustInCase );
       retVal = remove ( outName );
@@ -3108,11 +639,10 @@ void panic ( Char* s )
 
 
 /*---------------------------------------------*/
-void badBGLengths ( void )
+void crcError ()
 {
    fprintf ( stderr,
-             "\n%s: error when reading background model code lengths,\n"
-             "\twhich probably means the compressed file is corrupted.\n",
+             "\n%s: Data integrity error when decompressing.\n",
              progName );
    showFileNames();
    cadvise();
@@ -3121,19 +651,6 @@ void badBGLengths ( void )
 
 
 /*---------------------------------------------*/
-void crcError ( UInt32 crcStored, UInt32 crcComputed )
-{
-   fprintf ( stderr,
-             "\n%s: Data integrity error when decompressing.\n"
-             "\tStored CRC = 0x%x, computed CRC = 0x%x\n",
-             progName, crcStored, crcComputed );
-   showFileNames();
-   cadvise();
-   cleanUpAndFail( 2 );
-}
-
-
-/*---------------------------------------------*/
 void compressedStreamEOF ( void )
 {
    fprintf ( stderr,
@@ -3160,46 +677,6 @@ void ioError ( )
 
 
 /*---------------------------------------------*/
-void blockOverrun ()
-{
-   fprintf ( stderr,
-             "\n%s: block overrun during decompression,\n"
-             "\twhich probably means the compressed file\n"
-             "\tis corrupted.\n",
-             progName );
-   showFileNames();
-   cadvise();
-   cleanUpAndFail( 2 );
-}
-
-
-/*---------------------------------------------*/
-void badBlockHeader ()
-{
-   fprintf ( stderr,
-             "\n%s: bad block header in the compressed file,\n"
-             "\twhich probably means it is corrupted.\n",
-             progName );
-   showFileNames();
-   cadvise();
-   cleanUpAndFail( 2 );
-}
-
-
-/*---------------------------------------------*/
-void bitStreamEOF ()
-{
-   fprintf ( stderr,
-             "\n%s: read past the end of compressed data,\n"
-             "\twhich probably means it is corrupted.\n",
-             progName );
-   showFileNames();
-   cadvise();
-   cleanUpAndFail( 2 );
-}
-
-
-/*---------------------------------------------*/
 void mySignalCatcher ( IntNative n )
 {
    fprintf ( stderr,
@@ -3233,27 +710,11 @@ void mySIGSEGVorSIGBUScatcher ( IntNative n )
 
 
 /*---------------------------------------------*/
-void uncompressOutOfMemory ( Int32 draw, Int32 blockSize )
-{
-   fprintf ( stderr,
-             "\n%s: Can't allocate enough memory for decompression.\n"
-             "\tRequested %d bytes for a block size of %d.\n"
-             "\tTry selecting space-economic decompress (with flag -s)\n"
-             "\tand failing that, find a machine with more memory.\n",
-             progName, draw, blockSize );
-   showFileNames();
-   cleanUpAndFail(1);
-}
-
-
-/*---------------------------------------------*/
-void compressOutOfMemory ( Int32 draw, Int32 blockSize )
+void outOfMemory ( void )
 {
    fprintf ( stderr,
-             "\n%s: Can't allocate enough memory for compression.\n"
-             "\tRequested %d bytes for a block size of %d.\n"
-             "\tTry selecting a small block size (with flag -s).\n",
-             progName, draw, blockSize );
+             "\n%s: couldn't allocate enough memory\n",
+             progName );
    showFileNames();
    cleanUpAndFail(1);
 }
@@ -3274,6 +735,24 @@ void pad ( Char *s )
 
 
 /*---------------------------------------------*/
+void copyFileName ( Char* to, Char* from ) 
+{
+   if ( strlen(from) > FILE_NAME_LEN-10 )  {
+      fprintf (
+         stderr,
+         "bzip2: file name\n`%s'\nis suspiciously (> 1024 chars) long.\n"
+         "Try using a reasonable file name instead.  Sorry! :)\n",
+         from
+      );
+      exit(1);
+   }
+
+  strncpy(to,from,FILE_NAME_LEN-10);
+  to[FILE_NAME_LEN-10]='\0';
+}
+
+
+/*---------------------------------------------*/
 Bool fileExists ( Char* name )
 {
    FILE *tmp   = fopen ( name, "rb" );
@@ -3287,7 +766,7 @@ Bool fileExists ( Char* name )
 /*--
   if in doubt, return True
 --*/
-Bool notABogStandardFile ( Char* name )
+Bool notAStandardFile ( Char* name )
 {
    IntNative      i;
    struct MY_STAT statBuf;
@@ -3300,9 +779,9 @@ Bool notABogStandardFile ( Char* name )
 
 
 /*---------------------------------------------*/
-void copyDateAndPermissions ( Char *srcName, Char *dstName )
+void copyDatePermissionsAndOwner ( Char *srcName, Char *dstName )
 {
-   #if BZ_UNIX
+#if BZ_UNIX
    IntNative      retVal;
    struct MY_STAT statBuf;
    struct utimbuf uTimBuf;
@@ -3314,13 +793,34 @@ void copyDateAndPermissions ( Char *srcName, Char *dstName )
 
    retVal = chmod ( dstName, statBuf.st_mode );
    ERROR_IF_NOT_ZERO ( retVal );
+   /* Not sure if this is really portable or not.  Causes 
+      problems on my x86-Linux Redhat 5.0 box.  Decided
+      to omit it from 0.9.0.  JRS, 27 June 98.  If you 
+      understand Unix file semantics and portability issues
+      well enough to fix this properly, drop me a line
+      at jseward@acm.org.
+   retVal = chown ( dstName, statBuf.st_uid, statBuf.st_gid );
+   ERROR_IF_NOT_ZERO ( retVal );
+   */
    retVal = utime ( dstName, &uTimBuf );
    ERROR_IF_NOT_ZERO ( retVal );
-   #endif
+#endif
 }
 
 
 /*---------------------------------------------*/
+void setInterimPermissions ( Char *dstName )
+{
+#if BZ_UNIX
+   IntNative      retVal;
+   retVal = chmod ( dstName, S_IRUSR | S_IWUSR );
+   ERROR_IF_NOT_ZERO ( retVal );
+#endif
+}
+
+
+
+/*---------------------------------------------*/
 Bool endsInBz2 ( Char* name )
 {
    Int32 n = strlen ( name );
@@ -3353,13 +853,13 @@ void compress ( Char *name )
       panic ( "compress: bad modes\n" );
 
    switch (srcMode) {
-      case SM_I2O: strcpy ( inName, "(stdin)" );
-                   strcpy ( outName, "(stdout)" ); break;
-      case SM_F2F: strcpy ( inName, name );
-                   strcpy ( outName, name );
+      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: strcpy ( inName, name );
-                   strcpy ( outName, "(stdout)" ); break;
+      case SM_F2O: copyFileName ( inName, name );
+                   copyFileName ( outName, "(stdout)" ); break;
    }
 
    if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
@@ -3377,12 +877,12 @@ void compress ( Char *name )
                 progName, inName );
       return;
    }
-   if ( srcMode != SM_I2O && notABogStandardFile ( inName )) {
+   if ( srcMode != SM_I2O && notAStandardFile ( inName )) {
       fprintf ( stderr, "%s: Input file %s is not a normal file, skipping.\n",
                 progName, inName );
       return;
    }
-   if ( srcMode == SM_F2F && fileExists ( outName ) ) {
+   if ( srcMode == SM_F2F && !forceOverwrite && fileExists ( outName ) ) {
       fprintf ( stderr, "%s: Output file %s already exists, skipping.\n",
                 progName, outName );
       return;
@@ -3434,6 +934,7 @@ void compress ( Char *name )
                       progName, inName );
             return;
          };
+         setInterimPermissions ( outName );
          break;
 
       default:
@@ -3454,7 +955,7 @@ void compress ( Char *name )
 
    /*--- If there was an I/O error, we won't get here. ---*/
    if ( srcMode == SM_F2F ) {
-      copyDateAndPermissions ( inName, outName );
+      copyDatePermissionsAndOwner ( inName, outName );
       if ( !keepInputFiles ) {
          IntNative retVal = remove ( inName );
          ERROR_IF_NOT_ZERO ( retVal );
@@ -3474,15 +975,15 @@ void uncompress ( Char *name )
       panic ( "uncompress: bad modes\n" );
 
    switch (srcMode) {
-      case SM_I2O: strcpy ( inName, "(stdin)" );
-                   strcpy ( outName, "(stdout)" ); break;
-      case SM_F2F: strcpy ( inName, name );
-                   strcpy ( outName, name );
+      case SM_I2O: copyFileName ( inName, "(stdin)" );
+                   copyFileName ( outName, "(stdout)" ); break;
+      case SM_F2F: copyFileName ( inName, name );
+                   copyFileName ( outName, name );
                    if (endsInBz2 ( outName ))
                       outName [ strlen ( outName ) - 4 ] = '\0';
                    break;
-      case SM_F2O: strcpy ( inName, name );
-                   strcpy ( outName, "(stdout)" ); break;
+      case SM_F2O: copyFileName ( inName, name );
+                   copyFileName ( outName, "(stdout)" ); break;
    }
 
    if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
@@ -3501,12 +1002,12 @@ void uncompress ( Char *name )
                 progName, inName );
       return;
    }
-   if ( srcMode != SM_I2O && notABogStandardFile ( inName )) {
+   if ( srcMode != SM_I2O && notAStandardFile ( inName )) {
       fprintf ( stderr, "%s: Input file %s is not a normal file, skipping.\n",
                 progName, inName );
       return;
    }
-   if ( srcMode == SM_F2F && fileExists ( outName ) ) {
+   if ( srcMode == SM_F2F && !forceOverwrite && fileExists ( outName ) ) {
       fprintf ( stderr, "%s: Output file %s already exists, skipping.\n",
                 progName, outName );
       return;
@@ -3550,6 +1051,7 @@ void uncompress ( Char *name )
                       progName, inName );
             return;
          };
+         setInterimPermissions ( outName );
          break;
 
       default:
@@ -3571,7 +1073,7 @@ void uncompress ( Char *name )
    /*--- If there was an I/O error, we won't get here. ---*/
    if ( magicNumberOK ) {
       if ( srcMode == SM_F2F ) {
-         copyDateAndPermissions ( inName, outName );
+         copyDatePermissionsAndOwner ( inName, outName );
          if ( !keepInputFiles ) {
             IntNative retVal = remove ( inName );
             ERROR_IF_NOT_ZERO ( retVal );
@@ -3607,11 +1109,11 @@ void testf ( Char *name )
    if (name == NULL && srcMode != SM_I2O)
       panic ( "testf: bad modes\n" );
 
-   strcpy ( outName, "(none)" );
+   copyFileName ( outName, "(none)" );
    switch (srcMode) {
-      case SM_I2O: strcpy ( inName, "(stdin)" ); break;
-      case SM_F2F: strcpy ( inName, name ); break;
-      case SM_F2O: strcpy ( inName, name ); break;
+      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 ) ) {
@@ -3630,7 +1132,7 @@ void testf ( Char *name )
                 progName, inName );
       return;
    }
-   if ( srcMode != SM_I2O && notABogStandardFile ( inName )) {
+   if ( srcMode != SM_I2O && notAStandardFile ( inName )) {
       fprintf ( stderr, "%s: Input file %s is not a normal file, skipping.\n",
                 progName, inName );
       return;
@@ -3684,25 +1186,18 @@ void license ( void )
    fprintf ( stderr,
 
     "bzip2, a block-sorting file compressor.  "
-    "Version 0.1pl2, 29-Aug-97.\n"
+    "Version 0.9.0c, 18-Oct-98.\n"
     "   \n"
-    "   Copyright (C) 1996, 1997 by Julian Seward.\n"
+    "   Copyright (C) 1996, 1997, 1998 by Julian Seward.\n"
     "   \n"
     "   This program is free software; you can redistribute it and/or modify\n"
-    "   it under the terms of the GNU General Public License as published by\n"
-    "   the Free Software Foundation; either version 2 of the License, or\n"
-    "   (at your option) any later version.\n"
+    "   it under the terms set out in the LICENSE file, which is included\n"
+    "   in the bzip2-0.9.0c 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"
-    "   GNU General Public License for more details.\n"
-    "   \n"
-    "   You should have received a copy of the GNU General Public License\n"
-    "   along with this program; if not, write to the Free Software\n"
-    "   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n"
-    "   \n"
-    "   The GNU General Public License is contained in the file LICENSE.\n"
+    "   LICENSE file for more details.\n"
     "   \n"
    );
 }
@@ -3714,16 +1209,17 @@ void usage ( Char *fullProgName )
    fprintf (
       stderr,
       "bzip2, a block-sorting file compressor.  "
-      "Version 0.1pl2, 29-Aug-97.\n"
+      "Version 0.9.0c, 18-Oct-98.\n"
       "\n   usage: %s [flags and input files in any order]\n"
       "\n"
       "   -h --help           print this message\n"
       "   -d --decompress     force decompression\n"
-      "   -f --compress       force compression\n"
+      "   -z --compress       force compression\n"
+      "   -k --keep           keep (don't delete) input files\n"
+      "   -f --force          overwrite existing output filess\n"
       "   -t --test           test compressed file integrity\n"
       "   -c --stdout         output to standard out\n"
       "   -v --verbose        be verbose (a 2nd -v gives more)\n"
-      "   -k --keep           keep (don't delete) input files\n"
       "   -L --license        display software version & license\n"
       "   -V --version        display software version & license\n"
       "   -s --small          use less memory (at most 2500k)\n"
@@ -3731,15 +1227,16 @@ void usage ( Char *fullProgName )
       "   --repetitive-fast   compress repetitive blocks faster\n"
       "   --repetitive-best   compress repetitive blocks better\n"
       "\n"
-      "   If invoked as `bzip2', the default action is to compress.\n"
-      "              as `bunzip2', the default action is to decompress.\n"
+      "   If invoked as `bzip2', default action is to compress.\n"
+      "              as `bunzip2',  default action is to decompress.\n"
+      "              as `bz2cat', 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"
-      "   flags, so `-v -4' means the same as -v4 or -4v, &c.\n"
-      #if BZ_UNIX
+      "   short flags, so `-v -4' means the same as -v4 or -4v, &c.\n"
+#if BZ_UNIX
       "\n"
-      #endif
+#endif
       ,
 
       fullProgName
@@ -3776,14 +1273,7 @@ void *myMalloc ( Int32 n )
    void* p;
 
    p = malloc ( (size_t)n );
-   if (p == NULL) {
-      fprintf (
-         stderr,
-         "%s: `malloc' failed on request for %d bytes.\n",
-         progName, n
-      );
-      exit ( 1 );
-   }
+   if (p == NULL) outOfMemory ();
    return p;
 }
 
@@ -3817,7 +1307,6 @@ Cell *snocString ( Cell *root, Char *name )
 }
 
 
-
 /*---------------------------------------------*/
 #define ISFLAG(s) (strcmp(aa->name, (s))==0)
 
@@ -3829,11 +1318,6 @@ IntNative main ( IntNative argc, Char *argv[] )
    Cell   *argList;
    Cell   *aa;
 
-
-   #if DEBUG
-      fprintf ( stderr, "bzip2: *** compiled with debugging ON ***\n" );
-   #endif
-
    /*-- Be really really really paranoid :-) --*/
    if (sizeof(Int32) != 4 || sizeof(UInt32) != 4  ||
        sizeof(Int16) != 2 || sizeof(UInt16) != 2  ||
@@ -3844,7 +1328,7 @@ IntNative main ( IntNative argc, Char *argv[] )
                 "\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" );
-      exit(1);
+      exit(3);
    }
 
 
@@ -3852,35 +1336,28 @@ IntNative main ( IntNative argc, Char *argv[] )
    signal (SIGINT,  mySignalCatcher);
    signal (SIGTERM, mySignalCatcher);
    signal (SIGSEGV, mySIGSEGVorSIGBUScatcher);
-   #if BZ_UNIX
+#if BZ_UNIX
    signal (SIGHUP,  mySignalCatcher);
    signal (SIGBUS,  mySIGSEGVorSIGBUScatcher);
-   #endif
+#endif
 
 
    /*-- Initialise --*/
    outputHandleJustInCase  = NULL;
-   ftab                    = NULL;
-   ll4                     = NULL;
-   ll16                    = NULL;
-   ll8                     = NULL;
-   tt                      = NULL;
-   block                   = NULL;
-   zptr                    = NULL;
    smallMode               = False;
    keepInputFiles          = False;
+   forceOverwrite          = False;
    verbosity               = 0;
    blockSize100k           = 9;
    testFailsExist          = False;
-   bsStream                = NULL;
    numFileNames            = 0;
    numFilesProcessed       = 0;
    workFactor              = 30;
 
-   strcpy ( inName,  "(none)" );
-   strcpy ( outName, "(none)" );
+   copyFileName ( inName,  "(none)" );
+   copyFileName ( outName, "(none)" );
 
-   strcpy ( progNameReally, argv[0] );
+   copyFileName ( progNameReally, argv[0] );
    progName = &progNameReally[0];
    for (tmp = &progNameReally[0]; *tmp != '\0'; tmp++)
       if (*tmp == PATH_SEP) progName = tmp + 1;
@@ -3903,20 +1380,26 @@ IntNative main ( IntNative argc, Char *argv[] )
       }
 
 
-   /*-- Determine what to do (compress/uncompress/test). --*/
+   /*-- 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 ( (strcmp ( "bunzip2",     progName ) == 0) ||
-        (strcmp ( "BUNZIP2",     progName ) == 0) ||
-        (strcmp ( "bunzip2.exe", progName ) == 0) ||
-        (strcmp ( "BUNZIP2.EXE", progName ) == 0) )
+   if ( (strstr ( progName, "unzip" ) != 0) ||
+        (strstr ( progName, "UNZIP" ) != 0) )
       opMode = OM_UNZ;
 
-
-   /*-- Determine source modes; flag handling may change this too. --*/
-   if (numFileNames == 0)
-      srcMode = SM_I2O; else srcMode = SM_F2F;
+   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. --*/
@@ -3926,7 +1409,8 @@ IntNative main ( IntNative argc, Char *argv[] )
             switch (aa->name[j]) {
                case 'c': srcMode          = SM_F2O; break;
                case 'd': opMode           = OM_UNZ; break;
-               case 'f': opMode           = OM_Z; 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;
@@ -3957,6 +1441,7 @@ IntNative main ( IntNative argc, Char *argv[] )
       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
@@ -3974,14 +1459,9 @@ IntNative main ( IntNative argc, Char *argv[] )
          }
    }
 
+   if (verbosity > 4) verbosity = 4;
    if (opMode == OM_Z && smallMode) blockSize100k = 2;
 
-   if (opMode == OM_Z && srcMode == SM_F2O && numFileNames > 1) {
-      fprintf ( stderr, "%s: I won't compress multiple files to stdout.\n",
-                progName );
-      exit ( 1 );
-   }
-
    if (srcMode == SM_F2O && numFileNames == 0) {
       fprintf ( stderr, "%s: -c expects at least one filename.\n",
                 progName );
@@ -3997,7 +1477,6 @@ IntNative main ( IntNative argc, Char *argv[] )
    if (opMode != OM_Z) blockSize100k = 0;
 
    if (opMode == OM_Z) {
-      allocateCompressStructures();
       if (srcMode == SM_I2O)
          compress ( NULL );
          else
diff --git a/bzip2.txt b/bzip2.txt
index aee8e2b..898dfe8 100644
--- a/bzip2.txt
+++ b/bzip2.txt
@@ -1,22 +1,22 @@
 
-
-
 bzip2(1)                                                 bzip2(1)
 
 
 NAME
-       bzip2, bunzip2 - a block-sorting file compressor, v0.1
+       bzip2, bunzip2 - a block-sorting file compressor, v0.9.0
+       bzcat - decompresses files to stdout
        bzip2recover - recovers data from damaged bzip2 files
 
 
 SYNOPSIS
-       bzip2 [ -cdfkstvVL123456789 ] [ filenames ...  ]
-       bunzip2 [ -kvsVL ] [ filenames ...  ]
+       bzip2 [ -cdfkstvzVL123456789 ] [ filenames ...  ]
+       bunzip2 [ -fkvsVL ] [ filenames ...  ]
+       bzcat [ -s ] [ filenames ...  ]
        bzip2recover filename
 
 
 DESCRIPTION
-       Bzip2  compresses  files  using the Burrows-Wheeler block-
+       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,
@@ -26,7 +26,7 @@ DESCRIPTION
        The command-line options are deliberately very similar  to
        those of GNU Gzip, but they are not identical.
 
-       Bzip2  expects  a list of file names to accompany the com-
+       bzip2  expects  a list of file names to accompany the com-
        mand-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  and
@@ -38,8 +38,8 @@ DESCRIPTION
        cepts, or have serious file name length restrictions, such
        as MS-DOS.
 
-       Bzip2  and  bunzip2  will not overwrite existing files; if
-       you want this to happen, you should delete them first.
+       bzip2  and  bunzip2 will by default not overwrite existing
+       files; if you want this to happen, specify the -f flag.
 
        If no file names  are  specified,  bzip2  compresses  from
        standard  input  to  standard output.  In this case, bzip2
@@ -47,28 +47,29 @@ DESCRIPTION
        this  would  be  entirely  incomprehensible  and therefore
        pointless.
 
-       Bunzip2 (or bzip2 -d ) decompresses and restores all spec-
+       bunzip2 (or bzip2 -d ) decompresses and restores all spec-
        ified files whose names end in ".bz2".  Files without this
        suffix are ignored.  Again, supplying no filenames  causes
        decompression from standard input to standard output.
 
-       You  can also compress or decompress files to the standard
-       output by giving the -c flag.  You can decompress multiple
-       files  like  this, but you may only compress a single file
-       this way, since it would otherwise be difficult  to  sepa-
-       rate  out  the  compressed representations of the original
-       files.
-
-
-
-                                                                1
-
-
-
-
-
-bzip2(1)                                                 bzip2(1)
+       bunzip2 will correctly decompress a file which is the con-
+       catenation 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  com-
+       pressed and decompressed like this.  The resulting outputs
+       are fed sequentially to stdout.  Compression  of  multiple
+       files  in this manner generates a stream containing multi-
+       ple compressed file representations.  Such a stream can be
+       decompressed  correctly  only  by  bzip2  version 0.9.0 or
+       later.  Earlier versions of bzip2 will stop  after  decom-
+       pressing the first file in the stream.
+
+       bzcat  (or bzip2 -dc ) decompresses all specified files to
+       the standard output.
 
        Compression is always performed, even  if  the  compressed
        file  is slightly larger than the original.  Files of less
@@ -108,13 +109,14 @@ MEMORY MANAGEMENT
        file, and 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.   Com-
-       pression  and decompression requirements, in bytes, can be
-       estimated as:
+       irrelevant  to  and  so  ignored   during   decompression.
+
+       Compression  and decompression requirements, in bytes, can
+       be estimated as:
 
              Compression:   400k + ( 7 x block size )
 
-             Decompression: 100k + ( 5 x block size ), or
+             Decompression: 100k + ( 4 x block size ), or
                             100k + ( 2.5 x block size )
 
        Larger  block  sizes  give  rapidly  diminishing  marginal
@@ -125,19 +127,8 @@ MEMORY MANAGEMENT
        requirement  is  set  at compression-time by the choice of
        block size.
 
-
-
-                                                                2
-
-
-
-
-
-bzip2(1)                                                 bzip2(1)
-
-
        For files compressed with the  default  900k  block  size,
-       bunzip2  will require about 4600 kbytes to decompress.  To
+       bunzip2  will require about 3700 kbytes to decompress.  To
        support decompression of any file on a 4 megabyte machine,
        bunzip2  has  an  option to decompress using approximately
        half this amount of memory, about 2300 kbytes.  Decompres-
@@ -157,8 +148,8 @@ bzip2(1)                                                 bzip2(1)
        file 20,000 bytes long with the flag  -9  will  cause  the
        compressor  to  allocate  around 6700k of memory, but only
        touch 400k + 20000 * 7 = 540 kbytes of it.  Similarly, the
-       decompressor  will  allocate  4600k  but only touch 100k +
-       20000 * 5 = 200 kbytes.
+       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
@@ -172,15 +163,15 @@ bzip2(1)                                                 bzip2(1)
                   Compress   Decompress   Decompress   Corpus
            Flag     usage      usage       -s usage     Size
 
-            -1      1100k       600k         350k      914704
-            -2      1800k      1100k         600k      877703
-            -3      2500k      1600k         850k      860338
-            -4      3200k      2100k        1100k      846899
-            -5      3900k      2600k        1350k      845160
-            -6      4600k      3100k        1600k      838626
-            -7      5400k      3600k        1850k      834096
-            -8      6000k      4100k        2100k      828642
-            -9      6700k      4600k        2350k      828642
+            -1      1100k       500k         350k      914704
+            -2      1800k       900k         600k      877703
+            -3      2500k      1300k         850k      860338
+            -4      3200k      1700k        1100k      846899
+            -5      3900k      2100k        1350k      845160
+            -6      4600k      2500k        1600k      838626
+            -7      5400k      2900k        1850k      834096
+            -8      6000k      3300k        2100k      828642
+            -9      6700k      3700k        2350k      828642
 
 
 OPTIONS
@@ -189,47 +180,37 @@ OPTIONS
               decompress multiple files to stdout, but will  only
               compress a single file to stdout.
 
-
-
-
-
-                                                                3
-
-
-
-
-
-bzip2(1)                                                 bzip2(1)
-
-
        -d --decompress
-              Force  decompression.  Bzip2 and bunzip2 are really
-              the same program, and the decision about whether to
-              compress  or  decompress  is  done  on the basis of
-              which name is used.  This flag overrides that mech-
-              anism, and forces bzip2 to decompress.
+              Force  decompression.  bzip2, bunzip2 and 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.
 
-       -f --compress
+       -z --compress
               The  complement  to -d: forces compression, regard-
               less of the invokation name.
 
        -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, using the
-              low-memory decompression algorithm (see -s).
+              decompression and throws away the result.
+
+       -f --force
+              Force overwrite of output files.   Normally,  bzip2
+              will not overwrite existing output files.
 
        -k --keep
               Keep  (don't delete) input files during compression
               or decompression.
 
        -s --small
-              Reduce  memory  usage,  both  for  compression  and
-              decompression.  Files are decompressed using a mod-
-              ified algorithm which only requires 2.5  bytes  per
-              block  byte.   This  means  any  file can be decom-
-              pressed in 2300k of memory,  albeit  somewhat  more
-              slowly than usual.
+              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
@@ -238,36 +219,21 @@ bzip2(1)                                                 bzip2(1)
               megabytes  or  less),  use  -s for everything.  See
               MEMORY MANAGEMENT above.
 
-
        -v --verbose
               Verbose mode -- show the compression ratio for each
               file  processed.   Further  -v's  increase the ver-
               bosity level, spewing out lots of information which
               is primarily of interest for diagnostic purposes.
 
-       -L --license
+       -L --license -V --version
               Display  the  software  version,  license terms and
               conditions.
 
-       -V --version
-              Same as -L.
-
        -1 to -9
               Set the block size to 100 k, 200 k ..  900  k  when
               compressing.   Has  no  effect  when decompressing.
               See MEMORY MANAGEMENT above.
 
-
-
-                                                                4
-
-
-
-
-
-bzip2(1)                                                 bzip2(1)
-
-
        --repetitive-fast
               bzip2 injects some small  pseudo-random  variations
               into  very  repetitive  blocks  to limit worst-case
@@ -278,7 +244,6 @@ bzip2(1)                                                 bzip2(1)
               would take before resorting to randomisation.  This
               flag makes it give up much sooner.
 
-
        --repetitive-best
               Opposite  of  --repetitive-fast;  try  a lot harder
               before resorting to randomisation.
@@ -306,10 +271,10 @@ RECOVERING DATA FROM DAMAGED FILES
        bzip2recover takes a single argument, the name of the dam-
        aged 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 wild-
-       cards in subsequent processing -- for example, "bzip2  -dc
-       rec*file.bz2  >  recovered_data" -- lists the files in the
-       "right" order.
+       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 "right" order.
 
        bzip2recover should be of most use dealing with large .bz2
        files,  as  these will contain many blocks.  It is clearly
@@ -322,18 +287,6 @@ RECOVERING DATA FROM DAMAGED FILES
 
 PERFORMANCE NOTES
        The sorting phase of compression gathers together  similar
-
-
-
-                                                                5
-
-
-
-
-
-bzip2(1)                                                 bzip2(1)
-
-
        strings  in  the  file.  Because of this, files containing
        very long runs of  repeated  symbols,  like  "aabaabaabaab
        ..."   (repeated   several  hundred  times)  may  compress
@@ -348,10 +301,6 @@ bzip2(1)                                                 bzip2(1)
        severe slowness in compression, try making the block  size
        as small as possible, with flag -1.
 
-       Incompressible or virtually-incompressible data may decom-
-       press rather more slowly than one would hope.  This is due
-       to a naive implementation of the move-to-front coder.
-
        bzip2  usually  allocates  several  megabytes of memory to
        operate in, and then charges all over it in a fairly  ran-
        dom  fashion.   This means that performance, both for com-
@@ -362,12 +311,6 @@ bzip2(1)                                                 bzip2(1)
        large performance improvements.  I imagine bzip2 will per-
        form best on machines with very large caches.
 
-       Test mode (-t) uses the low-memory decompression algorithm
-       (-s).  This means test mode does not run  as  fast  as  it
-       could;  it  could  run as fast as the normal decompression
-       machinery.  This could easily be fixed at the cost of some
-       code bloat.
-
 
 CAVEATS
        I/O  error  messages  are not as helpful as they could be.
@@ -375,91 +318,38 @@ CAVEATS
        but  the  details  of  what  the problem is sometimes seem
        rather misleading.
 
-       This manual page pertains to version 0.1 of bzip2.  It may
-       well  happen that some future version will use a different
-       compressed file format.  If you try to  decompress,  using
-       0.1,  a  .bz2  file created with some future version which
-       uses a different compressed file format, 0.1 will complain
-       that  your  file  "is not a bzip2 file".  If that happens,
-       you should obtain a more recent version of bzip2  and  use
-       that to decompress the file.
+       This manual page pertains to version 0.9.0 of bzip2.  Com-
+       pressed  data created by this version is entirely forwards
+       and backwards compatible with the previous public release,
+       version  0.1pl2,  but  with the following exception: 0.9.0
+       can correctly decompress multiple concatenated  compressed
+       files.   0.1pl2  cannot do this; it will stop after decom-
+       pressing just the first file in the stream.
 
        Wildcard expansion for Windows 95 and NT is flaky.
 
-       bzip2recover  uses  32-bit integers to represent bit posi-
-       tions in compressed files, so it cannot handle  compressed
-
-
-
-                                                                6
-
-
-
-
-
-bzip2(1)                                                 bzip2(1)
-
-
-       files  more than 512 megabytes long.  This could easily be
+       bzip2recover uses 32-bit integers to represent  bit  posi-
+       tions  in compressed files, so it cannot handle compressed
+       files more than 512 megabytes long.  This could easily  be
        fixed.
 
-       bzip2recover sometimes reports a  very  small,  incomplete
-       final  block.  This is spurious and can be safely ignored.
-
-
-RELATIONSHIP TO bzip-0.21
-       This program is a descendant of the bzip program,  version
-       0.21,  which  I released in August 1996.  The primary dif-
-       ference of bzip2 is its avoidance of the possibly patented
-       algorithms  which  were  used  in 0.21.  bzip2 also brings
-       various useful refinements (-s,  -t),  uses  less  memory,
-       decompresses  significantly  faster,  and  has support for
-       recovering data from damaged files.
-
-       Because bzip2 uses Huffman coding to  construct  the  com-
-       pressed  bitstream, rather than the arithmetic coding used
-       in 0.21, the compressed representations generated  by  the
-       two  programs are incompatible, and they will not interop-
-       erate.  The change in suffix from  .bz  to  .bz2  reflects
-       this.   It would have been helpful to at least allow bzip2
-       to decompress files created by 0.21, but this would defeat
-       the primary aim of having a patent-free compressor.
-
-       For a more precise statement about patent issues in bzip2,
-       please see the README file in the distribution.
-
-       Huffman  coding  necessarily  involves some coding ineffi-
-       ciency compared to arithmetic  coding.   This  means  that
-       bzip2  compresses about 1% worse than 0.21, an unfortunate
-       but unavoidable fact-of-life.  On the other  hand,  decom-
-       pression  is approximately 50% faster for the same reason,
-       and the change in file format gave an opportunity  to  add
-       data-recovery features.  So it is not all bad.
-
 
 AUTHOR
        Julian Seward, jseward@acm.org.
-
-       The ideas embodied in bzip and 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 0.21, and many refinements),
-       and Alistair Moffat, Radford Neal and Ian Witten (for  the
-       arithmetic  coder  in 0.21).  I am much indebted for their
-       help, support and advice.  See the file ALGORITHMS in  the
-       source  distribution for pointers to sources of documenta-
-       tion.  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  com-
-       pression  performance.   Many  people sent patches, helped
+       http://www.muraroa.demon.co.uk
+
+       The ideas embodied in bzip2 are due to (at least) the fol-
+       lowing people: Michael Burrows and David Wheeler (for  the
+       block  sorting  transformation), David Wheeler (again, for
+       the Huffman coder), Peter Fenwick (for the structured cod-
+       ing model in the original bzip, and many refinements), and
+       Alistair Moffat, Radford Neal  and  Ian  Witten  (for  the
+       arithmetic  coder  in  the  original  bzip).   I  am  much
+       indebted for their help, support and advice.  See the man-
+       ual  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 compres-
+       sion.  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.
-
-
-
-
-
-                                                                7
-
-
diff --git a/bzip2recover.c b/bzip2recover.c
index 0eef0e6..0e2822b 100644
--- a/bzip2recover.c
+++ b/bzip2recover.c
@@ -7,43 +7,63 @@
 /*--
   This program is bzip2recover, a program to attempt data 
   salvage from damaged files created by the accompanying
-  bzip2-0.1 program.
-
-  Copyright (C) 1996, 1997 by Julian Seward.
-     Guildford, Surrey, UK
-     email: jseward@acm.org
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-  The GNU General Public License is contained in the file LICENSE.
+  bzip2-0.9.0c program.
+
+  Copyright (C) 1996-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
 --*/
 
+/*--
+  This program is a complete hack and should be rewritten
+  properly.  It isn't very complicated.
+--*/
 
 #include <stdio.h>
 #include <errno.h>
-#include <malloc.h>
 #include <stdlib.h>
-#include <strings.h>  /*-- or try string.h --*/
+#include <string.h>
 
-#define UInt32  unsigned int
-#define Int32   int
-#define UChar   unsigned char
-#define Char    char
-#define Bool    unsigned char
-#define True    1
-#define False   0
+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];
@@ -191,8 +211,9 @@ void bsClose ( BitStream* bs )
       if (retVal == EOF) writeError();
    }
    retVal = fclose ( bs->handle );
-   if (retVal == EOF)
+   if (retVal == EOF) {
       if (bs->mode == 'w') writeError(); else readError();
+   }
    free ( bs );
 }
 
@@ -248,13 +269,19 @@ Int32 main ( Int32 argc, Char** argv )
    UInt32      bitsRead;
    UInt32      bStart[20000];
    UInt32      bEnd[20000];
+
+   UInt32      rbStart[20000];
+   UInt32      rbEnd[20000];
+   Int32       rbCtr;
+
+
    UInt32      buffHi, buffLo, blockCRC;
    Char*       p;
 
    strcpy ( progName, argv[0] );
    inFileName[0] = outFileName[0] = 0;
 
-   fprintf ( stderr, "bzip2recover: extracts blocks from damaged .bz2 files.\n" );
+   fprintf ( stderr, "bzip2recover v0.9.0c: extracts blocks from damaged .bz2 files.\n" );
 
    if (argc != 2) {
       fprintf ( stderr, "%s: usage is `%s damaged_file_name'.\n",
@@ -278,6 +305,8 @@ Int32 main ( Int32 argc, Char** argv )
    currBlock = 0;
    bStart[currBlock] = 0;
 
+   rbCtr = 0;
+
    while (True) {
       b = bsGetBit ( bsIn );
       bitsRead++;
@@ -303,19 +332,25 @@ Int32 main ( Int32 argc, Char** argv )
          if (bitsRead > 49)
             bEnd[currBlock] = bitsRead-49; else
             bEnd[currBlock] = 0;
-         if (currBlock > 0)
+         if (currBlock > 0 &&
+             (bEnd[currBlock] - bStart[currBlock]) >= 130) {
             fprintf ( stderr, "   block %d runs from %d to %d\n",
-                      currBlock,  bStart[currBlock], bEnd[currBlock] );
+                      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 currBlock inclusive. --*/
+   /*-- identified blocks run from 1 to rbCtr inclusive. --*/
 
-   if (currBlock < 1) {
+   if (rbCtr < 1) {
       fprintf ( stderr,
                 "%s: sorry, I couldn't find any block boundaries.\n",
                 progName );
@@ -336,23 +371,23 @@ Int32 main ( Int32 argc, Char** argv )
 
    bitsRead = 0;
    outFile = NULL;
-   wrBlock = 1;
+   wrBlock = 0;
    while (True) {
       b = bsGetBit(bsIn);
       if (b == 2) break;
       buffHi = (buffHi << 1) | (buffLo >> 31);
       buffLo = (buffLo << 1) | (b & 1);
-      if (bitsRead == 47+bStart[wrBlock]) 
+      if (bitsRead == 47+rbStart[wrBlock]) 
          blockCRC = (buffHi << 16) | (buffLo >> 16);
 
-      if (outFile != NULL && bitsRead >= bStart[wrBlock]
-                          && bitsRead <= bEnd[wrBlock]) {
+      if (outFile != NULL && bitsRead >= rbStart[wrBlock]
+                          && bitsRead <= rbEnd[wrBlock]) {
          bsPutBit ( bsWr, b );
       }
 
       bitsRead++;
 
-      if (bitsRead == bEnd[wrBlock]+1) {
+      if (bitsRead == rbEnd[wrBlock]+1) {
          if (outFile != NULL) {
             bsPutUChar ( bsWr, 0x17 ); bsPutUChar ( bsWr, 0x72 );
             bsPutUChar ( bsWr, 0x45 ); bsPutUChar ( bsWr, 0x38 );
@@ -360,18 +395,18 @@ Int32 main ( Int32 argc, Char** argv )
             bsPutUInt32 ( bsWr, blockCRC );
             bsClose ( bsWr );
          }
-         if (wrBlock >= currBlock) break;
+         if (wrBlock >= rbCtr) break;
          wrBlock++;
       } else
-      if (bitsRead == bStart[wrBlock]) {
+      if (bitsRead == rbStart[wrBlock]) {
          outFileName[0] = 0;
-         sprintf ( outFileName, "rec%4d", wrBlock );
+         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, outFileName );
+                           wrBlock+1, outFileName );
 
          outFile = fopen ( outFileName, "wb" );
          if (outFile == NULL) {
diff --git a/bzlib.c b/bzlib.c
new file mode 100644
index 0000000..362e8ff
--- /dev/null
+++ b/bzlib.c
@@ -0,0 +1,1512 @@
+
+/*-------------------------------------------------------------*/
+/*--- 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-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
+
+  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 bz__AssertH__fail ( int errcode )
+{
+   fprintf(stderr, 
+      "\n\nbzip2/libbzip2, v0.9.0c: internal error number %d.\n"
+      "This is a bug in bzip2/libbzip2, v0.9.0c.  Please report\n"
+      "it to me at: jseward@acm.org.  If this happened when\n"
+      "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.  Thx.  Julian Seward, 18 October 1998.\n\n",
+      errcode
+   );
+   exit(3);
+}
+#endif
+
+
+/*---------------------------------------------------*/
+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(bzCompressInit) 
+                    ( bz_stream* strm, 
+                     int        blockSize100k,
+                     int        verbosity,
+                     int        workFactor )
+{
+   Int32   n;
+   EState* s;
+
+   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->block    = NULL;
+   s->quadrant = NULL;
+   s->zptr     = NULL;
+   s->ftab     = NULL;
+
+   n           = 100000 * blockSize100k;
+   s->block    = BZALLOC( (n + BZ_NUM_OVERSHOOT_BYTES) * sizeof(UChar) );
+   s->quadrant = BZALLOC( (n + BZ_NUM_OVERSHOOT_BYTES) * sizeof(Int16) );
+   s->zptr     = BZALLOC( n                            * sizeof(Int32) );
+   s->ftab     = BZALLOC( 65537                        * sizeof(Int32) );
+
+   if (s->block == NULL || s->quadrant == NULL ||
+       s->zptr == NULL  || s->ftab == NULL) {
+      if (s->block    != NULL) BZFREE(s->block);
+      if (s->quadrant != NULL) BZFREE(s->quadrant);
+      if (s->zptr     != NULL) BZFREE(s->zptr);
+      if (s->ftab     != NULL) BZFREE(s->ftab);
+      if (s           != NULL) BZFREE(s);
+      return BZ_MEM_ERROR;
+   }
+
+   s->szptr = (UInt16*)(s->zptr);
+
+   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->nBlocksRandomised = 0;
+   strm->state          = s;
+   strm->total_in       = 0;
+   strm->total_out      = 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++;
+      }
+
+   } 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++;
+         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) = ((UChar*)(s->quadrant))[s->state_out_pos];
+      s->state_out_pos++;
+      s->strm->avail_out--;
+      s->strm->next_out++;
+      s->strm->total_out++;
+      
+   }
+
+   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 );
+            compressBlock ( s, s->mode == BZ_M_FINISHING );
+            s->state = BZ_S_OUTPUT;
+         }
+         else
+         if (s->nblock >= s->nblockMAX) {
+            compressBlock ( s, False );
+            s->state = BZ_S_OUTPUT;
+         }
+         else
+         if (s->strm->avail_in == 0) {
+            break;
+         }
+      }
+
+   }
+
+   return progress_in || progress_out;
+}
+
+
+/*---------------------------------------------------*/
+int BZ_API(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(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->block    != NULL) BZFREE(s->block);
+   if (s->quadrant != NULL) BZFREE(s->quadrant);
+   if (s->zptr     != NULL) BZFREE(s->zptr);
+   if (s->ftab     != NULL) BZFREE(s->ftab);
+   BZFREE(strm->state);
+
+   strm->state = NULL;   
+
+   return BZ_OK;
+}
+
+
+/*---------------------------------------------------*/
+/*--- Decompression stuff                         ---*/
+/*---------------------------------------------------*/
+
+/*---------------------------------------------------*/
+int BZ_API(bzDecompressInit) 
+                     ( bz_stream* strm, 
+                       int        verbosity,
+                       int        small )
+{
+   DState* s;
+
+   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           = 0;
+   strm->total_out          = 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++;
+         }
+   
+         /* 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;
+
+      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:
+      s->strm->total_out += (avail_out_INIT - cs_avail_out);
+
+      /* 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 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++;
+         }
+   
+         /* 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++;
+         }
+   
+         /* 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(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 = 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 );
+   /*notreached*/
+}
+
+
+/*---------------------------------------------------*/
+int BZ_API(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(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 = 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(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 = 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(bzWriteClose)
+                  ( int*          bzerror, 
+                    BZFILE*       b, 
+                    int           abandon,
+                    unsigned int* nbytes_in,
+                    unsigned int* nbytes_out )
+{
+   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 != NULL) *nbytes_in = 0;
+   if (nbytes_out != NULL) *nbytes_out = 0;
+
+   if ((!abandon) && bzf->lastErr == BZ_OK) {
+      while (True) {
+         bzf->strm.avail_out = BZ_MAX_UNUSED;
+         bzf->strm.next_out = bzf->buf;
+         ret = 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 != NULL) *nbytes_in = bzf->strm.total_in;
+   if (nbytes_out != NULL) *nbytes_out = bzf->strm.total_out;
+
+   BZ_SETERR(BZ_OK);
+   bzCompressEnd ( &(bzf->strm) );
+   free ( bzf );
+}
+
+
+/*---------------------------------------------------*/
+BZFILE* BZ_API(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 = 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(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)bzDecompressEnd ( &(bzf->strm) );
+   free ( bzf );
+}
+
+
+/*---------------------------------------------------*/
+int BZ_API(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 = 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(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(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 = 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 = 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;   
+   bzCompressEnd ( &strm );
+   return BZ_OK;
+
+   output_overflow:
+   bzCompressEnd ( &strm );
+   return BZ_OUTBUFF_FULL;
+
+   errhandler:
+   bzCompressEnd ( &strm );
+   return ret;
+}
+
+
+/*---------------------------------------------------*/
+int BZ_API(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 = 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 = bzDecompress ( &strm );
+   if (ret == BZ_OK) goto output_overflow_or_eof;
+   if (ret != BZ_STREAM_END) goto errhandler;
+
+   /* normal termination */
+   *destLen -= strm.avail_out;
+   bzDecompressEnd ( &strm );
+   return BZ_OK;
+
+   output_overflow_or_eof:
+   if (strm.avail_out > 0) {
+      bzDecompressEnd ( &strm );
+      return BZ_UNEXPECTED_EOF;
+   } else {
+      bzDecompressEnd ( &strm );
+      return BZ_OUTBUFF_FULL;
+   };      
+
+   errhandler:
+   bzDecompressEnd ( &strm );
+   return BZ_SEQUENCE_ERROR;
+}
+
+
+/*---------------------------------------------------*/
+/*--
+   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(bzlibVersion)(void)
+{
+   return BZ_VERSION;
+}
+
+
+#ifndef BZ_NO_STDIO
+/*---------------------------------------------------*/
+
+#if defined(_WIN32) || defined(OS2) || defined(MSDOS)
+#   include <fcntl.h>
+#   include <io.h>
+#   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(*mode)){
+            blockSize100k = 0;
+            while(isdigit(*mode)){
+               blockSize100k = blockSize100k*10 + *mode-'0';
+               mode++;
+            }
+         }else{
+            /* ignore */
+         }
+      }
+      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){
+      bzfp = bzWriteOpen(&bzerr,fp,blockSize100k,verbosity,workFactor);
+   }else{
+      bzfp = 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(bzopen)
+               ( const char *path,
+                 const char *mode )
+{
+   return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0);
+}
+
+
+/*---------------------------------------------------*/
+BZFILE * BZ_API(bzdopen)
+               ( int fd,
+                 const char *mode )
+{
+   return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1);
+}
+
+
+/*---------------------------------------------------*/
+int BZ_API(bzread) (BZFILE* b, void* buf, int len )
+{
+   int bzerr, nread;
+   if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0;
+   nread = bzRead(&bzerr,b,buf,len);
+   if (bzerr == BZ_OK || bzerr == BZ_STREAM_END) {
+      return nread;
+   } else {
+      return -1;
+   }
+}
+
+
+/*---------------------------------------------------*/
+int BZ_API(bzwrite) (BZFILE* b, void* buf, int len )
+{
+   int bzerr;
+
+   bzWrite(&bzerr,b,buf,len);
+   if(bzerr == BZ_OK){
+      return len;
+   }else{
+      return -1;
+   }
+}
+
+
+/*---------------------------------------------------*/
+int BZ_API(bzflush) (BZFILE *b)
+{
+   /* do nothing now... */
+   return 0;
+}
+
+
+/*---------------------------------------------------*/
+void BZ_API(bzclose) (BZFILE* b)
+{
+   int bzerr;
+   FILE *fp = ((bzFile *)b)->handle;
+   
+   if(b==NULL){return;}
+   if(((bzFile*)b)->writing){
+      bzWriteClose(&bzerr,b,0,NULL,NULL);
+      if(bzerr != BZ_OK){
+         bzWriteClose(NULL,b,1,NULL,NULL);
+      }
+   }else{
+      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"
+      ,"???"   /* for future */
+      ,"???"   /* for future */
+      ,"???"   /* for future */
+      ,"???"   /* for future */
+      ,"???"   /* for future */
+      ,"???"   /* for future */
+};
+
+
+const char * BZ_API(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/bzlib.h b/bzlib.h
new file mode 100644
index 0000000..bb62273
--- /dev/null
+++ b/bzlib.h
@@ -0,0 +1,299 @@
+
+/*-------------------------------------------------------------*/
+/*--- 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-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
+
+  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
+
+#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)
+
+typedef 
+   struct {
+      char *next_in;
+      unsigned int avail_in;
+      unsigned int total_in;
+
+      char *next_out;
+      unsigned int avail_out;
+      unsigned int total_out;
+
+      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 <stdio.h>
+#   include <windows.h>
+#   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(bzCompressInit) ( 
+      bz_stream* strm, 
+      int        blockSize100k, 
+      int        verbosity, 
+      int        workFactor 
+   );
+
+BZ_EXTERN int BZ_API(bzCompress) ( 
+      bz_stream* strm, 
+      int action 
+   );
+
+BZ_EXTERN int BZ_API(bzCompressEnd) ( 
+      bz_stream* strm 
+   );
+
+BZ_EXTERN int BZ_API(bzDecompressInit) ( 
+      bz_stream *strm, 
+      int       verbosity, 
+      int       small
+   );
+
+BZ_EXTERN int BZ_API(bzDecompress) ( 
+      bz_stream* strm 
+   );
+
+BZ_EXTERN int BZ_API(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(bzReadOpen) ( 
+      int*  bzerror,   
+      FILE* f, 
+      int   verbosity, 
+      int   small,
+      void* unused,    
+      int   nUnused 
+   );
+
+BZ_EXTERN void BZ_API(bzReadClose) ( 
+      int*    bzerror, 
+      BZFILE* b 
+   );
+
+BZ_EXTERN void BZ_API(bzReadGetUnused) ( 
+      int*    bzerror, 
+      BZFILE* b, 
+      void**  unused,  
+      int*    nUnused 
+   );
+
+BZ_EXTERN int BZ_API(bzRead) ( 
+      int*    bzerror, 
+      BZFILE* b, 
+      void*   buf, 
+      int     len 
+   );
+
+BZ_EXTERN BZFILE* BZ_API(bzWriteOpen) ( 
+      int*  bzerror,      
+      FILE* f, 
+      int   blockSize100k, 
+      int   verbosity, 
+      int   workFactor 
+   );
+
+BZ_EXTERN void BZ_API(bzWrite) ( 
+      int*    bzerror, 
+      BZFILE* b, 
+      void*   buf, 
+      int     len 
+   );
+
+BZ_EXTERN void BZ_API(bzWriteClose) ( 
+      int*          bzerror, 
+      BZFILE*       b, 
+      int           abandon, 
+      unsigned int* nbytes_in, 
+      unsigned int* nbytes_out 
+   );
+#endif
+
+
+/*-- Utility functions --*/
+
+BZ_EXTERN int BZ_API(bzBuffToBuffCompress) ( 
+      char*         dest, 
+      unsigned int* destLen,
+      char*         source, 
+      unsigned int  sourceLen,
+      int           blockSize100k, 
+      int           verbosity, 
+      int           workFactor 
+   );
+
+BZ_EXTERN int BZ_API(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(bzlibVersion) (
+      void
+   );
+
+#ifndef BZ_NO_STDIO
+BZ_EXTERN BZFILE * BZ_API(bzopen) (
+      const char *path,
+      const char *mode
+   );
+
+BZ_EXTERN BZFILE * BZ_API(bzdopen) (
+      int        fd,
+      const char *mode
+   );
+         
+BZ_EXTERN int BZ_API(bzread) (
+      BZFILE* b, 
+      void* buf, 
+      int len 
+   );
+
+BZ_EXTERN int BZ_API(bzwrite) (
+      BZFILE* b, 
+      void*   buf, 
+      int     len 
+   );
+
+BZ_EXTERN int BZ_API(bzflush) (
+      BZFILE* b
+   );
+
+BZ_EXTERN void BZ_API(bzclose) (
+      BZFILE* b
+   );
+
+BZ_EXTERN const char * BZ_API(bzerror) (
+      BZFILE *b, 
+      int    *errnum
+   );
+#endif
+
+
+#endif
+
+/*-------------------------------------------------------------*/
+/*--- end                                           bzlib.h ---*/
+/*-------------------------------------------------------------*/
diff --git a/bzlib_private.h b/bzlib_private.h
new file mode 100644
index 0000000..4044aef
--- /dev/null
+++ b/bzlib_private.h
@@ -0,0 +1,523 @@
+
+/*-------------------------------------------------------------*/
+/*--- 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-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
+
+  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 <stdlib.h>
+
+#ifndef BZ_NO_STDIO
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#endif
+
+#include "bzlib.h"
+
+
+
+/*-- General stuff. --*/
+
+#define BZ_VERSION  "0.9.0c"
+
+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 bz__AssertH__fail ( int errcode );
+#define AssertH(cond,errcode) \
+   { if (!(cond)) 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 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 = rNums[s->rTPos];             \
+      s->rTPos++;                              \
+      if (s->rTPos == 512) s->rTPos = 0;       \
+   }                                           \
+   s->rNToGo--;
+
+
+
+/*-- Stuff for doing CRCs. --*/
+
+extern UInt32 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) ^                    \
+            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_NUM_OVERSHOOT_BYTES 20
+
+
+
+/*-- 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 */
+      UChar*   block;
+      UInt16*  quadrant;
+      UInt32*  zptr;
+      UInt16*  szptr;
+      Int32*   ftab;
+      Int32    workDone;
+      Int32    workLimit;
+      Int32    workFactor;
+      Bool     firstAttempt;
+      Bool     blockRandomised;
+      Int32    origPtr;
+
+      /* 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    nBlocksRandomised;
+      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];
+
+   }
+   EState;
+
+
+
+/*-- externs for compression. --*/
+
+extern void 
+blockSort ( EState* );
+
+extern void 
+compressBlock ( EState*, Bool );
+
+extern void 
+bsInitWrite ( EState* );
+
+extern void 
+hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
+
+extern void 
+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 = indexIntoF ( s->tPos, s->cftab );    \
+      s->tPos = GET_LL(s->tPos);
+
+
+/*-- externs for decompression. --*/
+
+extern Int32 
+indexIntoF ( Int32, Int32* );
+
+extern Int32 
+decompress ( DState* );
+
+extern void 
+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/compress.c b/compress.c
new file mode 100644
index 0000000..23abd43
--- /dev/null
+++ b/compress.c
@@ -0,0 +1,588 @@
+
+/*-------------------------------------------------------------*/
+/*--- 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-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0 of 28 June 1998
+
+  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 bsInitWrite ( EState* s )
+{
+   s->bsLive = 0;
+   s->bsBuff = 0;
+}
+
+
+/*---------------------------------------------------*/
+static
+void bsFinishWrite ( EState* s )
+{
+   while (s->bsLive > 0) {
+      ((UChar*)(s->quadrant))[s->numZ] = (UChar)(s->bsBuff >> 24);
+      s->numZ++;
+      s->bsBuff <<= 8;
+      s->bsLive -= 8;
+   }
+}
+
+
+/*---------------------------------------------------*/
+#define bsNEEDW(nz)                           \
+{                                             \
+   while (s->bsLive >= 8) {                   \
+      ((UChar*)(s->quadrant))[s->numZ]        \
+         = (UChar)(s->bsBuff >> 24);          \
+      s->numZ++;                              \
+      s->bsBuff <<= 8;                        \
+      s->bsLive -= 8;                         \
+   }                                          \
+}
+
+
+/*---------------------------------------------------*/
+static
+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;
+   UChar  tmp;
+   UChar  tmp2;
+   Int32  zPend;
+   Int32  wr;
+   Int32  EOB;
+
+   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 = s->zptr[i]-1; if (j < 0) j += s->nblock;
+      ll_i = s->unseqToSeq[s->block[j]];
+      AssertD ( ll_i < s->nInUse, "generateMTFValues(2a)" );
+
+      j = 0;
+      tmp = yy[j];
+      while ( ll_i != tmp ) {
+         j++;
+         tmp2 = tmp;
+         tmp = yy[j];
+         yy[j] = tmp2;
+      };
+      yy[0] = tmp;
+
+      if (j == 0) {
+         zPend++;
+      } else {
+         if (zPend > 0) {
+            zPend--;
+            while (True) {
+               switch (zPend % 2) {
+                  case 0: s->szptr[wr] = BZ_RUNA; wr++; s->mtfFreq[BZ_RUNA]++; break;
+                  case 1: s->szptr[wr] = BZ_RUNB; wr++; s->mtfFreq[BZ_RUNB]++; break;
+               };
+               if (zPend < 2) break;
+               zPend = (zPend - 2) / 2;
+            };
+            zPend = 0;
+         }
+         s->szptr[wr] = j+1; wr++; s->mtfFreq[j+1]++;
+      }
+   }
+
+   if (zPend > 0) {
+      zPend--;
+      while (True) {
+         switch (zPend % 2) {
+            case 0:  s->szptr[wr] = BZ_RUNA; wr++; s->mtfFreq[BZ_RUNA]++; break;
+            case 1:  s->szptr[wr] = BZ_RUNB; wr++; s->mtfFreq[BZ_RUNB]++; break;
+         };
+         if (zPend < 2) break;
+         zPend = (zPend - 2) / 2;
+      };
+   }
+
+   s->szptr[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];
+
+   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;
+
+      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) {
+            register UInt16 cost0, cost1, cost2, cost3, cost4, cost5;
+            cost0 = cost1 = cost2 = cost3 = cost4 = cost5 = 0;
+            for (i = gs; i <= ge; i++) { 
+               UInt16 icv = s->szptr[i];
+               cost0 += s->len[0][icv];
+               cost1 += s->len[1][icv];
+               cost2 += s->len[2][icv];
+               cost3 += s->len[3][icv];
+               cost4 += s->len[4][icv];
+               cost5 += s->len[5][icv];
+            }
+            cost[0] = cost0; cost[1] = cost1; cost[2] = cost2;
+            cost[3] = cost3; cost[4] = cost4; cost[5] = cost5;
+         } else {
+            for (i = gs; i <= ge; i++) { 
+               UInt16 icv = s->szptr[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.
+          --*/
+         for (i = gs; i <= ge; i++)
+            s->rfreq[bt][ s->szptr[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++)
+         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 );
+      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;
+      for (i = gs; i <= ge; i++) {
+         AssertH ( s->selector[selCtr] < nGroups, 3006 );
+         bsW ( s, 
+               s->len  [s->selector[selCtr]] [s->szptr[i]],
+               s->code [s->selector[selCtr]] [s->szptr[i]] );
+      }
+
+      gs = ge+1;
+      selCtr++;
+   }
+   AssertH( selCtr == nSelectors, 3007 );
+
+   if (s->verbosity >= 3)
+      VPrintf1( "codes %d\n", s->numZ-nBytes );
+}
+
+
+/*---------------------------------------------------*/
+void 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 );
+
+      blockSort ( s );
+   }
+
+   /*-- If this is the first block, create the stream header. --*/
+   if (s->blockNo == 1) {
+      bsInitWrite ( s );
+      bsPutUChar ( s, 'B' );
+      bsPutUChar ( s, 'Z' );
+      bsPutUChar ( s, 'h' );
+      bsPutUChar ( s, '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 randomisation. --*/
+      if (s->blockRandomised) {
+         bsW(s,1,1); s->nBlocksRandomised++;
+      } else
+         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) {
+
+      if (s->verbosity >= 2 && s->nBlocksRandomised > 0)
+         VPrintf2 ( "    %d block%s needed randomisation\n", 
+                    s->nBlocksRandomised,
+                    s->nBlocksRandomised == 1 ? "" : "s" );
+
+      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/crctable.c b/crctable.c
new file mode 100644
index 0000000..2f3eacb
--- /dev/null
+++ b/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-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
+
+  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 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/decompress.c b/decompress.c
new file mode 100644
index 0000000..ac2b0a5
--- /dev/null
+++ b/decompress.c
@@ -0,0 +1,636 @@
+
+/*-------------------------------------------------------------*/
+/*--- 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-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
+
+  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++;                        \
+   }
+
+#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++;                                  \
+      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 (zvec > gLimit[zn]) {                    \
+      zn++;                                       \
+      GET_BIT(label2, zj);                        \
+      zvec = (zvec << 1) | zj;                    \
+   };                                             \
+   lval = gPerm[zvec - gBase[zn]];                \
+}
+
+
+/*---------------------------------------------------*/
+Int32 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);
+
+      /*--- 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 );
+      alphaSize = s->nInUse+2;
+
+      /*--- Now the selectors ---*/
+      GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
+      GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
+      for (i = 0; i < nSelectors; i++) {
+         j = 0;
+         while (True) {
+            GET_BIT(BZ_X_SELECTOR_3, uc);
+            if (uc == 0) break;
+            j++;
+            if (j > 5) 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];
+         }
+         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) {
+                  s->ll16[nblock] = (UInt16)uc;
+                  nblock++;
+                  es--;
+               }
+            else
+               while (es > 0) {
+                  s->tt[nblock] = (UInt32)uc;
+                  nblock++;
+                  es--;
+               };
+
+            if (nblock > nblockMAX) RETURN(BZ_DATA_ERROR);
+            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;
+         }
+      }
+
+      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/dlltest.c b/dlltest.c
new file mode 100644
index 0000000..ee81bcd
--- /dev/null
+++ b/dlltest.c
@@ -0,0 +1,163 @@
+/*
+        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 "bzlib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <io.h>
+#endif
+
+
+#ifdef _WIN32
+
+#include <windows.h>
+static int BZ2DLLLoaded = 0;
+static HINSTANCE BZ2DLLhLib;
+int BZ2DLLLoadLibrary(void)
+{
+        HINSTANCE hLib;
+
+        if(BZ2DLLLoaded==1){return 0;}
+        hLib=LoadLibrary("libbz2.dll");
+        if(hLib == NULL){
+                puts("Can't load libbz2.dll");
+                return -1;
+        }
+        BZ2DLLLoaded=1;
+        BZ2DLLhLib=hLib;
+        bzlibVersion=GetProcAddress(hLib,"bzlibVersion");
+        bzopen=GetProcAddress(hLib,"bzopen");
+        bzdopen=GetProcAddress(hLib,"bzdopen");
+        bzread=GetProcAddress(hLib,"bzread");
+        bzwrite=GetProcAddress(hLib,"bzwrite");
+        bzflush=GetProcAddress(hLib,"bzflush");
+        bzclose=GetProcAddress(hLib,"bzclose");
+        bzerror=GetProcAddress(hLib,"bzerror");
+        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]");
+}
+
+void main(int argc,char *argv[])
+{
+        int decompress = 0;
+        int level = 9;
+        char *fn_r,*fn_w;
+
+#ifdef _WIN32
+        if(BZ2DLLLoadLibrary()<0){
+                puts("can't load dll");
+                exit(1);
+        }
+#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;
+                        FILE *fp_w;
+
+                        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 = bzdopen(fileno(stdin),"rb"))==NULL)
+                                || (BZ2fp_r != NULL && (BZ2fp_r = bzopen(fn_r,"rb"))==NULL)){
+                                printf("can't bz2openstream\n");
+                                exit(1);
+                        }
+                        while((len=bzread(BZ2fp_r,buff,0x1000))>0){
+                                fwrite(buff,1,len,fp_w);
+                        }
+                        bzclose(BZ2fp_r);
+                        if(fp_w != stdout) fclose(fp_w);
+                }else{
+                        BZFILE *BZ2fp_w;
+                        FILE *fp_r;
+
+                        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 = bzdopen(fileno(stdout),mode))==NULL)
+                                || (fn_w !=NULL && (BZ2fp_w = bzopen(fn_w,mode))==NULL)){
+                                printf("can't bz2openstream\n");
+                                exit(1);
+                        }
+                        while((len=fread(buff,1,0x1000,fp_r))>0){
+                                bzwrite(BZ2fp_w,buff,len);
+                        }
+                        bzclose(BZ2fp_w);
+                        if(fp_r!=stdin)fclose(fp_r);
+                }
+        }
+#ifdef _WIN32
+        BZ2DLLFreeLibrary();
+#endif
+}
diff --git a/dlltest.dsp b/dlltest.dsp
new file mode 100644
index 0000000..4b1615e
--- /dev/null
+++ b/dlltest.dsp
@@ -0,0 +1,93 @@
+# Microsoft Developer Studio Project File - Name="dlltest" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 5.00

+# ** •Ò�W‚µ‚È‚¢‚Å‚­‚¾‚³‚¢ **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=dlltest - Win32 Debug

+!MESSAGE ‚±‚ê‚Í—LŒø‚ÈÒ²¸Ì§²Ù‚Å‚Í‚ ‚è‚Ü‚¹‚ñ�B ‚±‚ÌÌßÛ¼Þª¸Ä‚ðËÞÙÄÞ‚·‚邽‚ß‚É‚Í NMAKE ‚ðŽg—p‚µ‚Ä‚­‚¾‚³‚¢�B

+!MESSAGE [Ò²¸Ì§²Ù‚Ì´¸½Îß°Ä] ºÏÝÄÞ‚ðŽg—p‚µ‚ÄŽÀ�s‚µ‚Ä‚­‚¾‚³‚¢

+!MESSAGE 

+!MESSAGE NMAKE /f "dlltest.mak".

+!MESSAGE 

+!MESSAGE NMAKE ‚ÌŽÀ�sŽž‚É�\�¬‚ðŽw’è‚Å‚«‚Ü‚·

+!MESSAGE ºÏÝÄÞ ×²Ý�ã‚ÅϸۂÌ�Ý’è‚ð’è‹`‚µ‚Ü‚·�B—á:

+!MESSAGE 

+!MESSAGE NMAKE /f "dlltest.mak" CFG="dlltest - Win32 Debug"

+!MESSAGE 

+!MESSAGE ‘I‘ð‰Â”\‚ÈËÞÙÄÞ Ó°ÄÞ:

+!MESSAGE 

+!MESSAGE "dlltest - Win32 Release" ("Win32 (x86) Console Application" —p)

+!MESSAGE "dlltest - Win32 Debug" ("Win32 (x86) Console Application" —p)

+!MESSAGE 

+

+# Begin Project

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "dlltest - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD BASE RSC /l 0x411 /d "NDEBUG"

+# ADD RSC /l 0x411 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"minibz2.exe"

+

+!ELSEIF  "$(CFG)" == "dlltest - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "dlltest_"

+# PROP BASE Intermediate_Dir "dlltest_"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "dlltest_"

+# PROP Intermediate_Dir "dlltest_"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD BASE RSC /l 0x411 /d "_DEBUG"

+# ADD RSC /l 0x411 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"minibz2.exe" /pdbtype:sept

+

+!ENDIF 

+

+# Begin Target

+

+# Name "dlltest - Win32 Release"

+# Name "dlltest - Win32 Debug"

+# Begin Source File

+

+SOURCE=.\bzlib.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\dlltest.c

+# End Source File

+# End Target

+# End Project

diff --git a/howbig.c b/howbig.c
new file mode 100644
index 0000000..9f2ad7c
--- /dev/null
+++ b/howbig.c
@@ -0,0 +1,37 @@
+
+#include <stdio.h>
+#include <assert.h>
+#include "bzlib.h"
+
+unsigned char ibuff[1000000];
+unsigned char obuff[1000000];
+
+void doone ( int n )
+{
+   int i, j, k, q, nobuff;
+   q = 0;
+
+   for (k = 0; k < 1; k++) {
+      for (i = 0; i < n; i++)
+         ibuff[i] = ((unsigned long)(random())) & 0xff;
+      nobuff = 1000000;
+      j = bzBuffToBuffCompress ( obuff, &nobuff, ibuff, n, 9,0,0 );
+      assert (j == BZ_OK);
+      if (nobuff > q) q = nobuff;
+   }
+   printf ( "%d %d(%d)\n", n, q, (int)((float)n * 1.01 - (float)q) );
+}
+
+int main ( int argc, char** argv )
+{
+   int i;
+   i = 0;
+   while (1) {
+     if (i >= 900000) break;
+     doone(i);
+     if (   (int)(1.10 * i) > i )
+        i = (int)(1.10 * i); else i++;
+   }
+
+   return 0;
+}
\ No newline at end of file
diff --git a/huffman.c b/huffman.c
new file mode 100644
index 0000000..8254990
--- /dev/null
+++ b/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-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
+
+  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 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 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 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/libbz2.def b/libbz2.def
new file mode 100644
index 0000000..ba0f54e
--- /dev/null
+++ b/libbz2.def
@@ -0,0 +1,25 @@
+LIBRARY                 LIBBZ2

+DESCRIPTION             "libbzip2: library for data compression"

+EXPORTS

+        bzCompressInit

+        bzCompress

+        bzCompressEnd

+        bzDecompressInit

+        bzDecompress

+        bzDecompressEnd

+        bzReadOpen

+        bzReadClose

+        bzReadGetUnused

+        bzRead

+        bzWriteOpen

+        bzWrite

+        bzWriteClose

+        bzBuffToBuffCompress

+        bzBuffToBuffDecompress

+        bzlibVersion

+        bzopen

+        bzdopen

+        bzread

+        bzwrite

+        bzflush

+        bzclose

diff --git a/libbz2.dsp b/libbz2.dsp
new file mode 100644
index 0000000..a21a20f
--- /dev/null
+++ b/libbz2.dsp
@@ -0,0 +1,130 @@
+# Microsoft Developer Studio Project File - Name="libbz2" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 5.00

+# ** •Ò�W‚µ‚È‚¢‚Å‚­‚¾‚³‚¢ **

+

+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102

+

+CFG=libbz2 - Win32 Debug

+!MESSAGE ‚±‚ê‚Í—LŒø‚ÈÒ²¸Ì§²Ù‚Å‚Í‚ ‚è‚Ü‚¹‚ñ�B ‚±‚ÌÌßÛ¼Þª¸Ä‚ðËÞÙÄÞ‚·‚邽‚ß‚É‚Í NMAKE ‚ðŽg—p‚µ‚Ä‚­‚¾‚³‚¢�B

+!MESSAGE [Ò²¸Ì§²Ù‚Ì´¸½Îß°Ä] ºÏÝÄÞ‚ðŽg—p‚µ‚ÄŽÀ�s‚µ‚Ä‚­‚¾‚³‚¢

+!MESSAGE 

+!MESSAGE NMAKE /f "libbz2.mak".

+!MESSAGE 

+!MESSAGE NMAKE ‚ÌŽÀ�sŽž‚É�\�¬‚ðŽw’è‚Å‚«‚Ü‚·

+!MESSAGE ºÏÝÄÞ ×²Ý�ã‚ÅϸۂÌ�Ý’è‚ð’è‹`‚µ‚Ü‚·�B—á:

+!MESSAGE 

+!MESSAGE NMAKE /f "libbz2.mak" CFG="libbz2 - Win32 Debug"

+!MESSAGE 

+!MESSAGE ‘I‘ð‰Â”\‚ÈËÞÙÄÞ Ó°ÄÞ:

+!MESSAGE 

+!MESSAGE "libbz2 - Win32 Release" ("Win32 (x86) Dynamic-Link Library" —p)

+!MESSAGE "libbz2 - Win32 Debug" ("Win32 (x86) Dynamic-Link Library" —p)

+!MESSAGE 

+

+# Begin Project

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+MTL=midl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "libbz2 - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c

+# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c

+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o NUL /win32

+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o NUL /win32

+# ADD BASE RSC /l 0x411 /d "NDEBUG"

+# ADD RSC /l 0x411 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 /out:"libbz2.dll"

+

+!ELSEIF  "$(CFG)" == "libbz2 - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "Debug"

+# PROP Intermediate_Dir "Debug"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c

+# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c

+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o NUL /win32

+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o NUL /win32

+# ADD BASE RSC /l 0x411 /d "_DEBUG"

+# ADD RSC /l 0x411 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /out:"libbz2.dll" /pdbtype:sept

+

+!ENDIF 

+

+# Begin Target

+

+# Name "libbz2 - Win32 Release"

+# Name "libbz2 - Win32 Debug"

+# Begin Source File

+

+SOURCE=.\blocksort.c

+# End Source File

+# Begin Source File

+

+SOURCE=.\bzlib.c

+# End Source File

+# Begin Source File

+

+SOURCE=.\bzlib.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\bzlib_private.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\compress.c

+# End Source File

+# Begin Source File

+

+SOURCE=.\crctable.c

+# End Source File

+# Begin Source File

+

+SOURCE=.\decompress.c

+# End Source File

+# Begin Source File

+

+SOURCE=.\huffman.c

+# End Source File

+# Begin Source File

+

+SOURCE=.\libbz2.def

+# End Source File

+# Begin Source File

+

+SOURCE=.\randtable.c

+# End Source File

+# End Target

+# End Project

diff --git a/manual.texi b/manual.texi
new file mode 100644
index 0000000..99ce661
--- /dev/null
+++ b/manual.texi
@@ -0,0 +1,2100 @@
+\input texinfo  @c                                  -*- Texinfo -*-
+@setfilename bzip2.info
+
+@ignore
+This file documents bzip2 version 0.9.0c, and associated library
+libbzip2, written by Julian Seward (jseward@acm.org).
+
+Copyright (C) 1996-1998 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-1998 Julian Seward
+@subtitle version 0.9.0c of 18 October 1998
+@author Julian Seward
+
+@end titlepage
+@end iftex
+
+
+@parindent 0mm
+@parskip 2mm
+
+
+This program, @code{bzip2}, 
+and associated library @code{libbzip2}, are
+Copyright (C) 1996-1998 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, Guildford, Surrey, UK.
+
+@code{jseward@@acm.org}
+
+@code{http://www.muraroa.demon.co.uk}
+
+@code{bzip2}/@code{libbzip2} version 0.9.0c of 18 October 1998.
+
+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.
+@example
+NAME
+       bzip2, bunzip2 - a block-sorting file compressor, v0.9.0
+       bzcat - decompresses files to stdout
+       bzip2recover - recovers data from damaged bzip2 files
+
+
+SYNOPSIS
+       bzip2 [ -cdfkstvzVL123456789 ] [ filenames ...  ]
+       bunzip2 [ -fkvsVL ] [ filenames ...  ]
+       bzcat [ -s ] [ filenames ...  ]
+       bzip2recover filename
+
+
+DESCRIPTION
+       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 sta-
+       tistical compressors.
+
+       The command-line options are deliberately very similar  to
+       those of GNU Gzip, but they are not identical.
+
+       bzip2  expects  a list of file names to accompany the com-
+       mand-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  and
+       permissions  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,  per-
+       missions  and  dates  in filesystems which lack these con-
+       cepts, or have serious file name length restrictions, such
+       as MS-DOS.
+
+       bzip2  and  bunzip2 will by default not overwrite existing
+       files; if you want this to happen, specify the -f flag.
+
+       If no file names  are  specified,  bzip2  compresses  from
+       standard  input  to  standard output.  In this case, bzip2
+       will decline to write compressed output to a terminal,  as
+       this  would  be  entirely  incomprehensible  and therefore
+       pointless.
+
+       bunzip2 (or bzip2 -d ) decompresses and restores all spec-
+       ified files whose names end in ".bz2".  Files without this
+       suffix are ignored.  Again, supplying no filenames  causes
+       decompression from standard input to standard output.
+
+       bunzip2 will correctly decompress a file which is the con-
+       catenation 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  com-
+       pressed and decompressed like this.  The resulting outputs
+       are fed sequentially to stdout.  Compression  of  multiple
+       files  in this manner generates a stream containing multi-
+       ple compressed file representations.  Such a stream can be
+       decompressed  correctly  only  by  bzip2  version 0.9.0 or
+       later.  Earlier versions of bzip2 will stop  after  decom-
+       pressing the first file in the stream.
+
+       bzcat  (or bzip2 -dc ) decompresses all specified files to
+       the standard output.
+
+       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,  bzip2  uses  32-bit
+       CRCs  to make sure that the decompressed version of a file
+       is identical to the original.  This guards against corrup-
+       tion  of  the compressed data, and against undetected bugs
+       in 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 that something is wrong.  It  can't
+       help  you recover the original uncompressed data.  You can
+       use 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 bzip2 to panic.
+
+
+MEMORY MANAGEMENT
+       Bzip2 compresses large files in blocks.   The  block  size
+       affects  both  the  compression  ratio  achieved,  and the
+       amount of memory needed both for  compression  and  decom-
+       pression.   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 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 + ( 7 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  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,
+       bunzip2  will require about 3700 kbytes to decompress.  To
+       support decompression of any file on a 4 megabyte machine,
+       bunzip2  has  an  option to decompress using approximately
+       half this amount of memory, about 2300 kbytes.  Decompres-
+       sion  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 con-
+       straints  allow,  since  that  maximises  the  compression
+       achieved.  Compression and decompression speed are  virtu-
+       ally 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 6700k of memory, but only
+       touch 400k + 20000 * 7 = 540 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  Compres-
+       sion  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  domi-
+       nated by smaller files.
+
+                  Compress   Decompress   Decompress   Corpus
+           Flag     usage      usage       -s usage     Size
+
+            -1      1100k       500k         350k      914704
+            -2      1800k       900k         600k      877703
+            -3      2500k      1300k         850k      860338
+            -4      3200k      1700k        1100k      846899
+            -5      3900k      2100k        1350k      845160
+            -6      4600k      2500k        1600k      838626
+            -7      5400k      2900k        1850k      834096
+            -8      6000k      3300k        2100k      828642
+            -9      6700k      3700k        2350k      828642
+
+
+OPTIONS
+       -c --stdout
+              Compress or decompress to standard output.  -c will
+              decompress multiple files to stdout, but will  only
+              compress a single file to stdout.
+
+       -d --decompress
+              Force  decompression.  bzip2, bunzip2 and 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.
+
+       -z --compress
+              The  complement  to -d: forces compression, regard-
+              less of the invokation name.
+
+       -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.
+
+       -f --force
+              Force overwrite of output files.   Normally,  bzip2
+              will not overwrite existing output files.
+
+       -k --keep
+              Keep  (don't delete) input files during compression
+              or decompression.
+
+       -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 above.
+
+       -v --verbose
+              Verbose mode -- show the compression ratio for each
+              file  processed.   Further  -v's  increase the ver-
+              bosity level, spewing out lots of information which
+              is primarily of interest for diagnostic purposes.
+
+       -L --license -V --version
+              Display  the  software  version,  license terms and
+              conditions.
+
+       -1 to -9
+              Set the block size to 100 k, 200 k ..  900  k  when
+              compressing.   Has  no  effect  when decompressing.
+              See MEMORY MANAGEMENT above.
+
+       --repetitive-fast
+              bzip2 injects some small  pseudo-random  variations
+              into  very  repetitive  blocks  to limit worst-case
+              performance during compression.   If  sorting  runs
+              into  difficulties,  the  block  is randomised, and
+              sorting is restarted.  Very roughly, bzip2 persists
+              for  three  times  as  long as a well-behaved input
+              would take before resorting to randomisation.  This
+              flag makes it give up much sooner.
+
+       --repetitive-best
+              Opposite  of  --repetitive-fast;  try  a lot harder
+              before resorting to randomisation.
+
+
+RECOVERING DATA FROM DAMAGED FILES
+       bzip2 compresses files in blocks, usually 900kbytes  long.
+       Each block is handled independently.  If a media or trans-
+       mission 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.
+
+       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 bzip2 -t to test
+       the integrity of the resulting files, and decompress those
+       which are undamaged.
+
+       bzip2recover takes a single argument, the name of the dam-
+       aged 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 "right" order.
+
+       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 min-
+       imise any potential data loss through media  or  transmis-
+       sion errors, you might consider compressing with a smaller
+       block size.
+
+
+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
+       extraordinarily slowly.  You can use the -vvvvv option  to
+       monitor progress in great detail, if you want.  Decompres-
+       sion speed is unaffected.
+
+       Such pathological cases seem rare in  practice,  appearing
+       mostly in artificially-constructed test files, and in low-
+       level disk images.  It may be inadvisable to use bzip2  to
+       compress  the  latter.   If you do get a file which causes
+       severe slowness in compression, try making the block  size
+       as small as possible, with flag -1.
+
+       bzip2  usually  allocates  several  megabytes of memory to
+       operate in, and then charges all over it in a fairly  ran-
+       dom  fashion.   This means that performance, both for com-
+       pressing 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 bzip2 will per-
+       form best on machines with very large caches.
+
+
+CAVEATS
+       I/O  error  messages  are not as helpful as they could be.
+       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 0.9.0 of bzip2.  Com-
+       pressed  data created by this version is entirely forwards
+       and backwards compatible with the previous public release,
+       version  0.1pl2,  but  with the following exception: 0.9.0
+       can correctly decompress multiple concatenated  compressed
+       files.   0.1pl2  cannot do this; it will stop after decom-
+       pressing just the first file in the stream.
+
+       Wildcard expansion for Windows 95 and NT is flaky.
+
+       bzip2recover uses 32-bit integers to represent  bit  posi-
+       tions  in compressed files, so it cannot handle compressed
+       files more than 512 megabytes long.  This could easily  be
+       fixed.
+
+
+AUTHOR
+       Julian Seward, jseward@@acm.org.
+
+       The ideas embodied in bzip2 are due to (at least) the fol-
+       lowing people: Michael Burrows and David Wheeler (for  the
+       block  sorting  transformation), David Wheeler (again, for
+       the Huffman coder), Peter Fenwick (for the structured cod-
+       ing model in the original bzip, and many refinements), and
+       Alistair Moffat, Radford Neal  and  Ian  Witten  (for  the
+       arithmetic  coder  in  the  original  bzip).   I  am  much
+       indebted for their help, support and advice.  See the man-
+       ual  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 compres-
+       sion.  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 example
+
+
+
+
+
+@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.
+
+@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{bzCompressInit}, @code{bzCompress}, and @* @code{bzCompressEnd}
+for compression,
+and a corresponding trio @code{bzDecompressInit}, @* @code{bzDecompress}
+and @code{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{bzCompress} and @code{bzDecompress}.  
+These compress/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{bzReadOpen}, @code{bzRead}, @code{bzReadClose}
+and @code{bzReadGetUnused} are supplied.  For writing files,
+@code{bzWriteOpen}, @code{bzWrite} and @code{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{bzReadOpen} and @code{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{bzBuffToBuffCompress} and
+@code{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{bzopen}, @code{bzread}, @code{bzwrite}, @code{bzflush},
+@code{bzclose},
+@code{bzerror} and @code{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 not further 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.
+
+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{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_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{bzDecompress} and
+@code{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{bzCompressInit} or @code{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{bzRead} and @code{bzRead} when there is an error
+reading or writing in the compressed file, and by @code{bzReadOpen}
+and @code{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{bzRead} when the compressed file finishes
+before the logical end of stream is detected.
+@item BZ_OUTBUFF_FULL
+Returned by @code{bzBuffToBuffCompress} and
+@code{bzBuffToBuffDecompress} to indicate that the output data
+will not fit into the output buffer provided.
+@end table
+
+
+
+@section Low-level interface
+
+@subsection @code{bzCompressInit}
+@example
+typedef 
+   struct @{
+      char *next_in;
+      unsigned int avail_in;
+      unsigned int total_in;
+
+      char *next_out;
+      unsigned int avail_out;
+      unsigned int total_out;
+
+      void *state;
+
+      void *(*bzalloc)(void *,int,int);
+      void (*bzfree)(void *,void *);
+      void *opaque;
+   @} 
+   bz_stream;
+
+int 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{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} and 
+@code{total_out} will have been set to zero.  
+These last two 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.
+
+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,
+some pseudo-random variations are inserted into the block, and
+compression is restarted.  Lower values of @code{workFactor}
+reduce the tolerance of compression to repetitive data.
+You should set this parameter carefully; too low, and 
+compression ratio suffers, 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 randomisation process is entirely transparent.  
+If the library decides to randomise and restart compression on a
+block, it does so without comment.  Randomised blocks are
+automatically de-randomised during decompression, so data
+integrity is never compromised.
+
+Possible return values:
+@display
+      @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{bzCompress} 
+         if @code{BZ_OK} is returned
+      no specific action needed in case of error
+@end display
+
+@subsection @code{bzCompress}
+@example
+   int 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{bzCompress} to
+transfer data between them.
+
+Before each call to @code{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{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{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{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{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{bzCompressInit}) and after termination (@code{bzCompressEnd}), a
+stream is regarded as IDLE.
+
+Upon initialisation (@code{bzCompressInit}), the stream is placed in the
+RUNNING state.  Subsequent calls to @code{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{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{bzCompress}.
+
+Instead, the calling program passes @code{BZ_FINISH} as an action to
+@code{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{bzCompress} must be
+called repeatedly until all the output has been consumed.  At that
+point, @code{bzCompress} returns @code{BZ_STREAM_END}, and the stream's
+state is set back to IDLE.  @code{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{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{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{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{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{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{bzCompress}.
+@display
+IDLE/@code{any}           
+      Illegal.  IDLE state only exists after @code{bzCompressEnd} or
+      before @code{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{bzCompressInit}.
+@item Shovel data in and shlurp out its compressed form using zero or more
+calls of @code{bzCompress} with action = @code{BZ_RUN}.
+@item Finish up.  
+Repeatedly call @code{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{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{bzCompress ( ..., BZ_RUN )} and 
+just do the @code{bzCompress ( ..., BZ_FINISH )} calls.
+
+All required memory is allocated by @code{bzCompressInit}.  The
+compression library can accept any data at all (obviously).  So you
+shouldn't get any error return values from the @code{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{bzCompressEnd}
+@example
+int 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{bzDecompressInit}
+@example
+int bzDecompressInit ( bz_stream *strm, int verbosity, int small );
+@end example
+Prepares for decompression.  As with @code{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{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{bzDecompressInit} succeeds, a subsequent
+@code{bzDecompress} could fail with @code{BZ_MEM_ERROR}.
+
+Possible return values:
+@display
+      @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{bzDecompress}
+         if @code{BZ_OK} was returned
+      no specific action required in case of error
+@end display
+
+ 
+
+@subsection @code{bzDecompress}
+@example
+int 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{bzDecompress}
+to transfer data between them.
+
+Before each call to @code{bzDecompress}, @code{next_in} 
+should point at the compressed data,
+and @code{avail_in} should indicate how many bytes the library
+may read.  @code{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{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{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{bzDecompress} is simpler than @code{bzCompress}.
+
+You should provide input and remove output as described above, and
+repeatedly call @code{bzDecompress} until @code{BZ_STREAM_END} is
+returned.  Appearance of @code{BZ_STREAM_END} denotes that
+@code{bzDecompress} has detected the logical end of the compressed
+stream.  @code{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{bzDecompressEnd} can safely be
+called.
+
+If case of an error return value, you should call @code{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{bzDecompress}
+         if @code{BZ_OK} was returned
+      @code{bzDecompressEnd}
+         otherwise
+@end display
+
+
+@subsection @code{bzDecompressEnd}
+@example
+int 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{bzReadClose} (or @code{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{bzReadClose} (@code{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{bzReadClose} (@code{bzWriteClose}) should then be called to clean up.
+@item The @code{FILE*} arguments passed to
+   @code{bzReadOpen}/@code{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{bzReadOpen}
+@example
+   typedef void BZFILE;
+
+   BZFILE *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{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{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{bzReadOpen} returns @code{BZ_OK} but a subsequent call of
+@code{bzRead} will return @code{BZ_MEM_ERROR}.
+
+Possible assignments to @code{bzerror}:
+@display
+      @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{bzRead}
+         if @code{bzerror} is @code{BZ_OK}   
+      @code{bzClose} 
+         otherwise
+@end display
+
+
+@subsection @code{bzRead}
+@example
+   int 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{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{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{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{bzReadGetUnused} immediately before @code{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{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{bzRead} or @code{bzReadClose}
+         if @code{bzerror} is @code{BZ_OK} 
+      collect data from @code{buf}, then @code{bzReadClose} or @code{bzReadGetUnused} 
+         if @code{bzerror} is @code{BZ_SEQUENCE_END}   
+      @code{bzReadClose} 
+         otherwise
+@end display
+
+
+
+@subsection @code{bzReadGetUnused}
+@example
+   void 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{bzRead} has signalled 
+@code{BZ_STREAM_END} but before @code{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{bzWriteOpen}
+     @code{BZ_OK}
+         otherwise
+@end display
+
+Allowable next actions:
+@display 
+      @code{bzReadClose}
+@end display
+
+
+@subsection @code{bzReadClose}
+@example
+   void bzReadClose ( int *bzerror, BZFILE *b );
+@end example
+Releases all memory pertaining to the compressed file @code{b}.  
+@code{bzReadClose} does not call @code{fclose} on the underlying file
+handle, so you should do that yourself if appropriate.
+@code{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{bzOpenWrite} 
+      @code{BZ_OK} 
+         otherwise
+@end display
+
+Allowable next actions:
+@display
+      none
+@end display
+
+
+
+@subsection @code{bzWriteOpen}
+@example
+   BZFILE *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{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{bzWrite}.
+
+Possible assignments to @code{bzerror}:
+@display 
+      @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{bzWrite} 
+         if @code{bzerror} is @code{BZ_OK} 
+         (you could go directly to @code{bzWriteClose}, but this would be pretty pointless)
+      @code{bzWriteClose} 
+         otherwise
+@end display
+
+
+
+@subsection @code{bzWrite}
+@example
+   void 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{bzReadOpen}
+      @code{BZ_IO_ERROR} 
+         if there is an error writing the compressed file.
+      @code{BZ_OK} 
+         otherwise
+@end display
+
+
+
+
+@subsection @code{bzWriteClose}
+@example
+   int bzWriteClose ( int *bzerror, BZFILE* f,
+                      int abandon,
+                      unsigned int* nbytes_in,
+                      unsigned int* nbytes_out );
+@end example
+
+Compresses and flushes to the compressed file all data so far supplied
+by @code{bzWrite}.  The logical end-of-stream markers are also written, so
+subsequent calls to @code{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{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.
+
+Possible assignments to @code{bzerror}:
+@display
+      @code{BZ_SEQUENCE_ERROR} 
+         if @code{b} was opened with @code{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{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{bzReadGetUnused} after the last call of @code{bzRead}
+(the one returning @code{BZ_STREAM_END}) but before calling
+@code{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{bzRead}
+returns @code{BZ_STREAM_END}, call @code{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{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{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 = bzWriteOpen ( &bzerror, f, 9 );
+if (bzerror != BZ_OK) @{
+   bzWriteClose ( b );
+   /* handle error */
+@}
+
+while ( /* condition */ ) @{
+   /* get data to write into buf, and set nBuf appropriately */
+   nWritten = bzWrite ( &bzerror, b, buf, nBuf );
+   if (bzerror == BZ_IO_ERROR) @{ 
+      bzWriteClose ( &bzerror, b );
+      /* handle error */
+   @}
+@}
+
+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 = bzReadOpen ( &bzerror, f, 0, NULL, 0 );
+if (bzerror != BZ_OK) @{
+   bzReadClose ( &bzerror, b );
+   /* handle error */
+@}
+
+bzerror = BZ_OK;
+while (bzerror == BZ_OK && /* arbitrary other conditions */) @{
+   nBuf = bzRead ( &bzerror, b, buf, /* size of buf */ );
+   if (bzerror == BZ_OK) @{
+      /* do something with buf[0 .. nBuf-1] */
+   @}
+@}
+if (bzerror != BZ_STREAM_END) @{
+   bzReadClose ( &bzerror, b );
+   /* handle error */
+@} else @{
+   bzReadClose ( &bzerror );
+@}
+@end example
+
+
+
+@section Utility functions
+@subsection @code{bzBuffToBuffCompress}
+@example
+   int 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{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{bzBuffToBuffDecompress} will not write data at or
+beyond @code{dest[*destLen]}, even in case of buffer overflow.
+
+Possible return values:
+@display
+      @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{bzBuffToBuffDecompress}
+@example
+   int 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{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{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{bzBuffToBuffDecompress} will not write data at or
+beyond @code{dest[*destLen]}, even in case of buffer overflow.
+
+Possible return values:
+@display
+      @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 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{bzCompressInit}, @code{bzCompress}, @code{bzCompressEnd} @*
+@code{bzDecompressInit}, @code{bzDecompress}, @code{bzDecompressEnd} @*
+@code{bzBuffToBuffCompress}, @code{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, v0.9.0: internal error number N.
+   This is a bug in bzip2/libbzip2, v0.9.0.  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.  Thx.  Julian Seward, 27 June 1998.
+@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 might 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}.
+
+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-0.9.0} uses 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
+      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.
+      This can be done without much difficulty; I made
+      a prototype implementation of it some months now.
+@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 have been 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! I'm embarrassed at my own moronicness (moronicity?) on this
+      one.
+
+@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.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 your compiler doesn't
+like them, just @code{#define} @code{__inline__} to be null.  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.
+
+
+@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 four 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 a 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.  445 megabytes.
+@item A: directory tree holding various applications built from source:
+      @code{egcs-1.0.2}, @code{gcc-2.8.1}, KDE Beta 4, GTK, Octave, etc.
+      827 megabytes.
+@item P: directory tree holding large amounts of source code (@code{.tar} 
+      files) of the entire GNU distribution, plus a couple of
+      Linux distributions.  2400 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, internal buffer
+sizes and randomisation lengths set very small, 
+to detect any problems with the
+blocking, buffering and randomisation 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 (first 1700 files).
+@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 normal buffer sizes (5000 bytes), normal block
+      size (up to 900000 bytes), but with randomisation
+      mechanism running intensely (randomising approximately every
+      third byte).
+@item As (9) with small-mode decompression.
+@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.0} decompressing, all settings normal.
+@item Backwards compatibility:  H, @code{bzip2-0.9.0} compressing,
+      @code{bzip2-0.1pl2} decompressing, all settings normal.
+@item Bigger tests: A, all settings normal.
+@item P, all settings normal.
+@item Misc test: about 100 megabytes of @code{.tar} files with
+      @code{bzip2} compiled with 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 205 MHz Cyrix 6x86MX machine, running
+Linux 2.0.32.  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/pub/user/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
+
+
+
+@contents
+
+@bye
+
diff --git a/randtable.c b/randtable.c
new file mode 100644
index 0000000..27b34af
--- /dev/null
+++ b/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-1998 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, Guildford, Surrey, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 0.9.0c of 18 October 1998
+
+  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 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/test.bat b/test.bat
deleted file mode 100644
index 30b747d..0000000
--- a/test.bat
+++ /dev/null
@@ -1,9 +0,0 @@
-@rem

-@rem MSDOS test driver for bzip2

-@rem

-type words1

-.\bzip2 -1 < sample1.ref > sample1.rbz

-.\bzip2 -2 < sample2.ref > sample2.rbz

-.\bzip2 -dvv < sample1.bz2 > sample1.tst

-.\bzip2 -dvv < sample2.bz2 > sample2.tst

-type words3sh
\ No newline at end of file
diff --git a/test.cmd b/test.cmd
deleted file mode 100644
index f7bc866..0000000
--- a/test.cmd
+++ /dev/null
@@ -1,9 +0,0 @@
-@rem

-@rem OS/2 test driver for bzip2

-@rem

-type words1

-.\bzip2 -1 < sample1.ref > sample1.rbz

-.\bzip2 -2 < sample2.ref > sample2.rbz

-.\bzip2 -dvv < sample1.bz2 > sample1.tst

-.\bzip2 -dvv < sample2.bz2 > sample2.tst

-type words3sh
\ No newline at end of file
diff --git a/words0 b/words0
deleted file mode 100644
index 527fb43..0000000
--- a/words0
+++ /dev/null
@@ -1,7 +0,0 @@
-***-------------------------------------------------***
-***--------- IMPORTANT: READ WHAT FOLLOWS! ---------***
-***---------     viz: pay attention :-)    ---------***
-***-------------------------------------------------***
-
-Compiling bzip2 ...
-
diff --git a/words1 b/words1
index c75293b..a891431 100644
--- a/words1
+++ b/words1
@@ -1,5 +1,4 @@
 
-
 Doing 4 tests (2 compress, 2 uncompress) ...
 If there's a problem, things might stop at this point.
  
diff --git a/words2 b/words2
index d3cafb9..203ee39 100644
--- a/words2
+++ b/words2
@@ -1,5 +1,4 @@
 
-
 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/words3 b/words3
index 5739d18..10bb2e9 100644
--- a/words3
+++ b/words3
@@ -1,23 +1,20 @@
 
-
 If you got this far and the "cmp"s didn't find anything amiss, looks
-like you're in business.  You should install bzip2 and bunzip2:
+like you're in business.  You should install bzip2, bunzip2 and bzcat:
 
-   copy bzip2 to a public place, maybe /usr/bin.
-   In that public place, make bunzip2 a symbolic link
-      to the bzip2 you just copied there.
+   Copy bzip2 and bzip2recover to a public place, maybe /usr/bin.
+   In that public place, make bunzip2 and bzcat be
+      symbolic links to the bzip2 you just copied there.
    Put the manual page, bzip2.1, somewhere appropriate;
       perhaps in /usr/man/man1.
 
-Complete instructions for use are in the preformatted
-manual page, in the file bzip2.1.preformatted.
+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.
 
-Please read the README file carefully.  
-Finally, note that bzip2 comes with ABSOLUTELY NO WARRANTY.
-
-Happy compressing!
+Happy compressing.  -- JRS, 30 August 1998.
 
diff --git a/words3sh b/words3sh
deleted file mode 100644
index 1139177..0000000
--- a/words3sh
+++ /dev/null
@@ -1,12 +0,0 @@
-If you got this far and the "bzip2 -dvv"s give identical

-stored vs computed CRCs, you're probably in business.

-Complete instructions for use are in the preformatted manual page, 

-in the file bzip2.txt.

-

-You can also do "bzip2 --help" to see some helpful information. 

-"bzip2 -L" displays the software license.

-

-Please read the README file carefully.  

-Finally, note that bzip2 comes with ABSOLUTELY NO WARRANTY.

-

-Happy compressing!
\ No newline at end of file