Initial support for for bunzip2....

This code could be improvemed by 1) supporting more options, 2) Creating a shared crc table with gunzip, or perhaps generated on the fly. 3) Removing any remaining unneccessary code (e.g. if (noisy))
author: Glenn L McGrath 2001-10-05 03:48:57 +0000
committer: Glenn L McGrath 2001-10-05 03:48:57 +0000
commit: 24e2833cdfcba3505bbde9b56906bbcbb67aa2be (patch)
tree: 9555ce149062ec16167d77aa6a5d7a55850c511d
parent: 2e772edacf70e9ff45a00a34af4c94e04d490fc2 (diff)
download: busybox-24e2833cdfcba3505bbde9b56906bbcbb67aa2be.zip
busybox-24e2833cdfcba3505bbde9b56906bbcbb67aa2be.tar.gz
8 files changed, 4705 insertions, 0 deletions
diff --git a/Config.h b/Config.h
index 95eb3de..36c897a 100644
--- a/Config.h
+++ b/Config.h
@@ -13,6 +13,7 @@
 //#define BB_AR
 //#define BB_ASH
 #define BB_BASENAME
+//#define BB_BUNZIP2
 #define BB_CAT
 #define BB_CHGRP
 #define BB_CHMOD
diff --git a/applets.h b/applets.h
index ab8727b..461c878 100644
--- a/applets.h
+++ b/applets.h
@@ -64,6 +64,9 @@
 #ifdef BB_BASENAME
 	APPLET(basename, basename_main, _BB_DIR_USR_BIN)
 #endif
+#ifdef BB_BUNZIP2
+	APPLET(bunzip2, bunzip2_main, _BB_DIR_USR_BIN)
+#endif
 	APPLET_NOUSAGE("busybox", busybox_main, _BB_DIR_BIN)
 #ifdef BB_CAT
 	APPLET(cat, cat_main, _BB_DIR_BIN)
diff --git a/applets/usage.h b/applets/usage.h
index f504ac1..0b095a4 100644
--- a/applets/usage.h
+++ b/applets/usage.h
@@ -51,6 +51,12 @@
 	"$ basename /foo/bar.txt .txt\n" \
 	"bar"
 
+#define bunzip2_trivial_usage \
+	"FILE"
+#define bunzip2_full_usage \
+	"Uncompress FILE to current directory, stripping its .bz2 extension.\n"\
+	" -k is assumed" 
+
 #define cat_trivial_usage \
 	"[FILE]..."
 #define cat_full_usage \
diff --git a/archival/bunzip2.c b/archival/bunzip2.c
new file mode 100644
index 0000000..757654d
--- /dev/null
+++ b/archival/bunzip2.c
@@ -0,0 +1,2340 @@
+/* Modified for busybox by Glenn McGrath <bug1@optushome.com.au> */
+/*--
+  This file is a part of bzip2 and/or libbzip2, a program and
+  library for lossless, block-sorting data compression.
+
+  Copyright (C) 1996-2000 Julian R Seward.  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+  2. The origin of this software must not be misrepresented; you must 
+     not claim that you wrote the original software.  If you use this 
+     software in a product, an acknowledgment in the product 
+     documentation would be appreciated but is not required.
+
+  3. Altered source versions must be plainly marked as such, and must
+     not be misrepresented as being the original software.
+
+  4. The name of the author may not be used to endorse or promote 
+     products derived from this software without specific prior written 
+     permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  Julian Seward, Cambridge, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 1.0 of 21 March 2000
+
+  This program is based on (at least) the work of:
+     Mike Burrows
+     David Wheeler
+     Peter Fenwick
+     Alistair Moffat
+     Radford Neal
+     Ian H. Witten
+     Robert Sedgewick
+     Jon L. Bentley
+
+  For more information on these sources, see the manual.
+--*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <busybox.h>
+
+//#define TRUE 1
+//#define FALSE 0
+
+#define MTFA_SIZE 4096
+#define MTFL_SIZE 16
+#define BZ_N_GROUPS 6
+#define BZ_G_SIZE   50
+#define BZ_MAX_ALPHA_SIZE 258
+
+#define BZ_OK                0
+#define BZ_RUN_OK            1
+#define BZ_FLUSH_OK          2
+#define BZ_FINISH_OK         3
+#define BZ_STREAM_END        4
+#define BZ_SEQUENCE_ERROR    (-1)
+#define BZ_PARAM_ERROR       (-2)
+#define BZ_MEM_ERROR         (-3)
+#define BZ_DATA_ERROR        (-4)
+#define BZ_DATA_ERROR_MAGIC  (-5)
+#define BZ_IO_ERROR          (-6)
+#define BZ_UNEXPECTED_EOF    (-7)
+#define BZ_OUTBUFF_FULL      (-8)
+#define BZ_CONFIG_ERROR      (-9)
+
+#define BZ_RUNA 0
+#define BZ_RUNB 1
+
+#define BZ_MAX_UNUSED 5000
+#define FILE_NAME_LEN 1034
+/*-- 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
+
+#define BZ_MAX_CODE_LEN    23
+#define BZ_VERSION  "1.0.1, 23-June-2000"
+#define OM_TEST          3
+#define SM_F2F 3
+
+typedef struct {
+	char *next_in;
+	unsigned int avail_in;
+	unsigned int total_in_lo32;
+	unsigned int total_in_hi32;
+
+	char *next_out;
+	unsigned int avail_out;
+	unsigned int total_out_lo32;
+	unsigned int total_out_hi32;
+
+	void *state;
+
+	void *(*bzalloc)(void *,int,int);
+	void (*bzfree)(void *,void *);
+	void *opaque;
+} bz_stream;
+
+typedef struct {
+	bz_stream	strm;
+	FILE	*handle;
+    unsigned char	initialisedOk;
+	unsigned char	writing;
+	char	buf[BZ_MAX_UNUSED];
+	int		lastErr;
+	int		bufN;
+} bzFile;
+
+/*-- Structure holding all the decompression-side stuff. --*/
+typedef struct {
+	/* pointer back to the struct bz_stream */
+	bz_stream* strm;
+
+	/* state indicator for this stream */
+	int	state;
+
+	/* for doing the final run-length decoding */
+	unsigned char    state_out_ch;
+	int    state_out_len;
+	unsigned char     blockRandomised;
+	int rNToGo;
+	int rTPos;
+
+	/* the buffer for bit stream reading */
+	unsigned int   bsBuff;
+	int    bsLive;
+
+	/* misc administratium */
+	int    blockSize100k;
+	unsigned char     smallDecompress;
+	int    currBlockNo;
+	int    verbosity;
+
+	/* for undoing the Burrows-Wheeler transform */
+	int    origPtr;
+	unsigned int   tPos;
+	int    k0;
+	int    unzftab[256];
+	int    nblock_used;
+	int    cftab[257];
+	int    cftabCopy[257];
+
+	/* for undoing the Burrows-Wheeler transform (FAST) */
+	unsigned int *tt;
+
+	/* for undoing the Burrows-Wheeler transform (SMALL) */
+	unsigned short *ll16;
+	unsigned char *ll4;
+
+	/* stored and calculated CRCs */
+	unsigned int   storedBlockCRC;
+	unsigned int   storedCombinedCRC;
+	unsigned int   calculatedBlockCRC;
+	unsigned int   calculatedCombinedCRC;
+
+	/* map of bytes used in block */
+	int    nInUse;
+	unsigned char     inUse[256];
+	unsigned char     inUse16[16];
+	unsigned char    seqToUnseq[256];
+
+	/* for decoding the MTF values */
+	unsigned char    mtfa   [MTFA_SIZE];
+	unsigned char    selector   [2 + (900000 / BZ_G_SIZE)];
+	unsigned char    selectorMtf[2 + (900000 / BZ_G_SIZE)];
+	unsigned char    len  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    mtfbase[256 / MTFL_SIZE];
+
+	int    limit  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    base   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    perm   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    minLens[BZ_N_GROUPS];
+
+	/* save area for scalars in the main decompress code */
+	int    save_i;
+	int    save_j;
+	int    save_t;
+	int    save_alphaSize;
+	int    save_nGroups;
+	int    save_nSelectors;
+	int    save_EOB;
+	int    save_groupNo;
+	int    save_groupPos;
+	int    save_nextSym;
+	int    save_nblockMAX;
+	int    save_nblock;
+	int    save_es;
+	int    save_N;
+	int    save_curr;
+	int    save_zt;
+	int    save_zn; 
+	int    save_zvec;
+	int    save_zj;
+	int    save_gSel;
+	int    save_gMinlen;
+	int	*save_gLimit;
+	int	*save_gBase;
+	int	*save_gPerm;
+} DState;
+
+int BZ2_rNums[512];
+//int	verbosity_level;
+unsigned char smallMode;
+unsigned char noisy;
+char *progName;
+char inName[FILE_NAME_LEN];
+char outName[FILE_NAME_LEN];
+int srcMode;
+int opMode;
+unsigned char deleteOutputOnInterrupt;
+FILE *outputHandleJustInCase;
+int numFileNames;
+int numFilesProcessed;
+int exitValue;
+
+unsigned int BZ2_crc32Table[256] = {
+
+   /*-- Ugly, innit? --*/
+
+   0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
+   0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
+   0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
+   0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
+   0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
+   0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
+   0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
+   0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
+   0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
+   0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
+   0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
+   0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
+   0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
+   0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
+   0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
+   0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
+   0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
+   0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
+   0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
+   0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
+   0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
+   0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
+   0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
+   0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
+   0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
+   0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
+   0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
+   0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
+   0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
+   0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
+   0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
+   0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
+   0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
+   0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
+   0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
+   0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
+   0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
+   0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
+   0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
+   0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
+   0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
+   0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
+   0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
+   0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
+   0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
+   0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
+   0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
+   0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
+   0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
+   0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
+   0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
+   0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
+   0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
+   0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
+   0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
+   0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
+   0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
+   0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
+   0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
+   0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
+   0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
+   0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
+   0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
+   0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
+};
+
+void bz_rand_udp_mask(DState *s)
+{
+	if (s->rNToGo == 0) {
+		s->rNToGo = BZ2_rNums[s->rTPos];
+		s->rTPos++;
+		if (s->rTPos == 512) {
+			s->rTPos = 0;
+		}
+	}
+	s->rNToGo--;
+}
+
+static unsigned char myfeof(FILE *f)
+{
+	int c = fgetc(f);
+	if (c == EOF) {
+		return(TRUE);
+	}
+	ungetc(c, f);
+	return(FALSE);
+}
+
+static void cleanUpAndFail(int ec)
+{
+	int retVal;
+
+	if ((srcMode == SM_F2F) && (opMode != OM_TEST) && deleteOutputOnInterrupt) {
+		if (noisy) {
+			error_msg("%s: Deleting output file %s, if it exists.\n", progName, outName);
+		}
+		if (outputHandleJustInCase != NULL) {
+			fclose(outputHandleJustInCase);
+		}
+		retVal = remove(outName);
+		if (retVal != 0) {
+			error_msg("%s: WARNING: deletion of output file (apparently) failed.\n", progName);
+		}
+	}
+	if (noisy && (numFileNames > 0) && (numFilesProcessed < numFileNames)) {
+		error_msg("%s: WARNING: some files have not been processed:\n"
+			"\t%d specified on command line, %d not processed yet.\n\n",
+			progName, numFileNames, numFileNames - numFilesProcessed );
+	}
+
+	exit(ec);
+}
+
+
+void panic(char *s)
+{
+	error_msg("\n%s: PANIC -- internal consistency error:\n"
+             "\t%s\n"
+             "\tThis is a BUG.  Please report it to me at:\n"
+             "\tjseward@acm.org\n",
+             progName, s);
+	cleanUpAndFail( 3 );
+}
+
+void BZ2_hbCreateDecodeTables(int *limit, int *base, int *perm, unsigned char *length, int minLen, int maxLen, int alphaSize )
+{
+	int 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];
+	}
+}
+
+int bz_get_small(DState *s)
+{
+	int cccc;
+	int nb, na, mid;
+	nb = 0;
+	na = 256;
+	do {
+		mid = (nb + na) >> 1;
+		if (s->tPos >= s->cftab[mid]) {
+			nb = mid;
+		} else {
+			na = mid;
+		}
+	}
+	while (na - nb != 1);
+	cccc = nb;
+	s->tPos = (((unsigned int)s->ll16[s->tPos]) |
+		(((((unsigned int)(s->ll4[(s->tPos) >> 1])) >>
+		(((s->tPos) << 2) & 0x4)) & 0xF) << 16));
+	return(cccc);
+}
+
+void assert_h(int errcode)
+{
+	error_msg_and_die("\n\nbzip2/libbzip2: internal error number %d.\n"
+		"This is a bug in bzip2/libbzip2, %s.\n"
+		"Please report it to me at: jseward@acm.org.  If this happened\n"
+		"when you were using some program which uses libbzip2 as a\n"
+		"component, you should also report this bug to the author(s)\n"
+		"of that program.  Please make an effort to report this bug;\n"
+		"timely and accurate bug reports eventually lead to higher\n"
+		"quality software.  Thanks.  Julian Seward, 21 March 2000.\n\n",
+		errcode, BZ_VERSION);
+}
+
+static int get_bits(DState *s, int *vvv, char nnn)
+{
+	while (1) {
+		if (s->bsLive >= nnn) {
+			*vvv = (s->bsBuff >> (s->bsLive-nnn)) & ((1 << nnn)-1);
+			s->bsLive -= nnn;
+			break;
+		}
+		if (s->strm->avail_in == 0) {
+			return(FALSE);
+		}
+		s->bsBuff = (s->bsBuff << 8) | ((unsigned int) (*((unsigned char*)(s->strm->next_in))));
+		s->bsLive += 8;
+		s->strm->next_in++;
+		s->strm->avail_in--;
+		s->strm->total_in_lo32++;
+		if (s->strm->total_in_lo32 == 0) {
+			s->strm->total_in_hi32++;
+		}
+	}
+	return(TRUE);
+}
+
+int bz_get_fast(DState *s)
+{
+	int cccc;
+	s->tPos = s->tt[s->tPos];
+	cccc = (unsigned char)(s->tPos & 0xff);
+	s->tPos >>= 8;
+	return(cccc);
+}
+
+/*---------------------------------------------------*/
+int BZ2_decompress(DState *s)
+{
+	int uc = 0;
+	int	retVal;
+	int	minLen,	maxLen;
+	bz_stream	*strm = s->strm;
+
+	/* stuff that needs to be saved/restored */
+	int  i;
+	int  j;
+	int  t;
+	int  alphaSize;
+	int  nGroups;
+	int  nSelectors;
+	int  EOB;
+	int  groupNo;
+	int  groupPos;
+	int  nextSym;
+	int  nblockMAX;
+	int  nblock;
+	int  es;
+	int  N;
+	int  curr;
+	int  zt;
+	int  zn; 
+	int  zvec;
+	int  zj;
+	int  gSel;
+	int  gMinlen;
+	int *gLimit;
+	int *gBase;
+	int *gPerm;
+	int switch_val;
+
+	int get_mtf_val_init(void)
+	{
+		if (groupPos == 0) {
+			groupNo++;
+			if (groupNo >= nSelectors) {
+				retVal = BZ_DATA_ERROR;
+				return(FALSE);
+			}
+			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;
+		return(TRUE);
+	}
+
+	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_val = s->state;
+	switch (switch_val) {
+		case BZ_X_MAGIC_1:
+			s->state = BZ_X_MAGIC_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 'B') {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_MAGIC_2:
+			s->state = BZ_X_MAGIC_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 'Z') {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_MAGIC_3:
+			s->state = BZ_X_MAGIC_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 'h') {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_MAGIC_4:
+			s->state = BZ_X_MAGIC_4;
+			if (get_bits(s, &s->blockSize100k, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if ((s->blockSize100k < '1') || (s->blockSize100k > '9')) {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+			s->blockSize100k -= '0';
+
+			if (s->smallDecompress) {
+				s->ll16 = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(unsigned short), 1);
+				s->ll4 = (strm->bzalloc)(strm->opaque, ((1 + s->blockSize100k * 100000) >> 1) * sizeof(unsigned char), 1);
+
+				if (s->ll16 == NULL || s->ll4 == NULL) {
+					retVal = BZ_MEM_ERROR;
+					goto save_state_and_return;
+				}
+			} else {
+				s->tt = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(int), 1);
+				if (s->tt == NULL) {
+					retVal = BZ_MEM_ERROR;
+					goto save_state_and_return;
+				}
+			}
+
+		case BZ_X_BLKHDR_1:
+			s->state = BZ_X_BLKHDR_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+
+			if (uc == 0x17) {
+				goto endhdr_2;
+			}
+			if (uc != 0x31) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_2:
+			s->state = BZ_X_BLKHDR_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x41) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_3:
+			s->state = BZ_X_BLKHDR_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x59) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_4:
+			s->state = BZ_X_BLKHDR_4;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x26) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_5:
+			s->state = BZ_X_BLKHDR_5;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x53) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_6:
+			s->state = BZ_X_BLKHDR_6;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x59) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		s->currBlockNo++;
+		if (s->verbosity >= 2) {
+			error_msg("\n    [%d: huff+mtf ", s->currBlockNo);
+		}
+		s->storedBlockCRC = 0;
+
+		case BZ_X_BCRC_1:
+			s->state = BZ_X_BCRC_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_BCRC_2:
+			s->state = BZ_X_BCRC_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_BCRC_3:
+			s->state = BZ_X_BCRC_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_BCRC_4:
+			s->state = BZ_X_BCRC_4;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_RANDBIT:
+			s->state = BZ_X_RANDBIT;
+			{
+				int tmp = s->blockRandomised;
+				const int ret = get_bits(s, &tmp, 1);
+				s->blockRandomised = tmp;
+				if (ret == FALSE) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+			}
+
+			s->origPtr = 0;
+
+		case BZ_X_ORIGPTR_1:
+			s->state = BZ_X_ORIGPTR_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->origPtr = (s->origPtr << 8) | ((int)uc);
+
+		case BZ_X_ORIGPTR_2:
+			s->state = BZ_X_ORIGPTR_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->origPtr = (s->origPtr << 8) | ((int)uc);
+
+		case BZ_X_ORIGPTR_3:
+			s->state = BZ_X_ORIGPTR_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->origPtr = (s->origPtr << 8) | ((int)uc);
+
+			if (s->origPtr < 0) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			if (s->origPtr > 10 + 100000*s->blockSize100k) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+			/*--- Receive the mapping table ---*/
+		case BZ_X_MAPPING_1:
+			for (i = 0; i < 16; i++) {
+				s->state = BZ_X_MAPPING_1;
+				if (get_bits(s, &uc, 1) == FALSE) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+				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++) {
+					case BZ_X_MAPPING_2:
+						s->state = BZ_X_MAPPING_2;
+						if (get_bits(s, &uc, 1) == FALSE) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						if (uc == 1) {
+							s->inUse[i * 16 + j] = TRUE;
+						}
+					}
+				}
+			}
+
+			s->nInUse = 0;
+			for (i = 0; i < 256; i++) {
+				if (s->inUse[i]) {
+					s->seqToUnseq[s->nInUse] = i;
+					s->nInUse++;
+				}
+			}
+			if (s->nInUse == 0) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			alphaSize = s->nInUse+2;
+
+		/*--- Now the selectors ---*/
+		case BZ_X_SELECTOR_1:
+			s->state = BZ_X_SELECTOR_1;
+			if (get_bits(s, &nGroups, 3) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (nGroups < 2 || nGroups > 6) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_SELECTOR_2:
+			s->state = BZ_X_SELECTOR_2;
+			if (get_bits(s, &nSelectors, 15) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (nSelectors < 1) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+
+
+			for (i = 0; i < nSelectors; i++) {
+				j = 0;
+				while (1) {
+					case BZ_X_SELECTOR_3:
+					s->state = BZ_X_SELECTOR_3;
+					if (get_bits(s, &uc, 1) == FALSE) {
+						retVal = BZ_OK;
+						goto save_state_and_return;
+					}
+					if (uc == 0) {
+						break;
+					}
+					j++;
+					if (j >= nGroups) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+				}
+				s->selectorMtf[i] = j;
+			}
+
+			/*--- Undo the MTF values for the selectors. ---*/
+			{
+				unsigned char 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++) {
+			case BZ_X_CODING_1:
+				s->state = BZ_X_CODING_1;
+				if (get_bits(s, &curr, 5) == FALSE) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+			for (i = 0; i < alphaSize; i++) {
+				while (TRUE) {
+					if (curr < 1 || curr > 20) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+
+					case BZ_X_CODING_2:
+						s->state = BZ_X_CODING_2;
+						if (get_bits(s, &uc, 1) == FALSE) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						if (uc == 0) {
+							break;
+						}
+
+					case BZ_X_CODING_3:
+						s->state = BZ_X_CODING_3;
+						if (get_bits(s, &uc, 1) == FALSE) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						if (uc == 0) {
+							curr++;
+						} else {
+							curr--;
+						}
+				}
+				s->len[t][i] = curr;
+			}
+		}
+
+		/*--- Create the Huffman decoding tables ---*/
+		for (t = 0; t < nGroups; t++) {
+			minLen = 32;
+			maxLen = 0;
+			for (i = 0; i < alphaSize; i++) {
+				if (s->len[t][i] > maxLen) {
+					maxLen = s->len[t][i];
+				}
+				if (s->len[t][i] < minLen) {
+					minLen = s->len[t][i];
+				}
+			}
+
+			BZ2_hbCreateDecodeTables ( 
+				&(s->limit[t][0]), 
+				&(s->base[t][0]), 
+				&(s->perm[t][0]), 
+				&(s->len[t][0]),
+				minLen, maxLen, alphaSize
+				);
+
+
+			s->minLens[t] = minLen;
+		}
+
+		/*--- Now the MTF values ---*/
+
+		EOB      = s->nInUse+1;
+		nblockMAX = 100000 * s->blockSize100k;
+		groupNo  = -1;
+		groupPos = 0;
+
+		for (i = 0; i <= 255; i++) {
+			s->unzftab[i] = 0;
+		}
+		/*-- MTF init --*/
+		{
+			int 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] = (unsigned char)(ii * MTFL_SIZE + jj);
+					kk--;
+				}
+				s->mtfbase[ii] = kk + 1;
+			}
+		}
+		/*-- end MTF init --*/
+
+		nblock = 0;
+
+		if (get_mtf_val_init() == FALSE) {
+			goto save_state_and_return;
+		}
+		case BZ_X_MTF_1:
+			s->state = BZ_X_MTF_1;
+			if (get_bits(s, &zvec, zn) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			while (1) {
+				if (zn > 20 /* the longest code */) {
+					retVal = BZ_DATA_ERROR;
+					goto save_state_and_return;
+				}
+				if (zvec <= gLimit[zn]) {
+					break;
+				}
+				zn++;
+
+				case BZ_X_MTF_2:
+					s->state = BZ_X_MTF_2;
+					if (get_bits(s, &zj, 1) == FALSE) {
+						retVal = BZ_OK;
+						goto save_state_and_return;
+					}
+					zvec = (zvec << 1) | zj;
+			}
+			if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			nextSym = gPerm[zvec - gBase[zn]];
+
+		while (1) {
+			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;
+				if (get_mtf_val_init() == FALSE) {
+					goto save_state_and_return;
+				}
+				case BZ_X_MTF_3:
+					s->state = BZ_X_MTF_3;
+					if (get_bits(s, &zvec, zn) == FALSE) {
+						retVal = BZ_OK;
+						goto save_state_and_return;
+					}
+					while (1) {
+						if (zn > 20 /* the longest code */) {
+							retVal = BZ_DATA_ERROR;
+							goto save_state_and_return;
+						}
+						if (zvec <= gLimit[zn]) {
+							break;
+						}
+						zn++;
+
+						case BZ_X_MTF_4:
+							s->state = BZ_X_MTF_4;
+							if (get_bits(s, &zj, 1) == FALSE) {
+								retVal = BZ_OK;
+								goto save_state_and_return;
+							}
+							zvec = (zvec << 1) | zj;
+					}
+					if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+
+					}
+					nextSym = gPerm[zvec - gBase[zn]];
+			}
+			while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
+
+			es++;
+			uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
+			s->unzftab[uc] += es;
+
+			if (s->smallDecompress) {
+				while (es > 0) {
+					if (nblock >= nblockMAX) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+					s->ll16[nblock] = (unsigned short)uc;
+					nblock++;
+					es--;
+				}
+			} else {
+				while (es > 0) {
+					if (nblock >= nblockMAX) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+					s->tt[nblock] = (unsigned int)uc;
+					nblock++;
+					es--;
+				}
+			}
+			continue;
+		} else {
+			if (nblock >= nblockMAX) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			/*-- uc = MTF ( nextSym-1 ) --*/
+			{
+				int ii, jj, kk, pp, lno, off;
+				unsigned int nn;
+				nn = (unsigned int)(nextSym - 1);
+
+				if (nn < MTFL_SIZE) {
+					/* avoid general-case expense */
+					pp = s->mtfbase[0];
+					uc = s->mtfa[pp+nn];
+					while (nn > 3) {
+						int 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] = (unsigned short)(s->seqToUnseq[uc]);
+			} else {
+				s->tt[nblock]   = (unsigned int)(s->seqToUnseq[uc]);
+			}
+			nblock++;
+
+			if (get_mtf_val_init() == FALSE) {
+				goto save_state_and_return;
+			}
+			case BZ_X_MTF_5:
+				s->state = BZ_X_MTF_5;
+				if (get_bits(s, &zvec, zn) == FALSE) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+				while (1) {
+					if (zn > 20 /* the longest code */) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+					if (zvec <= gLimit[zn]) {
+						break;
+					}
+					zn++;
+
+					case BZ_X_MTF_6:
+						s->state = BZ_X_MTF_6;
+						if (get_bits(s, &zj, 1) == FALSE) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						zvec = (zvec << 1) | zj;
+				}
+			if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			nextSym = gPerm[zvec - gBase[zn]];
+			continue;
+		}
+	}
+
+	/* Now we know what nblock is, we can do a better sanity
+		check on s->origPtr.
+	*/
+	if (s->origPtr < 0 || s->origPtr >= nblock) {
+		retVal = BZ_DATA_ERROR;
+		goto save_state_and_return;
+	}
+	s->state_out_len = 0;
+	s->state_out_ch  = 0;
+	s->calculatedBlockCRC = 0xffffffffL;
+	s->state = BZ_X_OUTPUT;
+	if (s->verbosity >= 2) {
+		error_msg("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 = (unsigned char)(s->ll16[i]);
+			s->ll16[i] = (unsigned short)(s->cftabCopy[uc] & 0x0000ffff);
+			if (((i) & 0x1) == 0) {
+				s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (s->cftabCopy[uc] >> 16);
+			} else {
+				s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((s->cftabCopy[uc] >> 16) << 4);
+			}
+			s->cftabCopy[uc]++;
+		}
+
+		/*-- Compute T^(-1) by pointer reversal on T --*/
+		i = s->origPtr;
+		j = (((unsigned int)s->ll16[i]) |
+			(((((unsigned int)(s->ll4[(i) >> 1])) >>
+			(((i) << 2) & 0x4)) & 0xF) << 16));
+
+		do {
+			const int tmp = (((unsigned int)s->ll16[j]) |
+				(((((unsigned int)(s->ll4[(j) >> 1])) >>
+				(((j) << 2) & 0x4)) & 0xF) << 16));
+
+			s->ll16[j] = (unsigned short)(i & 0x0000ffff);
+			if (((j) & 0x1) == 0) {
+				s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0xf0) | (i >> 16);
+			} else {
+				s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0x0f) | ((i >> 16) << 4);
+			}
+			i = j;
+			j = tmp;
+		}
+		while (i != s->origPtr);
+			s->tPos = s->origPtr;
+			s->nblock_used = 0;
+			if (s->blockRandomised) {
+				s->rNToGo = 0;
+				s->rTPos  = 0;
+				s->k0 = bz_get_small(s);
+				s->nblock_used++;
+				bz_rand_udp_mask(s);
+				s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+			} else {
+				s->k0 = bz_get_small(s);
+				s->nblock_used++;
+			}
+		} else {
+			/*-- compute the T^(-1) vector --*/
+			for (i = 0; i < nblock; i++) {
+				uc = (unsigned char)(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) {
+				s->rNToGo = 0;
+				s->rTPos  = 0;
+				s->k0 = bz_get_fast(s);
+
+				s->nblock_used++;
+				bz_rand_udp_mask(s);
+				s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+			} else {
+				s->k0 = bz_get_fast(s);
+				s->nblock_used++;
+			}
+		}
+
+		retVal = BZ_OK;
+		goto save_state_and_return;
+
+endhdr_2:
+		case BZ_X_ENDHDR_2:
+			s->state = BZ_X_ENDHDR_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x72) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_3:
+			s->state = BZ_X_ENDHDR_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x45) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_4:
+			s->state = BZ_X_ENDHDR_4;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x38) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_5:
+			s->state = BZ_X_ENDHDR_5;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x50) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_6:
+			s->state = BZ_X_ENDHDR_6;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x90) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = 0;
+
+		case BZ_X_CCRC_1:
+			s->state = BZ_X_CCRC_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+		case BZ_X_CCRC_2:
+			s->state = BZ_X_CCRC_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_CCRC_3:
+			s->state = BZ_X_CCRC_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_CCRC_4:
+			s->state = BZ_X_CCRC_4;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+
+		s->state = BZ_X_IDLE;
+		retVal = BZ_STREAM_END;
+		goto save_state_and_return;
+
+default:
+		printf("switch val is %d\n", switch_val);
+		assert_h(4001);
+	}
+
+	assert_h(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;   
+}
+
+static void *default_bzalloc(void *opaque, int items, int size)
+{
+	void *v = xmalloc(items *size);
+	return v;
+}
+
+static void default_bzfree(void *opaque, void *addr)
+{
+	if (addr != NULL) {
+		free(addr);
+	}
+}
+
+//int BZ2_bzDecompressInit(bz_stream* strm, int verbosity_level, int small)
+int BZ2_bzDecompressInit(bz_stream* strm, int small)
+{
+	DState* s;
+
+	if (sizeof(int) != 4) {
+		return BZ_CONFIG_ERROR;
+	}
+	if (sizeof(short) != 2) {
+		return BZ_CONFIG_ERROR;
+	}
+	if (sizeof(char) != 1) {
+		return BZ_CONFIG_ERROR;
+	}
+	if (strm == NULL) {
+		return BZ_PARAM_ERROR;
+	}
+	if (small != 0 && small != 1) {
+		return BZ_PARAM_ERROR;
+	}
+//	if (verbosity_level < 0 || verbosity_level > 4) {
+//		return BZ_PARAM_ERROR;
+//	}
+	if (strm->bzalloc == NULL) {
+		strm->bzalloc = default_bzalloc;
+	}
+	if (strm->bzfree == NULL) {
+		strm->bzfree = default_bzfree;
+	}
+	s = (strm->bzalloc)(strm->opaque, sizeof(DState), 1);
+	if (s == NULL) {
+		return BZ_MEM_ERROR;
+	}
+	s->strm                  = strm;
+	strm->state              = s;
+	s->state                 = BZ_X_MAGIC_1;
+	s->bsLive                = 0;
+	s->bsBuff                = 0;
+	s->calculatedCombinedCRC = 0;
+	strm->total_in_lo32      = 0;
+	strm->total_in_hi32      = 0;
+	strm->total_out_lo32     = 0;
+	strm->total_out_hi32     = 0;
+	s->smallDecompress       = (unsigned char)small;
+	s->ll4                   = NULL;
+	s->ll16                  = NULL;
+	s->tt                    = NULL;
+	s->currBlockNo           = 0;
+//	s->verbosity             = verbosity_level;
+
+	return BZ_OK;
+}
+
+void bz_seterr(int eee, int *bzerror, bzFile **bzf)
+{
+	if (bzerror != NULL) {
+		*bzerror = eee;
+	}
+	if (*bzf != NULL) {
+		(*bzf)->lastErr = eee;
+	}
+}
+
+void BZ2_bzReadClose(int *bzerror, void *b)
+{
+	bzFile* bzf = (bzFile*)b;
+
+	bz_seterr(BZ_OK, bzerror, &bzf);
+	if (bzf == NULL) {
+		bz_seterr(BZ_OK, bzerror, &bzf);
+		return;
+	}
+
+	if (bzf->writing) {
+		bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf);
+		return;
+	}
+
+	if (bzf->initialisedOk) {
+		bz_stream *strm = &(bzf->strm);
+		DState *s;
+		if (strm == NULL) {
+			return;
+		}
+		s = strm->state;
+		if ((s == NULL) || (s->strm != strm)) {
+			return;
+		}
+		if (s->tt != NULL) {
+			(strm->bzfree)(strm->opaque,(s->tt));
+		}
+		if (s->ll16 != NULL) {
+			(strm->bzfree)(strm->opaque,(s->ll16));
+		}
+		if (s->ll4 != NULL) {
+			(strm->bzfree)(strm->opaque,(s->ll4));
+		}
+		(strm->bzfree)(strm->opaque,(strm->state));
+		strm->state = NULL;
+		return;
+	}
+	free(bzf);
+}
+
+static void unRLE_obuf_to_output_FAST(DState *s)
+{
+	unsigned char k1;
+
+	if (s->blockRandomised) {
+		while (1) {
+			/* try to finish existing run */
+			while (1) {
+				if (s->strm->avail_out == 0) {
+					return;
+				}
+				if (s->state_out_len == 0) {
+					break;
+				}
+				*((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
+				s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
+					BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
+					((unsigned char)s->state_out_ch)];
+				s->state_out_len--;
+				s->strm->next_out++;
+				s->strm->avail_out--;
+				s->strm->total_out_lo32++;
+				if (s->strm->total_out_lo32 == 0) {
+					s->strm->total_out_hi32++;
+				}
+			}
+   
+			/* can a new run be started? */
+			if (s->nblock_used == s->save_nblock+1) {
+				return;
+			}
+			s->state_out_len = 1;
+			s->state_out_ch = s->k0;
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			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;
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			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;
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			if (s->nblock_used == s->save_nblock+1) {
+				continue;
+			}
+			if (k1 != s->k0) {
+				s->k0 = k1;
+				continue;
+			}
+
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			s->state_out_len = ((int)k1) + 4;
+			s->k0 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+		}
+	} else {
+		/* restore */
+		unsigned int c_calculatedBlockCRC = s->calculatedBlockCRC;
+		unsigned char c_state_out_ch       = s->state_out_ch;
+		int c_state_out_len      = s->state_out_len;
+		int c_nblock_used        = s->nblock_used;
+		int c_k0                 = s->k0;
+		unsigned int	*c_tt                 = s->tt;
+		unsigned int	c_tPos               = s->tPos;
+		char	*cs_next_out          = s->strm->next_out;
+		unsigned int  cs_avail_out         = s->strm->avail_out;
+		/* end restore */
+
+		unsigned int avail_out_INIT = cs_avail_out;
+		int        s_save_nblockPP = s->save_nblock+1;
+		unsigned int total_out_lo32_old;
+
+		while (1) {
+			/* 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;
+					}
+					*((unsigned char *)(cs_next_out)) = c_state_out_ch;
+					c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
+						BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
+						((unsigned char)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;
+					}
+					*((unsigned char *)(cs_next_out)) = c_state_out_ch;
+					c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
+						BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
+						((unsigned char)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;
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			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;
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+			if (c_nblock_used == s_save_nblockPP) {
+				continue;
+			}
+			if (k1 != c_k0) {
+				c_k0 = k1;
+				continue;
+			}
+
+			c_state_out_len = 3;
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+			if (c_nblock_used == s_save_nblockPP) {
+				continue;
+			}
+			if (k1 != c_k0) {
+				c_k0 = k1;
+				continue;
+			}
+   
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+			c_state_out_len = ((int)k1) + 4;
+
+			c_tPos = c_tt[c_tPos];
+			c_k0 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+		}
+
+return_notr:
+		total_out_lo32_old = s->strm->total_out_lo32;
+		s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
+		if (s->strm->total_out_lo32 < total_out_lo32_old) {
+			s->strm->total_out_hi32++;
+		}
+
+		/* save */
+		s->calculatedBlockCRC = c_calculatedBlockCRC;
+		s->state_out_ch       = c_state_out_ch;
+		s->state_out_len      = c_state_out_len;
+		s->nblock_used        = c_nblock_used;
+		s->k0                 = c_k0;
+		s->tt                 = c_tt;
+		s->tPos               = c_tPos;
+		s->strm->next_out     = cs_next_out;
+		s->strm->avail_out    = cs_avail_out;
+		/* end save */
+	}
+}
+
+static void unRLE_obuf_to_output_SMALL(DState *s)
+{
+	unsigned char k1;
+
+	if (s->blockRandomised) {
+		while (1) {
+			/* try to finish existing run */
+			while (1) {
+				if (s->strm->avail_out == 0) {
+					return;
+				}
+				if (s->state_out_len == 0) {
+					break;
+				}
+				*((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
+				s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
+					BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
+					((unsigned char)s->state_out_ch)];
+				s->state_out_len--;
+				s->strm->next_out++;
+				s->strm->avail_out--;
+				s->strm->total_out_lo32++;
+				if (s->strm->total_out_lo32 == 0) {
+					s->strm->total_out_hi32++;
+				}
+			}
+
+			/* can a new run be started? */
+			if (s->nblock_used == s->save_nblock+1) {
+				return;
+			}
+               
+			s->state_out_len = 1;
+			s->state_out_ch = s->k0;
+			k1 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			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;
+			k1 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			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;
+			k1 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			if (s->nblock_used == s->save_nblock+1) {
+				continue;
+			}
+			if (k1 != s->k0) {
+				s->k0 = k1;
+				continue;
+			}
+			k1 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			s->state_out_len = ((int)k1) + 4;
+			s->k0 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+		}
+	} else {
+		while (1) {
+			/* try to finish existing run */
+			while (1) {
+				if (s->strm->avail_out == 0) {
+					return;
+				}
+				if (s->state_out_len == 0) {
+					break;
+				}
+				*((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
+				s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
+					BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
+					((unsigned char)s->state_out_ch)];
+				s->state_out_len--;
+				s->strm->next_out++;
+				s->strm->avail_out--;
+				s->strm->total_out_lo32++;
+				if (s->strm->total_out_lo32 == 0) {
+					s->strm->total_out_hi32++;
+				}
+			}
+
+			/* can a new run be started? */
+			if (s->nblock_used == s->save_nblock+1) {
+				return;
+			}
+
+			s->state_out_len = 1;
+			s->state_out_ch = s->k0;
+			k1 = bz_get_small(s);
+			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;
+			k1 = bz_get_small(s);
+			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;
+			k1 = bz_get_small(s);
+			s->nblock_used++;
+			if (s->nblock_used == s->save_nblock+1) {
+				continue;
+			}
+			if (k1 != s->k0) {
+				s->k0 = k1;
+				continue;
+			}
+
+			k1 = bz_get_small(s);
+			s->nblock_used++;
+			s->state_out_len = ((int)k1) + 4;
+			s->k0 = bz_get_small(s);
+			s->nblock_used++;
+		}
+	}
+}
+
+int BZ2_bzDecompress(bz_stream *strm)
+{
+	DState* s;
+	if (strm == NULL) {
+		return BZ_PARAM_ERROR;
+	}
+	s = strm->state;
+	if (s == NULL) {
+		return BZ_PARAM_ERROR;
+	}
+	if (s->strm != strm) {
+		return BZ_PARAM_ERROR;
+	}
+
+	while (1) {
+		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) {
+				s->calculatedBlockCRC = ~(s->calculatedBlockCRC);
+				if (s->verbosity >= 3) {
+					error_msg("{0x%x, 0x%x}", s->storedBlockCRC, s->calculatedBlockCRC);
+				}
+				if (s->verbosity >= 2) {
+					error_msg("]");
+				}
+				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) {
+			int r = BZ2_decompress(s);
+			if (r == BZ_STREAM_END) {
+				if (s->verbosity >= 3) {
+					error_msg("\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;
+			}
+		}
+	}
+
+	assert_h(6001);
+
+	return(0);  /*NOTREACHED*/
+}
+
+int BZ2_bzRead(int *bzerror, void *b, void *buf, int len)
+{
+	int n, ret;
+	bzFile *bzf = (bzFile*)b;
+
+	bz_seterr(BZ_OK, bzerror, &bzf);
+
+	if (bzf == NULL || buf == NULL || len < 0) {
+		bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
+		return 0;
+	}
+
+	if (bzf->writing) {
+		bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf);
+		return 0;
+	}
+
+	if (len == 0) {
+		bz_seterr(BZ_OK, bzerror, &bzf);
+		return 0;
+	}
+
+	bzf->strm.avail_out = len;
+	bzf->strm.next_out = buf;
+
+	while (1) {
+		if (ferror(bzf->handle)) {
+			bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
+			return 0;
+		}
+		if ((bzf->strm.avail_in == 0) && !myfeof(bzf->handle)) {
+			n = fread(bzf->buf, sizeof(unsigned char), BZ_MAX_UNUSED, bzf->handle);
+			if (ferror(bzf->handle)) {
+				bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
+				return 0;
+			}
+			bzf->bufN = n;
+			bzf->strm.avail_in = bzf->bufN;
+			bzf->strm.next_in = bzf->buf;
+		}
+
+		ret = BZ2_bzDecompress(&(bzf->strm));
+
+		if ((ret != BZ_OK) && (ret != BZ_STREAM_END)) {
+			bz_seterr(ret, bzerror, &bzf);
+			return 0;
+		}
+
+		if ((ret == BZ_OK) && myfeof(bzf->handle) &&
+			(bzf->strm.avail_in == 0) && (bzf->strm.avail_out > 0)) {
+			bz_seterr(BZ_UNEXPECTED_EOF, bzerror, &bzf);
+			return(0);
+		}
+
+		if (ret == BZ_STREAM_END) {
+			bz_seterr(BZ_STREAM_END, bzerror, &bzf);
+			return(len - bzf->strm.avail_out);
+		}
+		if (bzf->strm.avail_out == 0) {
+			bz_seterr(BZ_OK, bzerror, &bzf);
+			return(len);
+		}
+	}
+	return(0); /*not reached*/
+}
+
+void BZ2_bzReadGetUnused(int *bzerror, void *b, void **unused, int *nUnused)
+{
+	bzFile *bzf = (bzFile*)b;
+	if (bzf == NULL) {
+		bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
+		return;
+	}
+	if (bzf->lastErr != BZ_STREAM_END) {
+		bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf);
+		return;
+	}
+	if (unused == NULL || nUnused == NULL) {
+		bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
+		return;
+	}
+
+	bz_seterr(BZ_OK, bzerror, &bzf);
+	*nUnused = bzf->strm.avail_in;
+	*unused = bzf->strm.next_in;
+}
+
+void *BZ2_bzReadOpen(int *bzerror, FILE *f, int small, void *unused, int nUnused)
+{
+	bzFile *bzf = NULL;
+	int ret;
+
+	bz_seterr(BZ_OK, bzerror, &bzf);
+
+	if (f == NULL || (small != 0 && small != 1) ||
+		(unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)) ||
+//		(verbosity_level < 0 || verbosity_level > 4) ||
+		(unused == NULL && nUnused != 0)) {
+		bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
+		return NULL;
+	}
+
+	if (ferror(f)) {
+		bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
+		return NULL;
+	}
+
+	bzf = xmalloc(sizeof(bzFile));
+	if (bzf == NULL) {
+		bz_seterr(BZ_MEM_ERROR, bzerror, &bzf);
+		return NULL;
+	}
+	bz_seterr(BZ_OK, bzerror, &bzf);
+
+	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] = *((unsigned char *)(unused)); bzf->bufN++;
+		unused = ((void *)( 1 + ((unsigned char *)(unused))  ));
+		nUnused--;
+	}
+
+	ret = BZ2_bzDecompressInit(&(bzf->strm), small);
+	if (ret != BZ_OK) {
+		bz_seterr(ret, bzerror, &bzf);
+		free(bzf);
+		return NULL;
+	}
+
+	bzf->strm.avail_in = bzf->bufN;
+	bzf->strm.next_in  = bzf->buf;
+
+	bzf->initialisedOk = TRUE;
+	return bzf;   
+}
+
+static unsigned char uncompressStream(FILE *zStream, FILE *stream)
+{
+	unsigned char unused[BZ_MAX_UNUSED];
+	unsigned char *unusedTmp;
+	unsigned char obuf[5000];
+	void *bzf = NULL;
+	int bzerr_dummy;
+	int bzerr;
+	int nread;
+	int nUnused;
+	int streamNo;
+	int ret;
+	int i;
+
+	nUnused = 0;
+	streamNo = 0;
+
+	if (ferror(stream)) {
+		goto errhandler_io;
+	}
+	if (ferror(zStream)) {
+		goto errhandler_io;
+	}
+
+	while(1) {
+		bzf = BZ2_bzReadOpen(&bzerr, zStream, (int)smallMode, unused, nUnused);
+		if (bzf == NULL || bzerr != BZ_OK) {
+			goto errhandler;
+		}
+		streamNo++;
+
+		while (bzerr == BZ_OK) {
+			nread = BZ2_bzRead(&bzerr, bzf, obuf, 5000);
+			if (bzerr == BZ_DATA_ERROR_MAGIC) {
+				goto errhandler;
+			}
+			if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0) {
+				fwrite(obuf, sizeof(unsigned char), nread, stream);
+			}
+			if (ferror(stream)) {
+				goto errhandler_io;
+			}
+		}
+		if (bzerr != BZ_STREAM_END) {
+			goto errhandler;
+		}
+		BZ2_bzReadGetUnused(&bzerr, bzf, (void **)(&unusedTmp), &nUnused);
+		if (bzerr != BZ_OK) {
+			panic("decompress:bzReadGetUnused");
+		}
+		for (i = 0; i < nUnused; i++) {
+			unused[i] = unusedTmp[i];
+		}
+		BZ2_bzReadClose(&bzerr, bzf);
+		if (bzerr != BZ_OK) {
+			panic("decompress:bzReadGetUnused");
+		}
+		if ((nUnused == 0) && myfeof(zStream)) {
+			break;
+		}
+	}
+
+	if (ferror(zStream)) {
+		goto errhandler_io;
+	}
+	ret = fclose(zStream);
+	if (ret == EOF) {
+		goto errhandler_io;
+	}
+	if (ferror(stream)) {
+		goto errhandler_io;
+	}
+	ret = fflush(stream);
+	if (ret != 0) {
+		goto errhandler_io;
+	}
+	if (stream != stdout) {
+		ret = fclose(stream);
+		if (ret == EOF) {
+			goto errhandler_io;
+		}
+	}
+//	if (verbosity_level >= 2) {
+//		fprintf(stderr,"\n    ");
+//	}
+	return TRUE;
+
+errhandler:
+	BZ2_bzReadClose ( &bzerr_dummy, bzf );
+	switch (bzerr) {
+		case BZ_CONFIG_ERROR:
+			error_msg("bzip2: I'm not configured correctly for this platform!\n"
+				"\tI require Int32, Int16 and Char to have sizes\n"
+				"\tof 4, 2 and 1 bytes to run properly, and they don't.\n"
+				"\tProbably you can fix this by defining them correctly,\n"
+				"\tand recompiling.  Bye!\n" );
+			exit(3);
+		case BZ_IO_ERROR:
+errhandler_io:
+			error_msg("\n%s: I/O or other error, bailing out.  "
+				"Possible reason follows.\n", progName);
+			perror(progName);
+			cleanUpAndFail(1);
+		case BZ_DATA_ERROR:
+			error_msg("\n%s: Data integrity error when decompressing.\n", progName);
+			cleanUpAndFail(2);
+		case BZ_MEM_ERROR:
+			error_msg("\n%s: couldn't allocate enough memory\n", progName);
+			cleanUpAndFail(1);
+		case BZ_UNEXPECTED_EOF:
+			error_msg("\n%s: Compressed file ends unexpectedly;\n\t"
+				"perhaps it is corrupted?  *Possible* reason follows.\n", progName);
+			perror(progName);
+			cleanUpAndFail(2);
+		case BZ_DATA_ERROR_MAGIC:
+			if (zStream != stdin) {
+				fclose(zStream);
+			}
+			if (stream != stdout) {
+				fclose(stream);
+			}
+			if (streamNo == 1) {
+				return FALSE;
+			} else {
+				if (noisy) {
+					error_msg("\n%s: %s: trailing garbage after EOF ignored\n", progName, inName );
+				}
+				return TRUE;       
+			}
+		default:
+			panic ( "decompress:unexpected error" );
+	}
+
+	panic("decompress:end");
+	return(TRUE); /*notreached*/
+}
+
+int bunzip2_main(int argc, char **argv)
+{
+	FILE *src_stream;
+	FILE *dst_stream;
+	char *save_name;
+	char *save_name_ptr;
+	if (argc != 2) {
+		show_usage();
+	}
+	src_stream = xfopen(argv[1], "r");
+	save_name = strdup(argv[1]);
+	save_name_ptr = strrchr(save_name, '.');
+	if (save_name_ptr == NULL) {
+		return(FALSE);
+	}
+	if (strcmp(save_name_ptr, ".bz2") != 0) {
+		error_msg("Invalid extension, expected .bz2");
+	}
+	*save_name_ptr = '\0';	
+	dst_stream = xfopen(save_name, "w");
+	uncompressStream(src_stream, dst_stream);
+
+	return(TRUE);
+}
diff --git a/bunzip2.c b/bunzip2.c
new file mode 100644
index 0000000..757654d
--- /dev/null
+++ b/bunzip2.c
@@ -0,0 +1,2340 @@
+/* Modified for busybox by Glenn McGrath <bug1@optushome.com.au> */
+/*--
+  This file is a part of bzip2 and/or libbzip2, a program and
+  library for lossless, block-sorting data compression.
+
+  Copyright (C) 1996-2000 Julian R Seward.  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+  2. The origin of this software must not be misrepresented; you must 
+     not claim that you wrote the original software.  If you use this 
+     software in a product, an acknowledgment in the product 
+     documentation would be appreciated but is not required.
+
+  3. Altered source versions must be plainly marked as such, and must
+     not be misrepresented as being the original software.
+
+  4. The name of the author may not be used to endorse or promote 
+     products derived from this software without specific prior written 
+     permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+  Julian Seward, Cambridge, UK.
+  jseward@acm.org
+  bzip2/libbzip2 version 1.0 of 21 March 2000
+
+  This program is based on (at least) the work of:
+     Mike Burrows
+     David Wheeler
+     Peter Fenwick
+     Alistair Moffat
+     Radford Neal
+     Ian H. Witten
+     Robert Sedgewick
+     Jon L. Bentley
+
+  For more information on these sources, see the manual.
+--*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <busybox.h>
+
+//#define TRUE 1
+//#define FALSE 0
+
+#define MTFA_SIZE 4096
+#define MTFL_SIZE 16
+#define BZ_N_GROUPS 6
+#define BZ_G_SIZE   50
+#define BZ_MAX_ALPHA_SIZE 258
+
+#define BZ_OK                0
+#define BZ_RUN_OK            1
+#define BZ_FLUSH_OK          2
+#define BZ_FINISH_OK         3
+#define BZ_STREAM_END        4
+#define BZ_SEQUENCE_ERROR    (-1)
+#define BZ_PARAM_ERROR       (-2)
+#define BZ_MEM_ERROR         (-3)
+#define BZ_DATA_ERROR        (-4)
+#define BZ_DATA_ERROR_MAGIC  (-5)
+#define BZ_IO_ERROR          (-6)
+#define BZ_UNEXPECTED_EOF    (-7)
+#define BZ_OUTBUFF_FULL      (-8)
+#define BZ_CONFIG_ERROR      (-9)
+
+#define BZ_RUNA 0
+#define BZ_RUNB 1
+
+#define BZ_MAX_UNUSED 5000
+#define FILE_NAME_LEN 1034
+/*-- 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
+
+#define BZ_MAX_CODE_LEN    23
+#define BZ_VERSION  "1.0.1, 23-June-2000"
+#define OM_TEST          3
+#define SM_F2F 3
+
+typedef struct {
+	char *next_in;
+	unsigned int avail_in;
+	unsigned int total_in_lo32;
+	unsigned int total_in_hi32;
+
+	char *next_out;
+	unsigned int avail_out;
+	unsigned int total_out_lo32;
+	unsigned int total_out_hi32;
+
+	void *state;
+
+	void *(*bzalloc)(void *,int,int);
+	void (*bzfree)(void *,void *);
+	void *opaque;
+} bz_stream;
+
+typedef struct {
+	bz_stream	strm;
+	FILE	*handle;
+    unsigned char	initialisedOk;
+	unsigned char	writing;
+	char	buf[BZ_MAX_UNUSED];
+	int		lastErr;
+	int		bufN;
+} bzFile;
+
+/*-- Structure holding all the decompression-side stuff. --*/
+typedef struct {
+	/* pointer back to the struct bz_stream */
+	bz_stream* strm;
+
+	/* state indicator for this stream */
+	int	state;
+
+	/* for doing the final run-length decoding */
+	unsigned char    state_out_ch;
+	int    state_out_len;
+	unsigned char     blockRandomised;
+	int rNToGo;
+	int rTPos;
+
+	/* the buffer for bit stream reading */
+	unsigned int   bsBuff;
+	int    bsLive;
+
+	/* misc administratium */
+	int    blockSize100k;
+	unsigned char     smallDecompress;
+	int    currBlockNo;
+	int    verbosity;
+
+	/* for undoing the Burrows-Wheeler transform */
+	int    origPtr;
+	unsigned int   tPos;
+	int    k0;
+	int    unzftab[256];
+	int    nblock_used;
+	int    cftab[257];
+	int    cftabCopy[257];
+
+	/* for undoing the Burrows-Wheeler transform (FAST) */
+	unsigned int *tt;
+
+	/* for undoing the Burrows-Wheeler transform (SMALL) */
+	unsigned short *ll16;
+	unsigned char *ll4;
+
+	/* stored and calculated CRCs */
+	unsigned int   storedBlockCRC;
+	unsigned int   storedCombinedCRC;
+	unsigned int   calculatedBlockCRC;
+	unsigned int   calculatedCombinedCRC;
+
+	/* map of bytes used in block */
+	int    nInUse;
+	unsigned char     inUse[256];
+	unsigned char     inUse16[16];
+	unsigned char    seqToUnseq[256];
+
+	/* for decoding the MTF values */
+	unsigned char    mtfa   [MTFA_SIZE];
+	unsigned char    selector   [2 + (900000 / BZ_G_SIZE)];
+	unsigned char    selectorMtf[2 + (900000 / BZ_G_SIZE)];
+	unsigned char    len  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    mtfbase[256 / MTFL_SIZE];
+
+	int    limit  [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    base   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    perm   [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
+	int    minLens[BZ_N_GROUPS];
+
+	/* save area for scalars in the main decompress code */
+	int    save_i;
+	int    save_j;
+	int    save_t;
+	int    save_alphaSize;
+	int    save_nGroups;
+	int    save_nSelectors;
+	int    save_EOB;
+	int    save_groupNo;
+	int    save_groupPos;
+	int    save_nextSym;
+	int    save_nblockMAX;
+	int    save_nblock;
+	int    save_es;
+	int    save_N;
+	int    save_curr;
+	int    save_zt;
+	int    save_zn; 
+	int    save_zvec;
+	int    save_zj;
+	int    save_gSel;
+	int    save_gMinlen;
+	int	*save_gLimit;
+	int	*save_gBase;
+	int	*save_gPerm;
+} DState;
+
+int BZ2_rNums[512];
+//int	verbosity_level;
+unsigned char smallMode;
+unsigned char noisy;
+char *progName;
+char inName[FILE_NAME_LEN];
+char outName[FILE_NAME_LEN];
+int srcMode;
+int opMode;
+unsigned char deleteOutputOnInterrupt;
+FILE *outputHandleJustInCase;
+int numFileNames;
+int numFilesProcessed;
+int exitValue;
+
+unsigned int BZ2_crc32Table[256] = {
+
+   /*-- Ugly, innit? --*/
+
+   0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
+   0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
+   0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
+   0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
+   0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
+   0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
+   0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
+   0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
+   0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
+   0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
+   0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
+   0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
+   0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
+   0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
+   0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
+   0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
+   0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
+   0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
+   0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
+   0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
+   0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
+   0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
+   0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
+   0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
+   0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
+   0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
+   0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
+   0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
+   0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
+   0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
+   0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
+   0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
+   0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
+   0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
+   0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
+   0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
+   0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
+   0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
+   0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
+   0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
+   0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
+   0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
+   0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
+   0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
+   0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
+   0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
+   0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
+   0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
+   0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
+   0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
+   0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
+   0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
+   0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
+   0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
+   0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
+   0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
+   0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
+   0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
+   0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
+   0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
+   0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
+   0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
+   0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
+   0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
+};
+
+void bz_rand_udp_mask(DState *s)
+{
+	if (s->rNToGo == 0) {
+		s->rNToGo = BZ2_rNums[s->rTPos];
+		s->rTPos++;
+		if (s->rTPos == 512) {
+			s->rTPos = 0;
+		}
+	}
+	s->rNToGo--;
+}
+
+static unsigned char myfeof(FILE *f)
+{
+	int c = fgetc(f);
+	if (c == EOF) {
+		return(TRUE);
+	}
+	ungetc(c, f);
+	return(FALSE);
+}
+
+static void cleanUpAndFail(int ec)
+{
+	int retVal;
+
+	if ((srcMode == SM_F2F) && (opMode != OM_TEST) && deleteOutputOnInterrupt) {
+		if (noisy) {
+			error_msg("%s: Deleting output file %s, if it exists.\n", progName, outName);
+		}
+		if (outputHandleJustInCase != NULL) {
+			fclose(outputHandleJustInCase);
+		}
+		retVal = remove(outName);
+		if (retVal != 0) {
+			error_msg("%s: WARNING: deletion of output file (apparently) failed.\n", progName);
+		}
+	}
+	if (noisy && (numFileNames > 0) && (numFilesProcessed < numFileNames)) {
+		error_msg("%s: WARNING: some files have not been processed:\n"
+			"\t%d specified on command line, %d not processed yet.\n\n",
+			progName, numFileNames, numFileNames - numFilesProcessed );
+	}
+
+	exit(ec);
+}
+
+
+void panic(char *s)
+{
+	error_msg("\n%s: PANIC -- internal consistency error:\n"
+             "\t%s\n"
+             "\tThis is a BUG.  Please report it to me at:\n"
+             "\tjseward@acm.org\n",
+             progName, s);
+	cleanUpAndFail( 3 );
+}
+
+void BZ2_hbCreateDecodeTables(int *limit, int *base, int *perm, unsigned char *length, int minLen, int maxLen, int alphaSize )
+{
+	int 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];
+	}
+}
+
+int bz_get_small(DState *s)
+{
+	int cccc;
+	int nb, na, mid;
+	nb = 0;
+	na = 256;
+	do {
+		mid = (nb + na) >> 1;
+		if (s->tPos >= s->cftab[mid]) {
+			nb = mid;
+		} else {
+			na = mid;
+		}
+	}
+	while (na - nb != 1);
+	cccc = nb;
+	s->tPos = (((unsigned int)s->ll16[s->tPos]) |
+		(((((unsigned int)(s->ll4[(s->tPos) >> 1])) >>
+		(((s->tPos) << 2) & 0x4)) & 0xF) << 16));
+	return(cccc);
+}
+
+void assert_h(int errcode)
+{
+	error_msg_and_die("\n\nbzip2/libbzip2: internal error number %d.\n"
+		"This is a bug in bzip2/libbzip2, %s.\n"
+		"Please report it to me at: jseward@acm.org.  If this happened\n"
+		"when you were using some program which uses libbzip2 as a\n"
+		"component, you should also report this bug to the author(s)\n"
+		"of that program.  Please make an effort to report this bug;\n"
+		"timely and accurate bug reports eventually lead to higher\n"
+		"quality software.  Thanks.  Julian Seward, 21 March 2000.\n\n",
+		errcode, BZ_VERSION);
+}
+
+static int get_bits(DState *s, int *vvv, char nnn)
+{
+	while (1) {
+		if (s->bsLive >= nnn) {
+			*vvv = (s->bsBuff >> (s->bsLive-nnn)) & ((1 << nnn)-1);
+			s->bsLive -= nnn;
+			break;
+		}
+		if (s->strm->avail_in == 0) {
+			return(FALSE);
+		}
+		s->bsBuff = (s->bsBuff << 8) | ((unsigned int) (*((unsigned char*)(s->strm->next_in))));
+		s->bsLive += 8;
+		s->strm->next_in++;
+		s->strm->avail_in--;
+		s->strm->total_in_lo32++;
+		if (s->strm->total_in_lo32 == 0) {
+			s->strm->total_in_hi32++;
+		}
+	}
+	return(TRUE);
+}
+
+int bz_get_fast(DState *s)
+{
+	int cccc;
+	s->tPos = s->tt[s->tPos];
+	cccc = (unsigned char)(s->tPos & 0xff);
+	s->tPos >>= 8;
+	return(cccc);
+}
+
+/*---------------------------------------------------*/
+int BZ2_decompress(DState *s)
+{
+	int uc = 0;
+	int	retVal;
+	int	minLen,	maxLen;
+	bz_stream	*strm = s->strm;
+
+	/* stuff that needs to be saved/restored */
+	int  i;
+	int  j;
+	int  t;
+	int  alphaSize;
+	int  nGroups;
+	int  nSelectors;
+	int  EOB;
+	int  groupNo;
+	int  groupPos;
+	int  nextSym;
+	int  nblockMAX;
+	int  nblock;
+	int  es;
+	int  N;
+	int  curr;
+	int  zt;
+	int  zn; 
+	int  zvec;
+	int  zj;
+	int  gSel;
+	int  gMinlen;
+	int *gLimit;
+	int *gBase;
+	int *gPerm;
+	int switch_val;
+
+	int get_mtf_val_init(void)
+	{
+		if (groupPos == 0) {
+			groupNo++;
+			if (groupNo >= nSelectors) {
+				retVal = BZ_DATA_ERROR;
+				return(FALSE);
+			}
+			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;
+		return(TRUE);
+	}
+
+	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_val = s->state;
+	switch (switch_val) {
+		case BZ_X_MAGIC_1:
+			s->state = BZ_X_MAGIC_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 'B') {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_MAGIC_2:
+			s->state = BZ_X_MAGIC_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 'Z') {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_MAGIC_3:
+			s->state = BZ_X_MAGIC_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 'h') {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_MAGIC_4:
+			s->state = BZ_X_MAGIC_4;
+			if (get_bits(s, &s->blockSize100k, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if ((s->blockSize100k < '1') || (s->blockSize100k > '9')) {
+				retVal = BZ_DATA_ERROR_MAGIC;
+				goto save_state_and_return;
+			}
+			s->blockSize100k -= '0';
+
+			if (s->smallDecompress) {
+				s->ll16 = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(unsigned short), 1);
+				s->ll4 = (strm->bzalloc)(strm->opaque, ((1 + s->blockSize100k * 100000) >> 1) * sizeof(unsigned char), 1);
+
+				if (s->ll16 == NULL || s->ll4 == NULL) {
+					retVal = BZ_MEM_ERROR;
+					goto save_state_and_return;
+				}
+			} else {
+				s->tt = (strm->bzalloc)(strm->opaque, s->blockSize100k * 100000 * sizeof(int), 1);
+				if (s->tt == NULL) {
+					retVal = BZ_MEM_ERROR;
+					goto save_state_and_return;
+				}
+			}
+
+		case BZ_X_BLKHDR_1:
+			s->state = BZ_X_BLKHDR_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+
+			if (uc == 0x17) {
+				goto endhdr_2;
+			}
+			if (uc != 0x31) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_2:
+			s->state = BZ_X_BLKHDR_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x41) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_3:
+			s->state = BZ_X_BLKHDR_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x59) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_4:
+			s->state = BZ_X_BLKHDR_4;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x26) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_5:
+			s->state = BZ_X_BLKHDR_5;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x53) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_BLKHDR_6:
+			s->state = BZ_X_BLKHDR_6;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x59) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		s->currBlockNo++;
+		if (s->verbosity >= 2) {
+			error_msg("\n    [%d: huff+mtf ", s->currBlockNo);
+		}
+		s->storedBlockCRC = 0;
+
+		case BZ_X_BCRC_1:
+			s->state = BZ_X_BCRC_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_BCRC_2:
+			s->state = BZ_X_BCRC_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_BCRC_3:
+			s->state = BZ_X_BCRC_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_BCRC_4:
+			s->state = BZ_X_BCRC_4;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedBlockCRC = (s->storedBlockCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_RANDBIT:
+			s->state = BZ_X_RANDBIT;
+			{
+				int tmp = s->blockRandomised;
+				const int ret = get_bits(s, &tmp, 1);
+				s->blockRandomised = tmp;
+				if (ret == FALSE) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+			}
+
+			s->origPtr = 0;
+
+		case BZ_X_ORIGPTR_1:
+			s->state = BZ_X_ORIGPTR_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->origPtr = (s->origPtr << 8) | ((int)uc);
+
+		case BZ_X_ORIGPTR_2:
+			s->state = BZ_X_ORIGPTR_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->origPtr = (s->origPtr << 8) | ((int)uc);
+
+		case BZ_X_ORIGPTR_3:
+			s->state = BZ_X_ORIGPTR_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->origPtr = (s->origPtr << 8) | ((int)uc);
+
+			if (s->origPtr < 0) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			if (s->origPtr > 10 + 100000*s->blockSize100k) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+			/*--- Receive the mapping table ---*/
+		case BZ_X_MAPPING_1:
+			for (i = 0; i < 16; i++) {
+				s->state = BZ_X_MAPPING_1;
+				if (get_bits(s, &uc, 1) == FALSE) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+				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++) {
+					case BZ_X_MAPPING_2:
+						s->state = BZ_X_MAPPING_2;
+						if (get_bits(s, &uc, 1) == FALSE) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						if (uc == 1) {
+							s->inUse[i * 16 + j] = TRUE;
+						}
+					}
+				}
+			}
+
+			s->nInUse = 0;
+			for (i = 0; i < 256; i++) {
+				if (s->inUse[i]) {
+					s->seqToUnseq[s->nInUse] = i;
+					s->nInUse++;
+				}
+			}
+			if (s->nInUse == 0) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			alphaSize = s->nInUse+2;
+
+		/*--- Now the selectors ---*/
+		case BZ_X_SELECTOR_1:
+			s->state = BZ_X_SELECTOR_1;
+			if (get_bits(s, &nGroups, 3) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (nGroups < 2 || nGroups > 6) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_SELECTOR_2:
+			s->state = BZ_X_SELECTOR_2;
+			if (get_bits(s, &nSelectors, 15) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (nSelectors < 1) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+
+
+			for (i = 0; i < nSelectors; i++) {
+				j = 0;
+				while (1) {
+					case BZ_X_SELECTOR_3:
+					s->state = BZ_X_SELECTOR_3;
+					if (get_bits(s, &uc, 1) == FALSE) {
+						retVal = BZ_OK;
+						goto save_state_and_return;
+					}
+					if (uc == 0) {
+						break;
+					}
+					j++;
+					if (j >= nGroups) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+				}
+				s->selectorMtf[i] = j;
+			}
+
+			/*--- Undo the MTF values for the selectors. ---*/
+			{
+				unsigned char 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++) {
+			case BZ_X_CODING_1:
+				s->state = BZ_X_CODING_1;
+				if (get_bits(s, &curr, 5) == FALSE) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+			for (i = 0; i < alphaSize; i++) {
+				while (TRUE) {
+					if (curr < 1 || curr > 20) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+
+					case BZ_X_CODING_2:
+						s->state = BZ_X_CODING_2;
+						if (get_bits(s, &uc, 1) == FALSE) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						if (uc == 0) {
+							break;
+						}
+
+					case BZ_X_CODING_3:
+						s->state = BZ_X_CODING_3;
+						if (get_bits(s, &uc, 1) == FALSE) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						if (uc == 0) {
+							curr++;
+						} else {
+							curr--;
+						}
+				}
+				s->len[t][i] = curr;
+			}
+		}
+
+		/*--- Create the Huffman decoding tables ---*/
+		for (t = 0; t < nGroups; t++) {
+			minLen = 32;
+			maxLen = 0;
+			for (i = 0; i < alphaSize; i++) {
+				if (s->len[t][i] > maxLen) {
+					maxLen = s->len[t][i];
+				}
+				if (s->len[t][i] < minLen) {
+					minLen = s->len[t][i];
+				}
+			}
+
+			BZ2_hbCreateDecodeTables ( 
+				&(s->limit[t][0]), 
+				&(s->base[t][0]), 
+				&(s->perm[t][0]), 
+				&(s->len[t][0]),
+				minLen, maxLen, alphaSize
+				);
+
+
+			s->minLens[t] = minLen;
+		}
+
+		/*--- Now the MTF values ---*/
+
+		EOB      = s->nInUse+1;
+		nblockMAX = 100000 * s->blockSize100k;
+		groupNo  = -1;
+		groupPos = 0;
+
+		for (i = 0; i <= 255; i++) {
+			s->unzftab[i] = 0;
+		}
+		/*-- MTF init --*/
+		{
+			int 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] = (unsigned char)(ii * MTFL_SIZE + jj);
+					kk--;
+				}
+				s->mtfbase[ii] = kk + 1;
+			}
+		}
+		/*-- end MTF init --*/
+
+		nblock = 0;
+
+		if (get_mtf_val_init() == FALSE) {
+			goto save_state_and_return;
+		}
+		case BZ_X_MTF_1:
+			s->state = BZ_X_MTF_1;
+			if (get_bits(s, &zvec, zn) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			while (1) {
+				if (zn > 20 /* the longest code */) {
+					retVal = BZ_DATA_ERROR;
+					goto save_state_and_return;
+				}
+				if (zvec <= gLimit[zn]) {
+					break;
+				}
+				zn++;
+
+				case BZ_X_MTF_2:
+					s->state = BZ_X_MTF_2;
+					if (get_bits(s, &zj, 1) == FALSE) {
+						retVal = BZ_OK;
+						goto save_state_and_return;
+					}
+					zvec = (zvec << 1) | zj;
+			}
+			if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			nextSym = gPerm[zvec - gBase[zn]];
+
+		while (1) {
+			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;
+				if (get_mtf_val_init() == FALSE) {
+					goto save_state_and_return;
+				}
+				case BZ_X_MTF_3:
+					s->state = BZ_X_MTF_3;
+					if (get_bits(s, &zvec, zn) == FALSE) {
+						retVal = BZ_OK;
+						goto save_state_and_return;
+					}
+					while (1) {
+						if (zn > 20 /* the longest code */) {
+							retVal = BZ_DATA_ERROR;
+							goto save_state_and_return;
+						}
+						if (zvec <= gLimit[zn]) {
+							break;
+						}
+						zn++;
+
+						case BZ_X_MTF_4:
+							s->state = BZ_X_MTF_4;
+							if (get_bits(s, &zj, 1) == FALSE) {
+								retVal = BZ_OK;
+								goto save_state_and_return;
+							}
+							zvec = (zvec << 1) | zj;
+					}
+					if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+
+					}
+					nextSym = gPerm[zvec - gBase[zn]];
+			}
+			while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
+
+			es++;
+			uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
+			s->unzftab[uc] += es;
+
+			if (s->smallDecompress) {
+				while (es > 0) {
+					if (nblock >= nblockMAX) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+					s->ll16[nblock] = (unsigned short)uc;
+					nblock++;
+					es--;
+				}
+			} else {
+				while (es > 0) {
+					if (nblock >= nblockMAX) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+					s->tt[nblock] = (unsigned int)uc;
+					nblock++;
+					es--;
+				}
+			}
+			continue;
+		} else {
+			if (nblock >= nblockMAX) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			/*-- uc = MTF ( nextSym-1 ) --*/
+			{
+				int ii, jj, kk, pp, lno, off;
+				unsigned int nn;
+				nn = (unsigned int)(nextSym - 1);
+
+				if (nn < MTFL_SIZE) {
+					/* avoid general-case expense */
+					pp = s->mtfbase[0];
+					uc = s->mtfa[pp+nn];
+					while (nn > 3) {
+						int 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] = (unsigned short)(s->seqToUnseq[uc]);
+			} else {
+				s->tt[nblock]   = (unsigned int)(s->seqToUnseq[uc]);
+			}
+			nblock++;
+
+			if (get_mtf_val_init() == FALSE) {
+				goto save_state_and_return;
+			}
+			case BZ_X_MTF_5:
+				s->state = BZ_X_MTF_5;
+				if (get_bits(s, &zvec, zn) == FALSE) {
+					retVal = BZ_OK;
+					goto save_state_and_return;
+				}
+				while (1) {
+					if (zn > 20 /* the longest code */) {
+						retVal = BZ_DATA_ERROR;
+						goto save_state_and_return;
+					}
+					if (zvec <= gLimit[zn]) {
+						break;
+					}
+					zn++;
+
+					case BZ_X_MTF_6:
+						s->state = BZ_X_MTF_6;
+						if (get_bits(s, &zj, 1) == FALSE) {
+							retVal = BZ_OK;
+							goto save_state_and_return;
+						}
+						zvec = (zvec << 1) | zj;
+				}
+			if (zvec - gBase[zn] < 0 || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			nextSym = gPerm[zvec - gBase[zn]];
+			continue;
+		}
+	}
+
+	/* Now we know what nblock is, we can do a better sanity
+		check on s->origPtr.
+	*/
+	if (s->origPtr < 0 || s->origPtr >= nblock) {
+		retVal = BZ_DATA_ERROR;
+		goto save_state_and_return;
+	}
+	s->state_out_len = 0;
+	s->state_out_ch  = 0;
+	s->calculatedBlockCRC = 0xffffffffL;
+	s->state = BZ_X_OUTPUT;
+	if (s->verbosity >= 2) {
+		error_msg("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 = (unsigned char)(s->ll16[i]);
+			s->ll16[i] = (unsigned short)(s->cftabCopy[uc] & 0x0000ffff);
+			if (((i) & 0x1) == 0) {
+				s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (s->cftabCopy[uc] >> 16);
+			} else {
+				s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((s->cftabCopy[uc] >> 16) << 4);
+			}
+			s->cftabCopy[uc]++;
+		}
+
+		/*-- Compute T^(-1) by pointer reversal on T --*/
+		i = s->origPtr;
+		j = (((unsigned int)s->ll16[i]) |
+			(((((unsigned int)(s->ll4[(i) >> 1])) >>
+			(((i) << 2) & 0x4)) & 0xF) << 16));
+
+		do {
+			const int tmp = (((unsigned int)s->ll16[j]) |
+				(((((unsigned int)(s->ll4[(j) >> 1])) >>
+				(((j) << 2) & 0x4)) & 0xF) << 16));
+
+			s->ll16[j] = (unsigned short)(i & 0x0000ffff);
+			if (((j) & 0x1) == 0) {
+				s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0xf0) | (i >> 16);
+			} else {
+				s->ll4[(j) >> 1] = (s->ll4[(j) >> 1] & 0x0f) | ((i >> 16) << 4);
+			}
+			i = j;
+			j = tmp;
+		}
+		while (i != s->origPtr);
+			s->tPos = s->origPtr;
+			s->nblock_used = 0;
+			if (s->blockRandomised) {
+				s->rNToGo = 0;
+				s->rTPos  = 0;
+				s->k0 = bz_get_small(s);
+				s->nblock_used++;
+				bz_rand_udp_mask(s);
+				s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+			} else {
+				s->k0 = bz_get_small(s);
+				s->nblock_used++;
+			}
+		} else {
+			/*-- compute the T^(-1) vector --*/
+			for (i = 0; i < nblock; i++) {
+				uc = (unsigned char)(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) {
+				s->rNToGo = 0;
+				s->rTPos  = 0;
+				s->k0 = bz_get_fast(s);
+
+				s->nblock_used++;
+				bz_rand_udp_mask(s);
+				s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+			} else {
+				s->k0 = bz_get_fast(s);
+				s->nblock_used++;
+			}
+		}
+
+		retVal = BZ_OK;
+		goto save_state_and_return;
+
+endhdr_2:
+		case BZ_X_ENDHDR_2:
+			s->state = BZ_X_ENDHDR_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x72) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_3:
+			s->state = BZ_X_ENDHDR_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x45) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_4:
+			s->state = BZ_X_ENDHDR_4;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x38) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_5:
+			s->state = BZ_X_ENDHDR_5;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x50) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+
+		case BZ_X_ENDHDR_6:
+			s->state = BZ_X_ENDHDR_6;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			if (uc != 0x90) {
+				retVal = BZ_DATA_ERROR;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = 0;
+
+		case BZ_X_CCRC_1:
+			s->state = BZ_X_CCRC_1;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+		case BZ_X_CCRC_2:
+			s->state = BZ_X_CCRC_2;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_CCRC_3:
+			s->state = BZ_X_CCRC_3;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+
+		case BZ_X_CCRC_4:
+			s->state = BZ_X_CCRC_4;
+			if (get_bits(s, &uc, 8) == FALSE) {
+				retVal = BZ_OK;
+				goto save_state_and_return;
+			}
+			s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((unsigned int)uc);
+
+		s->state = BZ_X_IDLE;
+		retVal = BZ_STREAM_END;
+		goto save_state_and_return;
+
+default:
+		printf("switch val is %d\n", switch_val);
+		assert_h(4001);
+	}
+
+	assert_h(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;   
+}
+
+static void *default_bzalloc(void *opaque, int items, int size)
+{
+	void *v = xmalloc(items *size);
+	return v;
+}
+
+static void default_bzfree(void *opaque, void *addr)
+{
+	if (addr != NULL) {
+		free(addr);
+	}
+}
+
+//int BZ2_bzDecompressInit(bz_stream* strm, int verbosity_level, int small)
+int BZ2_bzDecompressInit(bz_stream* strm, int small)
+{
+	DState* s;
+
+	if (sizeof(int) != 4) {
+		return BZ_CONFIG_ERROR;
+	}
+	if (sizeof(short) != 2) {
+		return BZ_CONFIG_ERROR;
+	}
+	if (sizeof(char) != 1) {
+		return BZ_CONFIG_ERROR;
+	}
+	if (strm == NULL) {
+		return BZ_PARAM_ERROR;
+	}
+	if (small != 0 && small != 1) {
+		return BZ_PARAM_ERROR;
+	}
+//	if (verbosity_level < 0 || verbosity_level > 4) {
+//		return BZ_PARAM_ERROR;
+//	}
+	if (strm->bzalloc == NULL) {
+		strm->bzalloc = default_bzalloc;
+	}
+	if (strm->bzfree == NULL) {
+		strm->bzfree = default_bzfree;
+	}
+	s = (strm->bzalloc)(strm->opaque, sizeof(DState), 1);
+	if (s == NULL) {
+		return BZ_MEM_ERROR;
+	}
+	s->strm                  = strm;
+	strm->state              = s;
+	s->state                 = BZ_X_MAGIC_1;
+	s->bsLive                = 0;
+	s->bsBuff                = 0;
+	s->calculatedCombinedCRC = 0;
+	strm->total_in_lo32      = 0;
+	strm->total_in_hi32      = 0;
+	strm->total_out_lo32     = 0;
+	strm->total_out_hi32     = 0;
+	s->smallDecompress       = (unsigned char)small;
+	s->ll4                   = NULL;
+	s->ll16                  = NULL;
+	s->tt                    = NULL;
+	s->currBlockNo           = 0;
+//	s->verbosity             = verbosity_level;
+
+	return BZ_OK;
+}
+
+void bz_seterr(int eee, int *bzerror, bzFile **bzf)
+{
+	if (bzerror != NULL) {
+		*bzerror = eee;
+	}
+	if (*bzf != NULL) {
+		(*bzf)->lastErr = eee;
+	}
+}
+
+void BZ2_bzReadClose(int *bzerror, void *b)
+{
+	bzFile* bzf = (bzFile*)b;
+
+	bz_seterr(BZ_OK, bzerror, &bzf);
+	if (bzf == NULL) {
+		bz_seterr(BZ_OK, bzerror, &bzf);
+		return;
+	}
+
+	if (bzf->writing) {
+		bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf);
+		return;
+	}
+
+	if (bzf->initialisedOk) {
+		bz_stream *strm = &(bzf->strm);
+		DState *s;
+		if (strm == NULL) {
+			return;
+		}
+		s = strm->state;
+		if ((s == NULL) || (s->strm != strm)) {
+			return;
+		}
+		if (s->tt != NULL) {
+			(strm->bzfree)(strm->opaque,(s->tt));
+		}
+		if (s->ll16 != NULL) {
+			(strm->bzfree)(strm->opaque,(s->ll16));
+		}
+		if (s->ll4 != NULL) {
+			(strm->bzfree)(strm->opaque,(s->ll4));
+		}
+		(strm->bzfree)(strm->opaque,(strm->state));
+		strm->state = NULL;
+		return;
+	}
+	free(bzf);
+}
+
+static void unRLE_obuf_to_output_FAST(DState *s)
+{
+	unsigned char k1;
+
+	if (s->blockRandomised) {
+		while (1) {
+			/* try to finish existing run */
+			while (1) {
+				if (s->strm->avail_out == 0) {
+					return;
+				}
+				if (s->state_out_len == 0) {
+					break;
+				}
+				*((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
+				s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
+					BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
+					((unsigned char)s->state_out_ch)];
+				s->state_out_len--;
+				s->strm->next_out++;
+				s->strm->avail_out--;
+				s->strm->total_out_lo32++;
+				if (s->strm->total_out_lo32 == 0) {
+					s->strm->total_out_hi32++;
+				}
+			}
+   
+			/* can a new run be started? */
+			if (s->nblock_used == s->save_nblock+1) {
+				return;
+			}
+			s->state_out_len = 1;
+			s->state_out_ch = s->k0;
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			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;
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			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;
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			if (s->nblock_used == s->save_nblock+1) {
+				continue;
+			}
+			if (k1 != s->k0) {
+				s->k0 = k1;
+				continue;
+			}
+
+			k1 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			s->state_out_len = ((int)k1) + 4;
+			s->k0 = bz_get_fast(s);
+			bz_rand_udp_mask(s);
+			s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+		}
+	} else {
+		/* restore */
+		unsigned int c_calculatedBlockCRC = s->calculatedBlockCRC;
+		unsigned char c_state_out_ch       = s->state_out_ch;
+		int c_state_out_len      = s->state_out_len;
+		int c_nblock_used        = s->nblock_used;
+		int c_k0                 = s->k0;
+		unsigned int	*c_tt                 = s->tt;
+		unsigned int	c_tPos               = s->tPos;
+		char	*cs_next_out          = s->strm->next_out;
+		unsigned int  cs_avail_out         = s->strm->avail_out;
+		/* end restore */
+
+		unsigned int avail_out_INIT = cs_avail_out;
+		int        s_save_nblockPP = s->save_nblock+1;
+		unsigned int total_out_lo32_old;
+
+		while (1) {
+			/* 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;
+					}
+					*((unsigned char *)(cs_next_out)) = c_state_out_ch;
+					c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
+						BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
+						((unsigned char)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;
+					}
+					*((unsigned char *)(cs_next_out)) = c_state_out_ch;
+					c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^
+						BZ2_crc32Table[(c_calculatedBlockCRC >> 24) ^
+						((unsigned char)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;
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			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;
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+			if (c_nblock_used == s_save_nblockPP) {
+				continue;
+			}
+			if (k1 != c_k0) {
+				c_k0 = k1;
+				continue;
+			}
+
+			c_state_out_len = 3;
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+			if (c_nblock_used == s_save_nblockPP) {
+				continue;
+			}
+			if (k1 != c_k0) {
+				c_k0 = k1;
+				continue;
+			}
+   
+			c_tPos = c_tt[c_tPos];
+			k1 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+			c_state_out_len = ((int)k1) + 4;
+
+			c_tPos = c_tt[c_tPos];
+			c_k0 = (unsigned char)(c_tPos & 0xff);
+			c_tPos >>= 8;
+
+			c_nblock_used++;
+		}
+
+return_notr:
+		total_out_lo32_old = s->strm->total_out_lo32;
+		s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
+		if (s->strm->total_out_lo32 < total_out_lo32_old) {
+			s->strm->total_out_hi32++;
+		}
+
+		/* save */
+		s->calculatedBlockCRC = c_calculatedBlockCRC;
+		s->state_out_ch       = c_state_out_ch;
+		s->state_out_len      = c_state_out_len;
+		s->nblock_used        = c_nblock_used;
+		s->k0                 = c_k0;
+		s->tt                 = c_tt;
+		s->tPos               = c_tPos;
+		s->strm->next_out     = cs_next_out;
+		s->strm->avail_out    = cs_avail_out;
+		/* end save */
+	}
+}
+
+static void unRLE_obuf_to_output_SMALL(DState *s)
+{
+	unsigned char k1;
+
+	if (s->blockRandomised) {
+		while (1) {
+			/* try to finish existing run */
+			while (1) {
+				if (s->strm->avail_out == 0) {
+					return;
+				}
+				if (s->state_out_len == 0) {
+					break;
+				}
+				*((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
+				s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
+					BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
+					((unsigned char)s->state_out_ch)];
+				s->state_out_len--;
+				s->strm->next_out++;
+				s->strm->avail_out--;
+				s->strm->total_out_lo32++;
+				if (s->strm->total_out_lo32 == 0) {
+					s->strm->total_out_hi32++;
+				}
+			}
+
+			/* can a new run be started? */
+			if (s->nblock_used == s->save_nblock+1) {
+				return;
+			}
+               
+			s->state_out_len = 1;
+			s->state_out_ch = s->k0;
+			k1 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			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;
+			k1 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			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;
+			k1 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			if (s->nblock_used == s->save_nblock+1) {
+				continue;
+			}
+			if (k1 != s->k0) {
+				s->k0 = k1;
+				continue;
+			}
+			k1 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			k1 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+			s->state_out_len = ((int)k1) + 4;
+			s->k0 = bz_get_small(s);
+			bz_rand_udp_mask(s);
+			s->k0 ^= ((s->rNToGo == 1) ? 1 : 0);
+			s->nblock_used++;
+		}
+	} else {
+		while (1) {
+			/* try to finish existing run */
+			while (1) {
+				if (s->strm->avail_out == 0) {
+					return;
+				}
+				if (s->state_out_len == 0) {
+					break;
+				}
+				*((unsigned char *)(s->strm->next_out)) = s->state_out_ch;
+				s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^
+					BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^
+					((unsigned char)s->state_out_ch)];
+				s->state_out_len--;
+				s->strm->next_out++;
+				s->strm->avail_out--;
+				s->strm->total_out_lo32++;
+				if (s->strm->total_out_lo32 == 0) {
+					s->strm->total_out_hi32++;
+				}
+			}
+
+			/* can a new run be started? */
+			if (s->nblock_used == s->save_nblock+1) {
+				return;
+			}
+
+			s->state_out_len = 1;
+			s->state_out_ch = s->k0;
+			k1 = bz_get_small(s);
+			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;
+			k1 = bz_get_small(s);
+			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;
+			k1 = bz_get_small(s);
+			s->nblock_used++;
+			if (s->nblock_used == s->save_nblock+1) {
+				continue;
+			}
+			if (k1 != s->k0) {
+				s->k0 = k1;
+				continue;
+			}
+
+			k1 = bz_get_small(s);
+			s->nblock_used++;
+			s->state_out_len = ((int)k1) + 4;
+			s->k0 = bz_get_small(s);
+			s->nblock_used++;
+		}
+	}
+}
+
+int BZ2_bzDecompress(bz_stream *strm)
+{
+	DState* s;
+	if (strm == NULL) {
+		return BZ_PARAM_ERROR;
+	}
+	s = strm->state;
+	if (s == NULL) {
+		return BZ_PARAM_ERROR;
+	}
+	if (s->strm != strm) {
+		return BZ_PARAM_ERROR;
+	}
+
+	while (1) {
+		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) {
+				s->calculatedBlockCRC = ~(s->calculatedBlockCRC);
+				if (s->verbosity >= 3) {
+					error_msg("{0x%x, 0x%x}", s->storedBlockCRC, s->calculatedBlockCRC);
+				}
+				if (s->verbosity >= 2) {
+					error_msg("]");
+				}
+				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) {
+			int r = BZ2_decompress(s);
+			if (r == BZ_STREAM_END) {
+				if (s->verbosity >= 3) {
+					error_msg("\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;
+			}
+		}
+	}
+
+	assert_h(6001);
+
+	return(0);  /*NOTREACHED*/
+}
+
+int BZ2_bzRead(int *bzerror, void *b, void *buf, int len)
+{
+	int n, ret;
+	bzFile *bzf = (bzFile*)b;
+
+	bz_seterr(BZ_OK, bzerror, &bzf);
+
+	if (bzf == NULL || buf == NULL || len < 0) {
+		bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
+		return 0;
+	}
+
+	if (bzf->writing) {
+		bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf);
+		return 0;
+	}
+
+	if (len == 0) {
+		bz_seterr(BZ_OK, bzerror, &bzf);
+		return 0;
+	}
+
+	bzf->strm.avail_out = len;
+	bzf->strm.next_out = buf;
+
+	while (1) {
+		if (ferror(bzf->handle)) {
+			bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
+			return 0;
+		}
+		if ((bzf->strm.avail_in == 0) && !myfeof(bzf->handle)) {
+			n = fread(bzf->buf, sizeof(unsigned char), BZ_MAX_UNUSED, bzf->handle);
+			if (ferror(bzf->handle)) {
+				bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
+				return 0;
+			}
+			bzf->bufN = n;
+			bzf->strm.avail_in = bzf->bufN;
+			bzf->strm.next_in = bzf->buf;
+		}
+
+		ret = BZ2_bzDecompress(&(bzf->strm));
+
+		if ((ret != BZ_OK) && (ret != BZ_STREAM_END)) {
+			bz_seterr(ret, bzerror, &bzf);
+			return 0;
+		}
+
+		if ((ret == BZ_OK) && myfeof(bzf->handle) &&
+			(bzf->strm.avail_in == 0) && (bzf->strm.avail_out > 0)) {
+			bz_seterr(BZ_UNEXPECTED_EOF, bzerror, &bzf);
+			return(0);
+		}
+
+		if (ret == BZ_STREAM_END) {
+			bz_seterr(BZ_STREAM_END, bzerror, &bzf);
+			return(len - bzf->strm.avail_out);
+		}
+		if (bzf->strm.avail_out == 0) {
+			bz_seterr(BZ_OK, bzerror, &bzf);
+			return(len);
+		}
+	}
+	return(0); /*not reached*/
+}
+
+void BZ2_bzReadGetUnused(int *bzerror, void *b, void **unused, int *nUnused)
+{
+	bzFile *bzf = (bzFile*)b;
+	if (bzf == NULL) {
+		bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
+		return;
+	}
+	if (bzf->lastErr != BZ_STREAM_END) {
+		bz_seterr(BZ_SEQUENCE_ERROR, bzerror, &bzf);
+		return;
+	}
+	if (unused == NULL || nUnused == NULL) {
+		bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
+		return;
+	}
+
+	bz_seterr(BZ_OK, bzerror, &bzf);
+	*nUnused = bzf->strm.avail_in;
+	*unused = bzf->strm.next_in;
+}
+
+void *BZ2_bzReadOpen(int *bzerror, FILE *f, int small, void *unused, int nUnused)
+{
+	bzFile *bzf = NULL;
+	int ret;
+
+	bz_seterr(BZ_OK, bzerror, &bzf);
+
+	if (f == NULL || (small != 0 && small != 1) ||
+		(unused != NULL && (nUnused < 0 || nUnused > BZ_MAX_UNUSED)) ||
+//		(verbosity_level < 0 || verbosity_level > 4) ||
+		(unused == NULL && nUnused != 0)) {
+		bz_seterr(BZ_PARAM_ERROR, bzerror, &bzf);
+		return NULL;
+	}
+
+	if (ferror(f)) {
+		bz_seterr(BZ_IO_ERROR, bzerror, &bzf);
+		return NULL;
+	}
+
+	bzf = xmalloc(sizeof(bzFile));
+	if (bzf == NULL) {
+		bz_seterr(BZ_MEM_ERROR, bzerror, &bzf);
+		return NULL;
+	}
+	bz_seterr(BZ_OK, bzerror, &bzf);
+
+	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] = *((unsigned char *)(unused)); bzf->bufN++;
+		unused = ((void *)( 1 + ((unsigned char *)(unused))  ));
+		nUnused--;
+	}
+
+	ret = BZ2_bzDecompressInit(&(bzf->strm), small);
+	if (ret != BZ_OK) {
+		bz_seterr(ret, bzerror, &bzf);
+		free(bzf);
+		return NULL;
+	}
+
+	bzf->strm.avail_in = bzf->bufN;
+	bzf->strm.next_in  = bzf->buf;
+
+	bzf->initialisedOk = TRUE;
+	return bzf;   
+}
+
+static unsigned char uncompressStream(FILE *zStream, FILE *stream)
+{
+	unsigned char unused[BZ_MAX_UNUSED];
+	unsigned char *unusedTmp;
+	unsigned char obuf[5000];
+	void *bzf = NULL;
+	int bzerr_dummy;
+	int bzerr;
+	int nread;
+	int nUnused;
+	int streamNo;
+	int ret;
+	int i;
+
+	nUnused = 0;
+	streamNo = 0;
+
+	if (ferror(stream)) {
+		goto errhandler_io;
+	}
+	if (ferror(zStream)) {
+		goto errhandler_io;
+	}
+
+	while(1) {
+		bzf = BZ2_bzReadOpen(&bzerr, zStream, (int)smallMode, unused, nUnused);
+		if (bzf == NULL || bzerr != BZ_OK) {
+			goto errhandler;
+		}
+		streamNo++;
+
+		while (bzerr == BZ_OK) {
+			nread = BZ2_bzRead(&bzerr, bzf, obuf, 5000);
+			if (bzerr == BZ_DATA_ERROR_MAGIC) {
+				goto errhandler;
+			}
+			if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0) {
+				fwrite(obuf, sizeof(unsigned char), nread, stream);
+			}
+			if (ferror(stream)) {
+				goto errhandler_io;
+			}
+		}
+		if (bzerr != BZ_STREAM_END) {
+			goto errhandler;
+		}
+		BZ2_bzReadGetUnused(&bzerr, bzf, (void **)(&unusedTmp), &nUnused);
+		if (bzerr != BZ_OK) {
+			panic("decompress:bzReadGetUnused");
+		}
+		for (i = 0; i < nUnused; i++) {
+			unused[i] = unusedTmp[i];
+		}
+		BZ2_bzReadClose(&bzerr, bzf);
+		if (bzerr != BZ_OK) {
+			panic("decompress:bzReadGetUnused");
+		}
+		if ((nUnused == 0) && myfeof(zStream)) {
+			break;
+		}
+	}
+
+	if (ferror(zStream)) {
+		goto errhandler_io;
+	}
+	ret = fclose(zStream);
+	if (ret == EOF) {
+		goto errhandler_io;
+	}
+	if (ferror(stream)) {
+		goto errhandler_io;
+	}
+	ret = fflush(stream);
+	if (ret != 0) {
+		goto errhandler_io;
+	}
+	if (stream != stdout) {
+		ret = fclose(stream);
+		if (ret == EOF) {
+			goto errhandler_io;
+		}
+	}
+//	if (verbosity_level >= 2) {
+//		fprintf(stderr,"\n    ");
+//	}
+	return TRUE;
+
+errhandler:
+	BZ2_bzReadClose ( &bzerr_dummy, bzf );
+	switch (bzerr) {
+		case BZ_CONFIG_ERROR:
+			error_msg("bzip2: I'm not configured correctly for this platform!\n"
+				"\tI require Int32, Int16 and Char to have sizes\n"
+				"\tof 4, 2 and 1 bytes to run properly, and they don't.\n"
+				"\tProbably you can fix this by defining them correctly,\n"
+				"\tand recompiling.  Bye!\n" );
+			exit(3);
+		case BZ_IO_ERROR:
+errhandler_io:
+			error_msg("\n%s: I/O or other error, bailing out.  "
+				"Possible reason follows.\n", progName);
+			perror(progName);
+			cleanUpAndFail(1);
+		case BZ_DATA_ERROR:
+			error_msg("\n%s: Data integrity error when decompressing.\n", progName);
+			cleanUpAndFail(2);
+		case BZ_MEM_ERROR:
+			error_msg("\n%s: couldn't allocate enough memory\n", progName);
+			cleanUpAndFail(1);
+		case BZ_UNEXPECTED_EOF:
+			error_msg("\n%s: Compressed file ends unexpectedly;\n\t"
+				"perhaps it is corrupted?  *Possible* reason follows.\n", progName);
+			perror(progName);
+			cleanUpAndFail(2);
+		case BZ_DATA_ERROR_MAGIC:
+			if (zStream != stdin) {
+				fclose(zStream);
+			}
+			if (stream != stdout) {
+				fclose(stream);
+			}
+			if (streamNo == 1) {
+				return FALSE;
+			} else {
+				if (noisy) {
+					error_msg("\n%s: %s: trailing garbage after EOF ignored\n", progName, inName );
+				}
+				return TRUE;       
+			}
+		default:
+			panic ( "decompress:unexpected error" );
+	}
+
+	panic("decompress:end");
+	return(TRUE); /*notreached*/
+}
+
+int bunzip2_main(int argc, char **argv)
+{
+	FILE *src_stream;
+	FILE *dst_stream;
+	char *save_name;
+	char *save_name_ptr;
+	if (argc != 2) {
+		show_usage();
+	}
+	src_stream = xfopen(argv[1], "r");
+	save_name = strdup(argv[1]);
+	save_name_ptr = strrchr(save_name, '.');
+	if (save_name_ptr == NULL) {
+		return(FALSE);
+	}
+	if (strcmp(save_name_ptr, ".bz2") != 0) {
+		error_msg("Invalid extension, expected .bz2");
+	}
+	*save_name_ptr = '\0';	
+	dst_stream = xfopen(save_name, "w");
+	uncompressStream(src_stream, dst_stream);
+
+	return(TRUE);
+}
diff --git a/include/applets.h b/include/applets.h
index ab8727b..461c878 100644
--- a/include/applets.h
+++ b/include/applets.h
@@ -64,6 +64,9 @@
 #ifdef BB_BASENAME
 	APPLET(basename, basename_main, _BB_DIR_USR_BIN)
 #endif
+#ifdef BB_BUNZIP2
+	APPLET(bunzip2, bunzip2_main, _BB_DIR_USR_BIN)
+#endif
 	APPLET_NOUSAGE("busybox", busybox_main, _BB_DIR_BIN)
 #ifdef BB_CAT
 	APPLET(cat, cat_main, _BB_DIR_BIN)
diff --git a/include/usage.h b/include/usage.h
index f504ac1..0b095a4 100644
--- a/include/usage.h
+++ b/include/usage.h
@@ -51,6 +51,12 @@
 	"$ basename /foo/bar.txt .txt\n" \
 	"bar"
 
+#define bunzip2_trivial_usage \
+	"FILE"
+#define bunzip2_full_usage \
+	"Uncompress FILE to current directory, stripping its .bz2 extension.\n"\
+	" -k is assumed" 
+
 #define cat_trivial_usage \
 	"[FILE]..."
 #define cat_full_usage \
diff --git a/usage.h b/usage.h
index f504ac1..0b095a4 100644
--- a/usage.h
+++ b/usage.h
@@ -51,6 +51,12 @@
 	"$ basename /foo/bar.txt .txt\n" \
 	"bar"
 
+#define bunzip2_trivial_usage \
+	"FILE"
+#define bunzip2_full_usage \
+	"Uncompress FILE to current directory, stripping its .bz2 extension.\n"\
+	" -k is assumed" 
+
 #define cat_trivial_usage \
 	"[FILE]..."
 #define cat_full_usage \
author	Glenn L McGrath	2001-10-05 03:48:57 +0000
committer	Glenn L McGrath	2001-10-05 03:48:57 +0000
commit	24e2833cdfcba3505bbde9b56906bbcbb67aa2be (patch)
tree	9555ce149062ec16167d77aa6a5d7a55850c511d
parent	2e772edacf70e9ff45a00a34af4c94e04d490fc2 (diff)
download	busybox-24e2833cdfcba3505bbde9b56906bbcbb67aa2be.zip busybox-24e2833cdfcba3505bbde9b56906bbcbb67aa2be.tar.gz