From f9267e8a2db672f39630e344c2f7d010125ddc33 Mon Sep 17 00:00:00 2001
From: Michal Vyskocil <mvyskocil@suse.cz>
Date: Tue, 20 Nov 2012 11:08:51 +0100
Subject: [PATCH 1/2] merge bzip2 edge case improvement from Commons Compress

This patch replaces the CBZip2OutputStream.java with one made as a
result of a following patch. Seems that ant 1.7.1 adds a lot of
incompatible changes, so cherry-pick or a port of the patch from 1.7.0
was not possible.

commit 76c046966c2d24df4d655e0b6369cc3a133d5063
Author: Stefan Bodewig <bodewig@apache.org>
Date:   Mon May 21 04:33:42 2012 +0000

    merge bzip2 edge case improvement from Commons Compress

    git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@1340895 13f79535-47bb-0310-9956-ffa450edef68
---
 src/main/org/apache/tools/bzip2/BlockSort.java     | 1081 +++++++++
 .../org/apache/tools/bzip2/CBZip2OutputStream.java | 2560 ++++++++++----------
 .../org/apache/tools/bzip2/BlockSortTest.java      |  171 ++
 3 files changed, 2506 insertions(+), 1306 deletions(-)
 create mode 100644 src/main/org/apache/tools/bzip2/BlockSort.java
 create mode 100644 src/tests/junit/org/apache/tools/bzip2/BlockSortTest.java

diff --git a/src/main/org/apache/tools/bzip2/BlockSort.java b/src/main/org/apache/tools/bzip2/BlockSort.java
new file mode 100644
index 0000000..f997bab
--- /dev/null
+++ b/src/main/org/apache/tools/bzip2/BlockSort.java
@@ -0,0 +1,1081 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tools.bzip2;
+
+import java.util.BitSet;
+
+/**
+ * Encapsulates the Burrows-Wheeler sorting algorithm needed by {@link
+ * CBZip2OutputStream}.
+ *
+ * <p>This class is based on a Java port of Julian Seward's
+ * blocksort.c in his libbzip2</p>
+ *
+ * <p>The Burrows-Wheeler transform is a reversible transform of the
+ * original data that is supposed to group similiar bytes close to
+ * each other.  The idea is to sort all permutations of the input and
+ * only keep the last byte of each permutation.  E.g. for "Commons
+ * Compress" you'd get:</p>
+ *
+ * <pre>
+ *  CompressCommons
+ * Commons Compress
+ * CompressCommons 
+ * essCommons Compr
+ * mmons CompressCo
+ * mons CompressCom
+ * mpressCommons Co
+ * ns CompressCommo
+ * ommons CompressC
+ * ompressCommons C
+ * ons CompressComm
+ * pressCommons Com
+ * ressCommons Comp
+ * s CompressCommon
+ * sCommons Compres
+ * ssCommons Compre
+ * </pre>
+ *
+ * <p>Which results in a new text "ss romooCCmmpnse", in adition the
+ * index of the first line that contained the original text is kept -
+ * in this case it is 1.  The idea is that in a long English text all
+ * permutations that start with "he" are likely suffixes of a "the" and
+ * thus they end in "t" leading to a larger block of "t"s that can
+ * better be compressed by the subsequent Move-to-Front, run-length
+ * und Huffman encoding steps.</p>
+ *
+ * <p>For more information see for example:</p>
+ * <ul>
+ *   <li><a
+ *   href="http://www.hpl.hp.com/techreports/Compaq-DEC/SRC-RR-124.pdf">Burrows,
+ *   M. and Wheeler, D.: A Block-sorting Lossless Data Compression
+ *   Algorithm</a></li>
+ *   <li><a href="http://webglimpse.net/pubs/suffix.pdf">Manber, U. and
+ *   Myers, G.: Suffix arrays: A new method for on-line string
+ *   searches</a></li>
+ *   <li><a
+ *   href="http://www.cs.tufts.edu/~nr/comp150fp/archive/bob-sedgewick/fast-strings.pdf">Bentley,
+ *   J.L. and Sedgewick, R.: Fast Algorithms for Sorting and Searching
+ *   Strings</a></li>
+ * </ul>
+ *
+ * @NotThreadSafe
+ */
+class BlockSort {
+
+    /*
+     * Some of the constructs used in the C code cannot be ported
+     * literally to Java - for example macros, unsigned types.  Some
+     * code has been hand-tuned to improve performance.  In order to
+     * avoid memory pressure some structures are reused for several
+     * blocks and some memory is even shared between sorting and the
+     * MTF stage even though either algorithm uses it for its own
+     * purpose.
+     *
+     * Comments preserved from the actual C code are prefixed with
+     * "LBZ2:".
+     */
+
+    /*
+     * 2012-05-20 Stefan Bodewig:
+     *
+     * This class seems to mix several revisions of libbzip2's code.
+     * The mainSort function and those used by it look closer to the
+     * 0.9.5 version but show some variations introduced later.  At
+     * the same time the logic of Compress 1.4 to randomize the block
+     * on bad input has been dropped after libbzip2 0.9.0 and replaced
+     * by a fallback sorting algorithm.
+     *
+     * I've added the fallbackSort function of 1.0.6 and tried to
+     * integrate it with the existing code without touching too much.
+     * I've also removed the now unused randomization code.
+     */
+
+    /*
+     * LBZ2: If you are ever unlucky/improbable enough to get a stack
+     * overflow whilst sorting, increase the following constant and
+     * try again. In practice I have never seen the stack go above 27
+     * elems, so the following limit seems very generous.
+     */
+    private static final int QSORT_STACK_SIZE = 1000;
+
+    private static final int FALLBACK_QSORT_STACK_SIZE = 100;
+
+    private static final int STACK_SIZE =
+        QSORT_STACK_SIZE < FALLBACK_QSORT_STACK_SIZE
+        ? FALLBACK_QSORT_STACK_SIZE : QSORT_STACK_SIZE;
+
+    /*
+     * Used when sorting. If too many long comparisons happen, we stop sorting,
+     * and use fallbackSort instead.
+     */
+    private int workDone;
+    private int workLimit;
+    private boolean firstAttempt;
+
+    private final int[] stack_ll = new int[STACK_SIZE]; // 4000 byte
+    private final int[] stack_hh = new int[STACK_SIZE]; // 4000 byte
+    private final int[] stack_dd = new int[QSORT_STACK_SIZE]; // 4000 byte
+
+    private final int[] mainSort_runningOrder = new int[256]; // 1024 byte
+    private final int[] mainSort_copy = new int[256]; // 1024 byte
+    private final boolean[] mainSort_bigDone = new boolean[256]; // 256 byte
+
+    private final int[] ftab = new int[65537]; // 262148 byte
+
+    /**
+     * Array instance identical to Data's sfmap, both are used only
+     * temporarily and indepently, so we do not need to allocate
+     * additional memory.
+     */
+    private final char[] quadrant;
+
+    BlockSort(final CBZip2OutputStream.Data data) {
+        this.quadrant = data.sfmap;
+    }
+
+    void blockSort(final CBZip2OutputStream.Data data, final int last) {
+        this.workLimit = WORK_FACTOR * last;
+        this.workDone = 0;
+        this.firstAttempt = true;
+
+        if (last + 1 < 10000) {
+            fallbackSort(data, last);
+        } else {
+            mainSort(data, last);
+
+            if (this.firstAttempt && (this.workDone > this.workLimit)) {
+                fallbackSort(data, last);
+            }
+        }
+
+        final int[] fmap = data.fmap;
+        data.origPtr = -1;
+        for (int i = 0; i <= last; i++) {
+            if (fmap[i] == 0) {
+                data.origPtr = i;
+                break;
+            }
+        }
+
+        // assert (data.origPtr != -1) : data.origPtr;
+    }
+
+    /**
+     * Adapt fallbackSort to the expected interface of the rest of the
+     * code, in particular deal with the fact that block starts at
+     * offset 1 (in libbzip2 1.0.6 it starts at 0).
+     */
+    final void fallbackSort(final CBZip2OutputStream.Data data,
+                            final int last) {
+        data.block[0] = data.block[last + 1];
+        fallbackSort(data.fmap, data.block, last + 1);
+        for (int i = 0; i < last + 1; i++) {
+            --data.fmap[i];
+        }
+        for (int i = 0; i < last + 1; i++) {
+            if (data.fmap[i] == -1) {
+                data.fmap[i] = last;
+                break;
+            }
+        }
+    }
+
+/*---------------------------------------------*/
+
+/*---------------------------------------------*/
+/*--- LBZ2: Fallback O(N log(N)^2) sorting        ---*/
+/*--- algorithm, for repetitive blocks      ---*/
+/*---------------------------------------------*/
+
+    /*
+     * This is the fallback sorting algorithm libbzip2 1.0.6 uses for
+     * repetitive or very short inputs.
+     *
+     * The idea is inspired by Manber-Myers string suffix sorting
+     * algorithm.  First a bucket sort places each permutation of the
+     * block into a bucket based on its first byte.  Permutations are
+     * represented by pointers to their first character kept in
+     * (partially) sorted order inside the array ftab.
+     *
+     * The next step visits all buckets in order and performs a
+     * quicksort on all permutations of the bucket based on the index
+     * of the bucket the second byte of the permutation belongs to,
+     * thereby forming new buckets.  When arrived here the
+     * permutations are sorted up to the second character and we have
+     * buckets of permutations that are identical up to two
+     * characters.
+     *
+     * Repeat the step of quicksorting each bucket, now based on the
+     * bucket holding the sequence of the third and forth character
+     * leading to four byte buckets.  Repeat this doubling of bucket
+     * sizes until all buckets only contain single permutations or the
+     * bucket size exceeds the block size.
+     *
+     * I.e.
+     *
+     * "abraba" form three buckets for the chars "a", "b", and "r" in
+     * the first step with
+     *
+     * fmap = { 'a:' 5, 3, 0, 'b:' 4, 1, 'r', 2 }
+     *
+     * when looking at the bucket of "a"s the second characters are in
+     * the buckets that start with fmap-index 0 (rolled over), 3 and 3
+     * respectively, forming two new buckets "aa" and "ab", so we get
+     *
+     * fmap = { 'aa:' 5, 'ab:' 3, 0, 'ba:' 4, 'br': 1, 'ra:' 2 }
+     *
+     * since the last bucket only contained a single item it didn't
+     * have to be sorted at all.
+     *
+     * There now is just one bucket with more than one permutation
+     * that remains to be sorted.  For the permutation that starts
+     * with index 3 the third and forth char are in bucket 'aa' at
+     * index 0 and for the one starting at block index 0 they are in
+     * bucket 'ra' with sort index 5.  The fully sorted order then becomes.
+     *
+     * fmap = { 5, 3, 0, 4, 1, 2 }
+     * 
+     */
+
+    /**
+     * @param fmap points to the index of the starting point of a
+     *        permutation inside the block of data in the current
+     *        partially sorted order
+     * @param eclass points from the index of a character inside the
+     *        block to the first index in fmap that contains the
+     *        bucket of its suffix that is sorted in this step.
+     * @param lo lower boundary of the fmap-interval to be sorted 
+     * @param hi upper boundary of the fmap-interval to be sorted 
+     */
+    private void fallbackSimpleSort(int[] fmap, 
+                                    int[] eclass, 
+                                    int lo, 
+                                    int hi) {
+        if (lo == hi) {
+            return;
+        }
+
+        int j;
+        if (hi - lo > 3) {
+            for (int i = hi - 4; i >= lo; i--) {
+                int tmp = fmap[i];
+                int ec_tmp = eclass[tmp];
+                for (j = i + 4; j <= hi && ec_tmp > eclass[fmap[j]];
+                     j += 4) {
+                    fmap[j - 4] = fmap[j];
+                }
+                fmap[j - 4] = tmp;
+            }
+        }
+
+        for (int i = hi - 1; i >= lo; i--) {
+            int tmp = fmap[i];
+            int ec_tmp = eclass[tmp];
+            for (j = i + 1; j <= hi && ec_tmp > eclass[fmap[j]]; j++) {
+                fmap[j - 1] = fmap[j];
+            }
+            fmap[j-1] = tmp;
+        }
+    }
+
+    private static final int FALLBACK_QSORT_SMALL_THRESH = 10;
+
+    /**
+     * swaps two values in fmap
+     */
+    private void fswap(int[] fmap, int zz1, int zz2) {
+        int zztmp = fmap[zz1];
+        fmap[zz1] = fmap[zz2];
+        fmap[zz2] = zztmp;
+    }
+
+    /**
+     * swaps two intervals starting at yyp1 and yyp2 of length yyn inside fmap.
+     */
+    private void fvswap(int[] fmap, int yyp1, int yyp2, int yyn) {
+        while (yyn > 0) {
+            fswap(fmap, yyp1, yyp2);
+            yyp1++; yyp2++; yyn--;
+        }
+    }
+
+    private int fmin(int a, int b) {
+        return a < b ? a : b;
+    }
+
+    private void fpush(int sp, int lz, int hz) {
+        stack_ll[sp] = lz;
+        stack_hh[sp] = hz;
+    }
+
+    private int[] fpop(int sp) {
+        return new int[] { stack_ll[sp], stack_hh[sp] };
+    }
+
+    /**
+     * @param fmap points to the index of the starting point of a
+     *        permutation inside the block of data in the current
+     *        partially sorted order
+     * @param eclass points from the index of a character inside the
+     *        block to the first index in fmap that contains the
+     *        bucket of its suffix that is sorted in this step.
+     * @param loSt lower boundary of the fmap-interval to be sorted 
+     * @param hiSt upper boundary of the fmap-interval to be sorted 
+     */
+    private void fallbackQSort3(int[] fmap, 
+                                int[] eclass, 
+                                int loSt, 
+                                int hiSt) {
+        int lo, unLo, ltLo, hi, unHi, gtHi, n;
+
+        long r = 0;
+        int sp = 0;
+        fpush(sp++, loSt, hiSt);
+
+        while (sp > 0) {
+            int[] s = fpop(--sp);
+            lo = s[0]; hi = s[1];
+
+            if (hi - lo < FALLBACK_QSORT_SMALL_THRESH) {
+                fallbackSimpleSort(fmap, eclass, lo, hi);
+                continue;
+            }
+
+            /* LBZ2: Random partitioning.  Median of 3 sometimes fails to
+               avoid bad cases.  Median of 9 seems to help but 
+               looks rather expensive.  This too seems to work but
+               is cheaper.  Guidance for the magic constants 
+               7621 and 32768 is taken from Sedgewick's algorithms
+               book, chapter 35.
+            */
+            r = ((r * 7621) + 1) % 32768;
+            long r3 = r % 3, med;
+            if (r3 == 0) {
+                med = eclass[fmap[lo]]; 
+            } else if (r3 == 1) {
+                med = eclass[fmap[(lo + hi) >>> 1]];
+            } else {
+                med = eclass[fmap[hi]];
+            }
+
+            unLo = ltLo = lo;
+            unHi = gtHi = hi;
+
+            // looks like the ternary partition attributed to Wegner
+            // in the cited Sedgewick paper
+            while (true) {
+                while (true) {
+                    if (unLo > unHi) {
+                        break;
+                    }
+                    n = eclass[fmap[unLo]] - (int) med;
+                    if (n == 0) { 
+                        fswap(fmap, unLo, ltLo); 
+                        ltLo++; unLo++; 
+                        continue; 
+                    }
+                    if (n > 0) {
+                        break;
+                    }
+                    unLo++;
+                }
+                while (true) {
+                    if (unLo > unHi) {
+                        break;
+                    }
+                    n = eclass[fmap[unHi]] - (int) med;
+                    if (n == 0) {
+                        fswap(fmap, unHi, gtHi); 
+                        gtHi--; unHi--; 
+                        continue; 
+                    }
+                    if (n < 0) {
+                        break;
+                    }
+                    unHi--;
+                }
+                if (unLo > unHi) {
+                    break;
+                }
+                fswap(fmap, unLo, unHi); unLo++; unHi--;
+            }
+
+            if (gtHi < ltLo) {
+                continue;
+            }
+
+            n = fmin(ltLo - lo, unLo - ltLo);
+            fvswap(fmap, lo, unLo - n, n);
+            int m = fmin(hi - gtHi, gtHi - unHi);
+            fvswap(fmap, unHi + 1, hi - m + 1, m);
+
+            n = lo + unLo - ltLo - 1;
+            m = hi - (gtHi - unHi) + 1;
+
+            if (n - lo > hi - m) {
+                fpush(sp++, lo, n);
+                fpush(sp++, m, hi);
+            } else {
+                fpush(sp++, m, hi);
+                fpush(sp++, lo, n);
+            }
+        }
+    }
+
+
+/*---------------------------------------------*/
+
+    private int[] eclass;
+
+    private int[] getEclass() {
+        return eclass == null
+            ? (eclass = new int[quadrant.length / 2]) : eclass;
+    }
+
+    /*
+     * The C code uses an array of ints (each int holding 32 flags) to
+     * represents the bucket-start flags (bhtab).  It also contains
+     * optimizations to skip over 32 consecutively set or
+     * consecutively unset bits on word boundaries at once.  For now
+     * I've chosen to use the simpler but potentially slower code
+     * using BitSet - also in the hope that using the BitSet#nextXXX
+     * methods may be fast enough.
+     */
+
+    /**
+     * @param fmap points to the index of the starting point of a
+     *        permutation inside the block of data in the current
+     *        partially sorted order
+     * @param block the original data
+     * @param nblock size of the block
+     * @param off offset of first byte to sort in block
+     */
+    final void fallbackSort(int[] fmap, byte[] block, int nblock) {
+        final int[] ftab = new int[257];
+        int H, i, j, k, l, r, cc, cc1;
+        int nNotDone;
+        int nBhtab;
+        final int[] eclass = getEclass();
+
+        for (i = 0; i < nblock; i++) {
+            eclass[i] = 0;
+        }
+        /*--
+          LBZ2: Initial 1-char radix sort to generate
+          initial fmap and initial BH bits.
+          --*/
+        for (i = 0; i < nblock; i++) {
+            ftab[block[i] & 0xff]++;
+        }
+        for (i = 1; i < 257;    i++) {
+            ftab[i] += ftab[i - 1];
+        }
+
+        for (i = 0; i < nblock; i++) {
+            j = block[i] & 0xff;
+            k = ftab[j] - 1;
+            ftab[j] = k;
+            fmap[k] = i;
+        }
+
+        nBhtab = 64 + nblock;
+        BitSet bhtab = new BitSet(nBhtab);
+        for (i = 0; i < 256; i++) {
+            bhtab.set(ftab[i]);
+        }
+
+        /*--
+          LBZ2: Inductively refine the buckets.  Kind-of an
+          "exponential radix sort" (!), inspired by the
+          Manber-Myers suffix array construction algorithm.
+          --*/
+
+        /*-- LBZ2: set sentinel bits for block-end detection --*/
+        for (i = 0; i < 32; i++) { 
+            bhtab.set(nblock + 2 * i);
+            bhtab.clear(nblock + 2 * i + 1);
+        }
+
+        /*-- LBZ2: the log(N) loop --*/
+        H = 1;
+        while (true) {
+
+            j = 0;
+            for (i = 0; i < nblock; i++) {
+                if (bhtab.get(i)) {
+                    j = i;
+                }
+                k = fmap[i] - H;
+                if (k < 0) {
+                    k += nblock;
+                }
+                eclass[k] = j;
+            }
+
+            nNotDone = 0;
+            r = -1;
+            while (true) {
+
+                /*-- LBZ2: find the next non-singleton bucket --*/
+                k = r + 1;
+                k = bhtab.nextClearBit(k);
+                l = k - 1;
+                if (l >= nblock) {
+                    break;
+                }
+                k = bhtab.nextSetBit(k + 1);
+                r = k - 1;
+                if (r >= nblock) {
+                    break;
+                }
+
+                /*-- LBZ2: now [l, r] bracket current bucket --*/
+                if (r > l) {
+                    nNotDone += (r - l + 1);
+                    fallbackQSort3(fmap, eclass, l, r);
+
+                    /*-- LBZ2: scan bucket and generate header bits-- */
+                    cc = -1;
+                    for (i = l; i <= r; i++) {
+                        cc1 = eclass[fmap[i]];
+                        if (cc != cc1) {
+                            bhtab.set(i);
+                            cc = cc1;
+                        }
+                    }
+                }
+            }
+
+            H *= 2;
+            if (H > nblock || nNotDone == 0) {
+                break;
+            }
+        }
+    }
+
+/*---------------------------------------------*/
+
+    /*
+     * LBZ2: Knuth's increments seem to work better than Incerpi-Sedgewick here.
+     * Possibly because the number of elems to sort is usually small, typically
+     * &lt;= 20.
+     */
+    private static final int[] INCS = { 1, 4, 13, 40, 121, 364, 1093, 3280,
+                                        9841, 29524, 88573, 265720, 797161,
+                                        2391484 };
+
+    /**
+     * This is the most hammered method of this class.
+     *
+     * <p>
+     * This is the version using unrolled loops. Normally I never use such ones
+     * in Java code. The unrolling has shown a noticable performance improvement
+     * on JRE 1.4.2 (Linux i586 / HotSpot Client). Of course it depends on the
+     * JIT compiler of the vm.
+     * </p>
+     */
+    private boolean mainSimpleSort(final CBZip2OutputStream.Data dataShadow,
+                                   final int lo, final int hi, final int d,
+                                   final int lastShadow) {
+        final int bigN = hi - lo + 1;
+        if (bigN < 2) {
+            return this.firstAttempt && (this.workDone > this.workLimit);
+        }
+
+        int hp = 0;
+        while (INCS[hp] < bigN) {
+            hp++;
+        }
+
+        final int[] fmap = dataShadow.fmap;
+        final char[] quadrant = this.quadrant;
+        final byte[] block = dataShadow.block;
+        final int lastPlus1 = lastShadow + 1;
+        final boolean firstAttemptShadow = this.firstAttempt;
+        final int workLimitShadow = this.workLimit;
+        int workDoneShadow = this.workDone;
+
+        // Following block contains unrolled code which could be shortened by
+        // coding it in additional loops.
+
+        HP: while (--hp >= 0) {
+            final int h = INCS[hp];
+            final int mj = lo + h - 1;
+
+            for (int i = lo + h; i <= hi;) {
+                // copy
+                for (int k = 3; (i <= hi) && (--k >= 0); i++) {
+                    final int v = fmap[i];
+                    final int vd = v + d;
+                    int j = i;
+
+                    // for (int a;
+                    // (j > mj) && mainGtU((a = fmap[j - h]) + d, vd,
+                    // block, quadrant, lastShadow);
+                    // j -= h) {
+                    // fmap[j] = a;
+                    // }
+                    //
+                    // unrolled version:
+
+                    // start inline mainGTU
+                    boolean onceRunned = false;
+                    int a = 0;
+
+                    HAMMER: while (true) {
+                        if (onceRunned) {
+                            fmap[j] = a;
+                            if ((j -= h) <= mj) {
+                                break HAMMER;
+                            }
+                        } else {
+                            onceRunned = true;
+                        }
+
+                        a = fmap[j - h];
+                        int i1 = a + d;
+                        int i2 = vd;
+
+                        // following could be done in a loop, but
+                        // unrolled it for performance:
+                        if (block[i1 + 1] == block[i2 + 1]) {
+                            if (block[i1 + 2] == block[i2 + 2]) {
+                                if (block[i1 + 3] == block[i2 + 3]) {
+                                    if (block[i1 + 4] == block[i2 + 4]) {
+                                        if (block[i1 + 5] == block[i2 + 5]) {
+                                            if (block[(i1 += 6)] == block[(i2 += 6)]) {
+                                                int x = lastShadow;
+                                                X: while (x > 0) {
+                                                    x -= 4;
+
+                                                    if (block[i1 + 1] == block[i2 + 1]) {
+                                                        if (quadrant[i1] == quadrant[i2]) {
+                                                            if (block[i1 + 2] == block[i2 + 2]) {
+                                                                if (quadrant[i1 + 1] == quadrant[i2 + 1]) {
+                                                                    if (block[i1 + 3] == block[i2 + 3]) {
+                                                                        if (quadrant[i1 + 2] == quadrant[i2 + 2]) {
+                                                                            if (block[i1 + 4] == block[i2 + 4]) {
+                                                                                if (quadrant[i1 + 3] == quadrant[i2 + 3]) {
+                                                                                    if ((i1 += 4) >= lastPlus1) {
+                                                                                        i1 -= lastPlus1;
+                                                                                    }
+                                                                                    if ((i2 += 4) >= lastPlus1) {
+                                                                                        i2 -= lastPlus1;
+                                                                                    }
+                                                                                    workDoneShadow++;
+                                                                                    continue X;
+                                                                                } else if ((quadrant[i1 + 3] > quadrant[i2 + 3])) {
+                                                                                    continue HAMMER;
+                                                                                } else {
+                                                                                    break HAMMER;
+                                                                                }
+                                                                            } else if ((block[i1 + 4] & 0xff) > (block[i2 + 4] & 0xff)) {
+                                                                                continue HAMMER;
+                                                                            } else {
+                                                                                break HAMMER;
+                                                                            }
+                                                                        } else if ((quadrant[i1 + 2] > quadrant[i2 + 2])) {
+                                                                            continue HAMMER;
+                                                                        } else {
+                                                                            break HAMMER;
+                                                                        }
+                                                                    } else if ((block[i1 + 3] & 0xff) > (block[i2 + 3] & 0xff)) {
+                                                                        continue HAMMER;
+                                                                    } else {
+                                                                        break HAMMER;
+                                                                    }
+                                                                } else if ((quadrant[i1 + 1] > quadrant[i2 + 1])) {
+                                                                    continue HAMMER;
+                                                                } else {
+                                                                    break HAMMER;
+                                                                }
+                                                            } else if ((block[i1 + 2] & 0xff) > (block[i2 + 2] & 0xff)) {
+                                                                continue HAMMER;
+                                                            } else {
+                                                                break HAMMER;
+                                                            }
+                                                        } else if ((quadrant[i1] > quadrant[i2])) {
+                                                            continue HAMMER;
+                                                        } else {
+                                                            break HAMMER;
+                                                        }
+                                                    } else if ((block[i1 + 1] & 0xff) > (block[i2 + 1] & 0xff)) {
+                                                        continue HAMMER;
+                                                    } else {
+                                                        break HAMMER;
+                                                    }
+
+                                                }
+                                                break HAMMER;
+                                            } // while x > 0
+                                            else {
+                                                if ((block[i1] & 0xff) > (block[i2] & 0xff)) {
+                                                    continue HAMMER;
+                                                } else {
+                                                    break HAMMER;
+                                                }
+                                            }
+                                        } else if ((block[i1 + 5] & 0xff) > (block[i2 + 5] & 0xff)) {
+                                            continue HAMMER;
+                                        } else {
+                                            break HAMMER;
+                                        }
+                                    } else if ((block[i1 + 4] & 0xff) > (block[i2 + 4] & 0xff)) {
+                                        continue HAMMER;
+                                    } else {
+                                        break HAMMER;
+                                    }
+                                } else if ((block[i1 + 3] & 0xff) > (block[i2 + 3] & 0xff)) {
+                                    continue HAMMER;
+                                } else {
+                                    break HAMMER;
+                                }
+                            } else if ((block[i1 + 2] & 0xff) > (block[i2 + 2] & 0xff)) {
+                                continue HAMMER;
+                            } else {
+                                break HAMMER;
+                            }
+                        } else if ((block[i1 + 1] & 0xff) > (block[i2 + 1] & 0xff)) {
+                            continue HAMMER;
+                        } else {
+                            break HAMMER;
+                        }
+
+                    } // HAMMER
+                    // end inline mainGTU
+
+                    fmap[j] = v;
+                }
+
+                if (firstAttemptShadow && (i <= hi)
+                    && (workDoneShadow > workLimitShadow)) {
+                    break HP;
+                }
+            }
+        }
+
+        this.workDone = workDoneShadow;
+        return firstAttemptShadow && (workDoneShadow > workLimitShadow);
+    }
+
+/*--
+   LBZ2: The following is an implementation of
+   an elegant 3-way quicksort for strings,
+   described in a paper "Fast Algorithms for
+   Sorting and Searching Strings", by Robert
+   Sedgewick and Jon L. Bentley.
+--*/
+
+    private static void vswap(int[] fmap, int p1, int p2, int n) {
+        n += p1;
+        while (p1 < n) {
+            int t = fmap[p1];
+            fmap[p1++] = fmap[p2];
+            fmap[p2++] = t;
+        }
+    }
+
+    private static byte med3(byte a, byte b, byte c) {
+        return (a < b) ? (b < c ? b : a < c ? c : a) : (b > c ? b : a > c ? c
+                                                        : a);
+    }
+
+    private static final int SMALL_THRESH = 20;
+    private static final int DEPTH_THRESH = 10;
+    private static final int WORK_FACTOR = 30;
+
+    /**
+     * Method "mainQSort3", file "blocksort.c", BZip2 1.0.2
+     */
+    private void mainQSort3(final CBZip2OutputStream.Data dataShadow,
+                            final int loSt, final int hiSt, final int dSt,
+                            final int last) {
+        final int[] stack_ll = this.stack_ll;
+        final int[] stack_hh = this.stack_hh;
+        final int[] stack_dd = this.stack_dd;
+        final int[] fmap = dataShadow.fmap;
+        final byte[] block = dataShadow.block;
+
+        stack_ll[0] = loSt;
+        stack_hh[0] = hiSt;
+        stack_dd[0] = dSt;
+
+        for (int sp = 1; --sp >= 0;) {
+            final int lo = stack_ll[sp];
+            final int hi = stack_hh[sp];
+            final int d = stack_dd[sp];
+
+            if ((hi - lo < SMALL_THRESH) || (d > DEPTH_THRESH)) {
+                if (mainSimpleSort(dataShadow, lo, hi, d, last)) {
+                    return;
+                }
+            } else {
+                final int d1 = d + 1;
+                final int med = med3(block[fmap[lo] + d1],
+                                     block[fmap[hi] + d1], block[fmap[(lo + hi) >>> 1] + d1]) & 0xff;
+
+                int unLo = lo;
+                int unHi = hi;
+                int ltLo = lo;
+                int gtHi = hi;
+
+                while (true) {
+                    while (unLo <= unHi) {
+                        final int n = (block[fmap[unLo] + d1] & 0xff)
+                            - med;
+                        if (n == 0) {
+                            final int temp = fmap[unLo];
+                            fmap[unLo++] = fmap[ltLo];
+                            fmap[ltLo++] = temp;
+                        } else if (n < 0) {
+                            unLo++;
+                        } else {
+                            break;
+                        }
+                    }
+
+                    while (unLo <= unHi) {
+                        final int n = (block[fmap[unHi] + d1] & 0xff)
+                            - med;
+                        if (n == 0) {
+                            final int temp = fmap[unHi];
+                            fmap[unHi--] = fmap[gtHi];
+                            fmap[gtHi--] = temp;
+                        } else if (n > 0) {
+                            unHi--;
+                        } else {
+                            break;
+                        }
+                    }
+
+                    if (unLo <= unHi) {
+                        final int temp = fmap[unLo];
+                        fmap[unLo++] = fmap[unHi];
+                        fmap[unHi--] = temp;
+                    } else {
+                        break;
+                    }
+                }
+
+                if (gtHi < ltLo) {
+                    stack_ll[sp] = lo;
+                    stack_hh[sp] = hi;
+                    stack_dd[sp] = d1;
+                    sp++;
+                } else {
+                    int n = ((ltLo - lo) < (unLo - ltLo)) ? (ltLo - lo)
+                        : (unLo - ltLo);
+                    vswap(fmap, lo, unLo - n, n);
+                    int m = ((hi - gtHi) < (gtHi - unHi)) ? (hi - gtHi)
+                        : (gtHi - unHi);
+                    vswap(fmap, unLo, hi - m + 1, m);
+
+                    n = lo + unLo - ltLo - 1;
+                    m = hi - (gtHi - unHi) + 1;
+
+                    stack_ll[sp] = lo;
+                    stack_hh[sp] = n;
+                    stack_dd[sp] = d;
+                    sp++;
+
+                    stack_ll[sp] = n + 1;
+                    stack_hh[sp] = m - 1;
+                    stack_dd[sp] = d1;
+                    sp++;
+
+                    stack_ll[sp] = m;
+                    stack_hh[sp] = hi;
+                    stack_dd[sp] = d;
+                    sp++;
+                }
+            }
+        }
+    }
+
+    private static final int SETMASK = (1 << 21);
+    private static final int CLEARMASK = (~SETMASK);
+
+    final void mainSort(final CBZip2OutputStream.Data dataShadow,
+                        final int lastShadow) {
+        final int[] runningOrder = this.mainSort_runningOrder;
+        final int[] copy = this.mainSort_copy;
+        final boolean[] bigDone = this.mainSort_bigDone;
+        final int[] ftab = this.ftab;
+        final byte[] block = dataShadow.block;
+        final int[] fmap = dataShadow.fmap;
+        final char[] quadrant = this.quadrant;
+        final int workLimitShadow = this.workLimit;
+        final boolean firstAttemptShadow = this.firstAttempt;
+
+        // LBZ2: Set up the 2-byte frequency table
+        for (int i = 65537; --i >= 0;) {
+            ftab[i] = 0;
+        }
+
+        /*
+         * In the various block-sized structures, live data runs from 0 to
+         * last+NUM_OVERSHOOT_BYTES inclusive. First, set up the overshoot area
+         * for block.
+         */
+        for (int i = 0; i < BZip2Constants.NUM_OVERSHOOT_BYTES; i++) {
+            block[lastShadow + i + 2] = block[(i % (lastShadow + 1)) + 1];
+        }
+        for (int i = lastShadow + BZip2Constants.NUM_OVERSHOOT_BYTES +1; --i >= 0;) {
+            quadrant[i] = 0;
+        }
+        block[0] = block[lastShadow + 1];
+
+        // LBZ2: Complete the initial radix sort:
+
+        int c1 = block[0] & 0xff;
+        for (int i = 0; i <= lastShadow; i++) {
+            final int c2 = block[i + 1] & 0xff;
+            ftab[(c1 << 8) + c2]++;
+            c1 = c2;
+        }
+
+        for (int i = 1; i <= 65536; i++) {
+            ftab[i] += ftab[i - 1];
+        }
+
+        c1 = block[1] & 0xff;
+        for (int i = 0; i < lastShadow; i++) {
+            final int c2 = block[i + 2] & 0xff;
+            fmap[--ftab[(c1 << 8) + c2]] = i;
+            c1 = c2;
+        }
+
+        fmap[--ftab[((block[lastShadow + 1] & 0xff) << 8) + (block[1] & 0xff)]] = lastShadow;
+
+        /*
+         * LBZ2: Now ftab contains the first loc of every small bucket. Calculate the
+         * running order, from smallest to largest big bucket.
+         */
+        for (int i = 256; --i >= 0;) {
+            bigDone[i] = false;
+            runningOrder[i] = i;
+        }
+
+        for (int h = 364; h != 1;) {
+            h /= 3;
+            for (int i = h; i <= 255; i++) {
+                final int vv = runningOrder[i];
+                final int a = ftab[(vv + 1) << 8] - ftab[vv << 8];
+                final int b = h - 1;
+                int j = i;
+                for (int ro = runningOrder[j - h]; (ftab[(ro + 1) << 8] - ftab[ro << 8]) > a; ro = runningOrder[j
+                                                                                                                - h]) {
+                    runningOrder[j] = ro;
+                    j -= h;
+                    if (j <= b) {
+                        break;
+                    }
+                }
+                runningOrder[j] = vv;
+            }
+        }
+
+        /*
+         * LBZ2: The main sorting loop.
+         */
+        for (int i = 0; i <= 255; i++) {
+            /*
+             * LBZ2: Process big buckets, starting with the least full.
+             */
+            final int ss = runningOrder[i];
+
+            // Step 1:
+            /*
+             * LBZ2: Complete the big bucket [ss] by quicksorting any unsorted small
+             * buckets [ss, j]. Hopefully previous pointer-scanning phases have
+             * already completed many of the small buckets [ss, j], so we don't
+             * have to sort them at all.
+             */
+            for (int j = 0; j <= 255; j++) {
+                final int sb = (ss << 8) + j;
+                final int ftab_sb = ftab[sb];
+                if ((ftab_sb & SETMASK) != SETMASK) {
+                    final int lo = ftab_sb & CLEARMASK;
+                    final int hi = (ftab[sb + 1] & CLEARMASK) - 1;
+                    if (hi > lo) {
+                        mainQSort3(dataShadow, lo, hi, 2, lastShadow);
+                        if (firstAttemptShadow
+                            && (this.workDone > workLimitShadow)) {
+                            return;
+                        }
+                    }
+                    ftab[sb] = ftab_sb | SETMASK;
+                }
+            }
+
+            // Step 2:
+            // LBZ2: Now scan this big bucket so as to synthesise the
+            // sorted order for small buckets [t, ss] for all t != ss.
+
+            for (int j = 0; j <= 255; j++) {
+                copy[j] = ftab[(j << 8) + ss] & CLEARMASK;
+            }
+
+            for (int j = ftab[ss << 8] & CLEARMASK, hj = (ftab[(ss + 1) << 8] & CLEARMASK); j < hj; j++) {
+                final int fmap_j = fmap[j];
+                c1 = block[fmap_j] & 0xff;
+                if (!bigDone[c1]) {
+                    fmap[copy[c1]] = (fmap_j == 0) ? lastShadow : (fmap_j - 1);
+                    copy[c1]++;
+                }
+            }
+
+            for (int j = 256; --j >= 0;) {
+                ftab[(j << 8) + ss] |= SETMASK;
+            }
+
+            // Step 3:
+            /*
+             * LBZ2: The ss big bucket is now done. Record this fact, and update the
+             * quadrant descriptors. Remember to update quadrants in the
+             * overshoot area too, if necessary. The "if (i < 255)" test merely
+             * skips this updating for the last bucket processed, since updating
+             * for the last bucket is pointless.
+             */
+            bigDone[ss] = true;
+
+            if (i < 255) {
+                final int bbStart = ftab[ss << 8] & CLEARMASK;
+                final int bbSize = (ftab[(ss + 1) << 8] & CLEARMASK) - bbStart;
+                int shifts = 0;
+
+                while ((bbSize >> shifts) > 65534) {
+                    shifts++;
+                }
+
+                for (int j = 0; j < bbSize; j++) {
+                    final int a2update = fmap[bbStart + j];
+                    final char qVal = (char) (j >> shifts);
+                    quadrant[a2update] = qVal;
+                    if (a2update < BZip2Constants.NUM_OVERSHOOT_BYTES) {
+                        quadrant[a2update + lastShadow + 1] = qVal;
+                    }
+                }
+            }
+
+        }
+    }
+
+}
diff --git a/src/main/org/apache/tools/bzip2/CBZip2OutputStream.java b/src/main/org/apache/tools/bzip2/CBZip2OutputStream.java
index c99c915..cbdd87a 100644
--- a/src/main/org/apache/tools/bzip2/CBZip2OutputStream.java
+++ b/src/main/org/apache/tools/bzip2/CBZip2OutputStream.java
@@ -24,1548 +24,1441 @@
 
 package org.apache.tools.bzip2;
 
-import java.io.OutputStream;
 import java.io.IOException;
+import java.io.OutputStream;
 
 /**
  * An output stream that compresses into the BZip2 format (without the file
  * header chars) into another stream.
  *
- * TODO:    Update to BZip2 1.0.1
+ * <p>
+ * The compression requires large amounts of memory. Thus you should call the
+ * {@link #close() close()} method as soon as possible, to force
+ * <tt>CBZip2OutputStream</tt> to release the allocated memory.
+ * </p>
+ *
+ * <p> You can shrink the amount of allocated memory and maybe raise
+ * the compression speed by choosing a lower blocksize, which in turn
+ * may cause a lower compression ratio. You can avoid unnecessary
+ * memory allocation by avoiding using a blocksize which is bigger
+ * than the size of the input.  </p>
+ *
+ * <p> You can compute the memory usage for compressing by the
+ * following formula: </p>
+ *
+ * <pre>
+ * &lt;code&gt;400k + (9 * blocksize)&lt;/code&gt;.
+ * </pre>
+ *
+ * <p> To get the memory required for decompression by {@link
+ * CBZip2InputStream CBZip2InputStream} use </p>
+ *
+ * <pre>
+ * &lt;code&gt;65k + (5 * blocksize)&lt;/code&gt;.
+ * </pre>
+ *
+ * <table width="100%" border="1">
+ * <colgroup> <col width="33%" /> <col width="33%" /> <col width="33%" />
+ * </colgroup>
+ * <tr>
+ * <th colspan="3">Memory usage by blocksize</th>
+ * </tr>
+ * <tr>
+ * <th align="right">Blocksize</th> <th align="right">Compression<br>
+ * memory usage</th> <th align="right">Decompression<br>
+ * memory usage</th>
+ * </tr>
+ * <tr>
+ * <td align="right">100k</td>
+ * <td align="right">1300k</td>
+ * <td align="right">565k</td>
+ * </tr>
+ * <tr>
+ * <td align="right">200k</td>
+ * <td align="right">2200k</td>
+ * <td align="right">1065k</td>
+ * </tr>
+ * <tr>
+ * <td align="right">300k</td>
+ * <td align="right">3100k</td>
+ * <td align="right">1565k</td>
+ * </tr>
+ * <tr>
+ * <td align="right">400k</td>
+ * <td align="right">4000k</td>
+ * <td align="right">2065k</td>
+ * </tr>
+ * <tr>
+ * <td align="right">500k</td>
+ * <td align="right">4900k</td>
+ * <td align="right">2565k</td>
+ * </tr>
+ * <tr>
+ * <td align="right">600k</td>
+ * <td align="right">5800k</td>
+ * <td align="right">3065k</td>
+ * </tr>
+ * <tr>
+ * <td align="right">700k</td>
+ * <td align="right">6700k</td>
+ * <td align="right">3565k</td>
+ * </tr>
+ * <tr>
+ * <td align="right">800k</td>
+ * <td align="right">7600k</td>
+ * <td align="right">4065k</td>
+ * </tr>
+ * <tr>
+ * <td align="right">900k</td>
+ * <td align="right">8500k</td>
+ * <td align="right">4565k</td>
+ * </tr>
+ * </table>
+ *
+ * <p>
+ * For decompression <tt>CBZip2InputStream</tt> allocates less memory if the
+ * bzipped input is smaller than one block.
+ * </p>
+ *
+ * <p>
+ * Instances of this class are not threadsafe.
+ * </p>
+ *
+ * <p>
+ * TODO: Update to BZip2 1.0.1
+ * </p>
+ *
  */
-public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
+public class CBZip2OutputStream extends OutputStream
+    implements BZip2Constants {
+
+    /**
+     * The minimum supported blocksize <tt> == 1</tt>.
+     */
+    public static final int MIN_BLOCKSIZE = 1;
+
+    /**
+     * The maximum supported blocksize <tt> == 9</tt>.
+     */
+    public static final int MAX_BLOCKSIZE = 9;
+
+    /**
+     * This constant is accessible by subclasses for historical
+     * purposes. If you don't know what it means then you don't need
+     * it.
+     */
     protected static final int SETMASK = (1 << 21);
+
+    /**
+     * This constant is accessible by subclasses for historical
+     * purposes. If you don't know what it means then you don't need
+     * it.
+     */
     protected static final int CLEARMASK = (~SETMASK);
+
+    /**
+     * This constant is accessible by subclasses for historical
+     * purposes. If you don't know what it means then you don't need
+     * it.
+     */
     protected static final int GREATER_ICOST = 15;
+
+    /**
+     * This constant is accessible by subclasses for historical
+     * purposes. If you don't know what it means then you don't need
+     * it.
+     */
     protected static final int LESSER_ICOST = 0;
+
+    /**
+     * This constant is accessible by subclasses for historical
+     * purposes. If you don't know what it means then you don't need
+     * it.
+     */
     protected static final int SMALL_THRESH = 20;
+
+    /**
+     * This constant is accessible by subclasses for historical
+     * purposes. If you don't know what it means then you don't need
+     * it.
+     */
     protected static final int DEPTH_THRESH = 10;
 
-    /*
-      If you are ever unlucky/improbable enough
-      to get a stack overflow whilst sorting,
-      increase the following constant and try
-      again.  In practice I have never seen the
-      stack go above 27 elems, so the following
-      limit seems very generous.
-    */
-    protected static final int QSORT_STACK_SIZE = 1000;
+    /**
+     * This constant is accessible by subclasses for historical
+     * purposes. If you don't know what it means then you don't need
+     * it.
+     */
+    protected static final int WORK_FACTOR = 30;
 
-    private static void panic() {
-        System.out.println("panic");
-        //throw new CError();
-    }
+    /**
+     * This constant is accessible by subclasses for historical
+     * purposes. If you don't know what it means then you don't need
+     * it.
+     * <p> If you are ever unlucky/improbable enough to get a stack
+     * overflow whilst sorting, increase the following constant and
+     * try again. In practice I have never seen the stack go above 27
+     * elems, so the following limit seems very generous.  </p>
+     */
+    protected static final int QSORT_STACK_SIZE = 1000;
 
-    private void makeMaps() {
-        int i;
-        nInUse = 0;
-        for (i = 0; i < 256; i++) {
-            if (inUse[i]) {
-                seqToUnseq[nInUse] = (char) i;
-                unseqToSeq[i] = (char) nInUse;
-                nInUse++;
-            }
-        }
-    }
+    /**
+     * Knuth's increments seem to work better than Incerpi-Sedgewick here.
+     * Possibly because the number of elems to sort is usually small, typically
+     * &lt;= 20.
+     */
+    private static final int[] INCS = { 1, 4, 13, 40, 121, 364, 1093, 3280,
+                                        9841, 29524, 88573, 265720, 797161,
+                                        2391484 };
 
+    /**
+     * This method is accessible by subclasses for historical
+     * purposes. If you don't know what it does then you don't need
+     * it.
+     */
     protected static void hbMakeCodeLengths(char[] len, int[] freq,
                                             int alphaSize, int maxLen) {
         /*
-          Nodes and heap entries run from 1.  Entry 0
-          for both the heap and nodes is a sentinel.
-        */
-        int nNodes, nHeap, n1, n2, i, j, k;
-        boolean  tooLong;
-
-        int[] heap = new int[MAX_ALPHA_SIZE + 2];
-        int[] weight = new int[MAX_ALPHA_SIZE * 2];
-        int[] parent = new int[MAX_ALPHA_SIZE * 2];
-
-        for (i = 0; i < alphaSize; i++) {
+         * Nodes and heap entries run from 1. Entry 0 for both the heap and
+         * nodes is a sentinel.
+         */
+        final int[] heap = new int[MAX_ALPHA_SIZE * 2];
+        final int[] weight = new int[MAX_ALPHA_SIZE * 2];
+        final int[] parent = new int[MAX_ALPHA_SIZE * 2];
+
+        for (int i = alphaSize; --i >= 0;) {
             weight[i + 1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
         }
 
-        while (true) {
-            nNodes = alphaSize;
-            nHeap = 0;
+        for (boolean tooLong = true; tooLong;) {
+            tooLong = false;
 
+            int nNodes = alphaSize;
+            int nHeap = 0;
             heap[0] = 0;
             weight[0] = 0;
             parent[0] = -2;
 
-            for (i = 1; i <= alphaSize; i++) {
+            for (int i = 1; i <= alphaSize; i++) {
                 parent[i] = -1;
                 nHeap++;
                 heap[nHeap] = i;
-                {
-                    int zz, tmp;
-                    zz = nHeap;
-                    tmp = heap[zz];
-                    while (weight[tmp] < weight[heap[zz >> 1]]) {
-                        heap[zz] = heap[zz >> 1];
-                        zz >>= 1;
-                    }
-                    heap[zz] = tmp;
+
+                int zz = nHeap;
+                int tmp = heap[zz];
+                while (weight[tmp] < weight[heap[zz >> 1]]) {
+                    heap[zz] = heap[zz >> 1];
+                    zz >>= 1;
                 }
+                heap[zz] = tmp;
             }
-            if (!(nHeap < (MAX_ALPHA_SIZE + 2))) {
-                panic();
-            }
+
+            // assert (nHeap < (MAX_ALPHA_SIZE + 2)) : nHeap;
 
             while (nHeap > 1) {
-                n1 = heap[1];
-                heap[1] = heap[nHeap];
-                nHeap--;
-                {
-                    int zz = 0, yy = 0, tmp = 0;
-                    zz = 1;
-                    tmp = heap[zz];
-                    while (true) {
-                        yy = zz << 1;
-                        if (yy > nHeap) {
-                            break;
-                        }
-                        if (yy < nHeap
-                            && weight[heap[yy + 1]] < weight[heap[yy]]) {
-                            yy++;
-                        }
-                        if (weight[tmp] < weight[heap[yy]]) {
-                            break;
-                        }
-                        heap[zz] = heap[yy];
-                        zz = yy;
-                    }
-                    heap[zz] = tmp;
-                }
-                n2 = heap[1];
+                int n1 = heap[1];
                 heap[1] = heap[nHeap];
                 nHeap--;
-                {
-                    int zz = 0, yy = 0, tmp = 0;
-                    zz = 1;
-                    tmp = heap[zz];
-                    while (true) {
-                        yy = zz << 1;
-                        if (yy > nHeap) {
-                            break;
-                        }
-                        if (yy < nHeap
-                            && weight[heap[yy + 1]] < weight[heap[yy]]) {
-                            yy++;
-                        }
-                        if (weight[tmp] < weight[heap[yy]]) {
-                            break;
-                        }
-                        heap[zz] = heap[yy];
-                        zz = yy;
-                    }
-                    heap[zz] = tmp;
-                }
-                nNodes++;
-                parent[n1] = parent[n2] = nNodes;
 
-                weight[nNodes] = ((weight[n1] & 0xffffff00)
-                                  + (weight[n2] & 0xffffff00))
-                    | (1 + (((weight[n1] & 0x000000ff)
-                            > (weight[n2] & 0x000000ff))
-                            ? (weight[n1] & 0x000000ff)
-                            : (weight[n2] & 0x000000ff)));
+                int yy = 0;
+                int zz = 1;
+                int tmp = heap[1];
 
-                parent[nNodes] = -1;
-                nHeap++;
-                heap[nHeap] = nNodes;
-                {
-                    int zz = 0, tmp = 0;
-                    zz = nHeap;
-                    tmp = heap[zz];
-                    while (weight[tmp] < weight[heap[zz >> 1]]) {
-                        heap[zz] = heap[zz >> 1];
-                        zz >>= 1;
-                    }
-                    heap[zz] = tmp;
-                }
-            }
-            if (!(nNodes < (MAX_ALPHA_SIZE * 2))) {
-                panic();
-            }
+                while (true) {
+                    yy = zz << 1;
 
-            tooLong = false;
-            for (i = 1; i <= alphaSize; i++) {
-                j = 0;
-                k = i;
-                while (parent[k] >= 0) {
-                    k = parent[k];
-                    j++;
-                }
-                len[i - 1] = (char) j;
-                if (j > maxLen) {
-                    tooLong = true;
-                }
-            }
+                    if (yy > nHeap) {
+                        break;
+                    }
 
-            if (!tooLong) {
-                break;
-            }
+                    if ((yy < nHeap)
+                        && (weight[heap[yy + 1]] < weight[heap[yy]])) {
+                        yy++;
+                    }
 
-            for (i = 1; i < alphaSize; i++) {
-                j = weight[i] >> 8;
-                j = 1 + (j / 2);
-                weight[i] = j << 8;
-            }
-        }
-    }
+                    if (weight[tmp] < weight[heap[yy]]) {
+                        break;
+                    }
 
-    /*
-      index of the last char in the block, so
-      the block size == last + 1.
-    */
-    int last;
+                    heap[zz] = heap[yy];
+                    zz = yy;
+                }
 
-    /*
-      index in zptr[] of original string after sorting.
-    */
-    int origPtr;
+                heap[zz] = tmp;
 
-    /*
-      always: in the range 0 .. 9.
-      The current block size is 100000 * this number.
-    */
-    int blockSize100k;
+                int n2 = heap[1];
+                heap[1] = heap[nHeap];
+                nHeap--;
 
-    boolean blockRandomised;
+                yy = 0;
+                zz = 1;
+                tmp = heap[1];
 
-    int bytesOut;
-    int bsBuff;
-    int bsLive;
-    CRC mCrc = new CRC();
+                while (true) {
+                    yy = zz << 1;
 
-    private boolean[] inUse = new boolean[256];
-    private int nInUse;
+                    if (yy > nHeap) {
+                        break;
+                    }
 
-    private char[] seqToUnseq = new char[256];
-    private char[] unseqToSeq = new char[256];
+                    if ((yy < nHeap)
+                        && (weight[heap[yy + 1]] < weight[heap[yy]])) {
+                        yy++;
+                    }
 
-    private char[] selector = new char[MAX_SELECTORS];
-    private char[] selectorMtf = new char[MAX_SELECTORS];
+                    if (weight[tmp] < weight[heap[yy]]) {
+                        break;
+                    }
 
-    private char[] block;
-    private int[] quadrant;
-    private int[] zptr;
-    private short[] szptr;
-    private int[] ftab;
+                    heap[zz] = heap[yy];
+                    zz = yy;
+                }
 
-    private int nMTF;
+                heap[zz] = tmp;
+                nNodes++;
+                parent[n1] = parent[n2] = nNodes;
 
-    private int[] mtfFreq = new int[MAX_ALPHA_SIZE];
+                final int weight_n1 = weight[n1];
+                final int weight_n2 = weight[n2];
+                weight[nNodes] = (((weight_n1 & 0xffffff00)
+                                   + (weight_n2 & 0xffffff00))
+                                  |
+                                  (1 + (((weight_n1 & 0x000000ff)
+                                         > (weight_n2 & 0x000000ff))
+                                        ? (weight_n1 & 0x000000ff)
+                                        : (weight_n2 & 0x000000ff))
+                                   ));
 
-    /*
-     * Used when sorting.  If too many long comparisons
-     * happen, we stop sorting, randomise the block
-     * slightly, and try again.
-     */
-    private int workFactor;
-    private int workDone;
-    private int workLimit;
-    private boolean firstAttempt;
-    private int nBlocksRandomised;
+                parent[nNodes] = -1;
+                nHeap++;
+                heap[nHeap] = nNodes;
 
-    private int currentChar = -1;
-    private int runLength = 0;
+                tmp = 0;
+                zz = nHeap;
+                tmp = heap[zz];
+                final int weight_tmp = weight[tmp];
+                while (weight_tmp < weight[heap[zz >> 1]]) {
+                    heap[zz] = heap[zz >> 1];
+                    zz >>= 1;
+                }
+                heap[zz] = tmp;
 
-    public CBZip2OutputStream(OutputStream inStream) throws IOException {
-        this(inStream, 9);
-    }
+            }
 
-    public CBZip2OutputStream(OutputStream inStream, int inBlockSize)
-        throws IOException {
-        block = null;
-        quadrant = null;
-        zptr = null;
-        ftab = null;
+            // assert (nNodes < (MAX_ALPHA_SIZE * 2)) : nNodes;
 
-        bsSetStream(inStream);
+            for (int i = 1; i <= alphaSize; i++) {
+                int j = 0;
+                int k = i;
 
-        workFactor = 50;
-        if (inBlockSize > 9) {
-            inBlockSize = 9;
-        }
-        if (inBlockSize < 1) {
-            inBlockSize = 1;
-        }
-        blockSize100k = inBlockSize;
-        allocateCompressStructures();
-        initialize();
-        initBlock();
-    }
+                for (int parent_k; (parent_k = parent[k]) >= 0;) {
+                    k = parent_k;
+                    j++;
+                }
 
-    /**
-     *
-     * modified by Oliver Merkel, 010128
-     *
-     */
-    public void write(int bv) throws IOException {
-        int b = (256 + bv) % 256;
-        if (currentChar != -1) {
-            if (currentChar == b) {
-                runLength++;
-                if (runLength > 254) {
-                    writeRun();
-                    currentChar = -1;
-                    runLength = 0;
+                len[i - 1] = (char) j;
+                if (j > maxLen) {
+                    tooLong = true;
                 }
-            } else {
-                writeRun();
-                runLength = 1;
-                currentChar = b;
             }
-        } else {
-            currentChar = b;
-            runLength++;
-        }
-    }
 
-    private void writeRun() throws IOException {
-        if (last < allowableBlockSize) {
-            inUse[currentChar] = true;
-            for (int i = 0; i < runLength; i++) {
-                mCrc.updateCRC((char) currentChar);
-            }
-            switch (runLength) {
-            case 1:
-                last++;
-                block[last + 1] = (char) currentChar;
-                break;
-            case 2:
-                last++;
-                block[last + 1] = (char) currentChar;
-                last++;
-                block[last + 1] = (char) currentChar;
-                break;
-            case 3:
-                last++;
-                block[last + 1] = (char) currentChar;
-                last++;
-                block[last + 1] = (char) currentChar;
-                last++;
-                block[last + 1] = (char) currentChar;
-                break;
-            default:
-                inUse[runLength - 4] = true;
-                last++;
-                block[last + 1] = (char) currentChar;
-                last++;
-                block[last + 1] = (char) currentChar;
-                last++;
-                block[last + 1] = (char) currentChar;
-                last++;
-                block[last + 1] = (char) currentChar;
-                last++;
-                block[last + 1] = (char) (runLength - 4);
-                break;
+            if (tooLong) {
+                for (int i = 1; i < alphaSize; i++) {
+                    int j = weight[i] >> 8;
+                    j = 1 + (j >> 1);
+                    weight[i] = j << 8;
+                }
             }
-        } else {
-            endBlock();
-            initBlock();
-            writeRun();
         }
     }
 
-    boolean closed = false;
-
-    protected void finalize() throws Throwable {
-        close();
-        super.finalize();
-    }
-
-    public void close() throws IOException {
-        if (closed) {
-            return;
-        }
-
-        if (runLength > 0) {
-            writeRun();
+    private static void hbMakeCodeLengths(final byte[] len, final int[] freq,
+                                          final Data dat, final int alphaSize,
+                                          final int maxLen) {
+        /*
+         * Nodes and heap entries run from 1. Entry 0 for both the heap and
+         * nodes is a sentinel.
+         */
+        final int[] heap = dat.heap;
+        final int[] weight = dat.weight;
+        final int[] parent = dat.parent;
+
+        for (int i = alphaSize; --i >= 0;) {
+            weight[i + 1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
         }
-        currentChar = -1;
-        endBlock();
-        endCompression();
-        closed = true;
-        super.close();
-        bsStream.close();
-    }
 
-    public void flush() throws IOException {
-        super.flush();
-        bsStream.flush();
-    }
+        for (boolean tooLong = true; tooLong;) {
+            tooLong = false;
 
-    private int blockCRC, combinedCRC;
+            int nNodes = alphaSize;
+            int nHeap = 0;
+            heap[0] = 0;
+            weight[0] = 0;
+            parent[0] = -2;
 
-    private void initialize() throws IOException {
-        bytesOut = 0;
-        nBlocksRandomised = 0;
+            for (int i = 1; i <= alphaSize; i++) {
+                parent[i] = -1;
+                nHeap++;
+                heap[nHeap] = i;
 
-        /* Write `magic' bytes h indicating file-format == huffmanised,
-           followed by a digit indicating blockSize100k.
-        */
-        bsPutUChar('h');
-        bsPutUChar('0' + blockSize100k);
+                int zz = nHeap;
+                int tmp = heap[zz];
+                while (weight[tmp] < weight[heap[zz >> 1]]) {
+                    heap[zz] = heap[zz >> 1];
+                    zz >>= 1;
+                }
+                heap[zz] = tmp;
+            }
 
-        combinedCRC = 0;
-    }
+            while (nHeap > 1) {
+                int n1 = heap[1];
+                heap[1] = heap[nHeap];
+                nHeap--;
 
-    private int allowableBlockSize;
+                int yy = 0;
+                int zz = 1;
+                int tmp = heap[1];
 
-    private void initBlock() {
-        //        blockNo++;
-        mCrc.initialiseCRC();
-        last = -1;
-        //        ch = 0;
+                while (true) {
+                    yy = zz << 1;
 
-        for (int i = 0; i < 256; i++) {
-            inUse[i] = false;
-        }
+                    if (yy > nHeap) {
+                        break;
+                    }
 
-        /* 20 is just a paranoia constant */
-        allowableBlockSize = baseBlockSize * blockSize100k - 20;
-    }
+                    if ((yy < nHeap)
+                        && (weight[heap[yy + 1]] < weight[heap[yy]])) {
+                        yy++;
+                    }
 
-    private void endBlock() throws IOException {
-        blockCRC = mCrc.getFinalCRC();
-        combinedCRC = (combinedCRC << 1) | (combinedCRC >>> 31);
-        combinedCRC ^= blockCRC;
+                    if (weight[tmp] < weight[heap[yy]]) {
+                        break;
+                    }
 
-        /* sort the block and establish posn of original string */
-        doReversibleTransformation();
+                    heap[zz] = heap[yy];
+                    zz = yy;
+                }
 
-        /*
-          A 6-byte block header, the value chosen arbitrarily
-          as 0x314159265359 :-).  A 32 bit value does not really
-          give a strong enough guarantee that the value will not
-          appear by chance in the compressed datastream.  Worst-case
-          probability of this event, for a 900k block, is about
-          2.0e-3 for 32 bits, 1.0e-5 for 40 bits and 4.0e-8 for 48 bits.
-          For a compressed file of size 100Gb -- about 100000 blocks --
-          only a 48-bit marker will do.  NB: normal compression/
-          decompression do *not* rely on these statistical properties.
-          They are only important when trying to recover blocks from
-          damaged files.
-        */
-        bsPutUChar(0x31);
-        bsPutUChar(0x41);
-        bsPutUChar(0x59);
-        bsPutUChar(0x26);
-        bsPutUChar(0x53);
-        bsPutUChar(0x59);
+                heap[zz] = tmp;
 
-        /* Now the block's CRC, so it is in a known place. */
-        bsPutint(blockCRC);
+                int n2 = heap[1];
+                heap[1] = heap[nHeap];
+                nHeap--;
 
-        /* Now a single bit indicating randomisation. */
-        if (blockRandomised) {
-            bsW(1, 1);
-            nBlocksRandomised++;
-        } else {
-            bsW(1, 0);
-        }
+                yy = 0;
+                zz = 1;
+                tmp = heap[1];
 
-        /* Finally, block's contents proper. */
-        moveToFrontCodeAndSend();
-    }
+                while (true) {
+                    yy = zz << 1;
 
-    private void endCompression() throws IOException {
-        /*
-          Now another magic 48-bit number, 0x177245385090, to
-          indicate the end of the last block.  (sqrt(pi), if
-          you want to know.  I did want to use e, but it contains
-          too much repetition -- 27 18 28 18 28 46 -- for me
-          to feel statistically comfortable.  Call me paranoid.)
-        */
-        bsPutUChar(0x17);
-        bsPutUChar(0x72);
-        bsPutUChar(0x45);
-        bsPutUChar(0x38);
-        bsPutUChar(0x50);
-        bsPutUChar(0x90);
-
-        bsPutint(combinedCRC);
+                    if (yy > nHeap) {
+                        break;
+                    }
 
-        bsFinishedWithStream();
-    }
+                    if ((yy < nHeap)
+                        && (weight[heap[yy + 1]] < weight[heap[yy]])) {
+                        yy++;
+                    }
 
-    private void hbAssignCodes (int[] code, char[] length, int minLen,
-                                int maxLen, int alphaSize) {
-        int n, vec, i;
+                    if (weight[tmp] < weight[heap[yy]]) {
+                        break;
+                    }
 
-        vec = 0;
-        for (n = minLen; n <= maxLen; n++) {
-            for (i = 0; i < alphaSize; i++) {
-                if (length[i] == n) {
-                    code[i] = vec;
-                    vec++;
+                    heap[zz] = heap[yy];
+                    zz = yy;
                 }
-            };
-            vec <<= 1;
-        }
-    }
-
-    private void bsSetStream(OutputStream f) {
-        bsStream = f;
-        bsLive = 0;
-        bsBuff = 0;
-        bytesOut = 0;
-    }
 
-    private void bsFinishedWithStream() throws IOException {
-        while (bsLive > 0) {
-            int ch = (bsBuff >> 24);
-            try {
-                bsStream.write(ch); // write 8-bit
-            } catch (IOException e) {
-                throw  e;
-            }
-            bsBuff <<= 8;
-            bsLive -= 8;
-            bytesOut++;
-        }
-    }
-
-    private void bsW(int n, int v) throws IOException {
-        while (bsLive >= 8) {
-            int ch = (bsBuff >> 24);
-            try {
-                bsStream.write(ch); // write 8-bit
-            } catch (IOException e) {
-                throw e;
-            }
-            bsBuff <<= 8;
-            bsLive -= 8;
-            bytesOut++;
-        }
-        bsBuff |= (v << (32 - bsLive - n));
-        bsLive += n;
-    }
-
-    private void bsPutUChar(int c) throws IOException {
-        bsW(8, c);
-    }
-
-    private void bsPutint(int u) throws IOException {
-        bsW(8, (u >> 24) & 0xff);
-        bsW(8, (u >> 16) & 0xff);
-        bsW(8, (u >>  8) & 0xff);
-        bsW(8,  u        & 0xff);
-    }
+                heap[zz] = tmp;
+                nNodes++;
+                parent[n1] = parent[n2] = nNodes;
 
-    private void bsPutIntVS(int numBits, int c) throws IOException {
-        bsW(numBits, c);
-    }
+                final int weight_n1 = weight[n1];
+                final int weight_n2 = weight[n2];
+                weight[nNodes] = ((weight_n1 & 0xffffff00)
+                                  + (weight_n2 & 0xffffff00))
+                    | (1 + (((weight_n1 & 0x000000ff)
+                             > (weight_n2 & 0x000000ff))
+                            ? (weight_n1 & 0x000000ff)
+                            : (weight_n2 & 0x000000ff)));
 
-    private void sendMTFValues() throws IOException {
-        char len[][] = new char[N_GROUPS][MAX_ALPHA_SIZE];
+                parent[nNodes] = -1;
+                nHeap++;
+                heap[nHeap] = nNodes;
 
-        int v, t, i, j, gs, ge, totc, bt, bc, iter;
-        int nSelectors = 0, alphaSize, minLen, maxLen, selCtr;
-        int nGroups, nBytes;
+                tmp = 0;
+                zz = nHeap;
+                tmp = heap[zz];
+                final int weight_tmp = weight[tmp];
+                while (weight_tmp < weight[heap[zz >> 1]]) {
+                    heap[zz] = heap[zz >> 1];
+                    zz >>= 1;
+                }
+                heap[zz] = tmp;
 
-        alphaSize = nInUse + 2;
-        for (t = 0; t < N_GROUPS; t++) {
-            for (v = 0; v < alphaSize; v++) {
-                len[t][v] = (char) GREATER_ICOST;
             }
-        }
 
-        /* Decide how many coding tables to use */
-        if (nMTF <= 0) {
-            panic();
-        }
+            for (int i = 1; i <= alphaSize; i++) {
+                int j = 0;
+                int k = i;
 
-        if (nMTF < 200) {
-            nGroups = 2;
-        } else if (nMTF < 600) {
-            nGroups = 3;
-        } else if (nMTF < 1200) {
-            nGroups = 4;
-        } else if (nMTF < 2400) {
-            nGroups = 5;
-        } else {
-            nGroups = 6;
-        }
-
-        /* Generate an initial set of coding tables */ {
-            int nPart, remF, tFreq, aFreq;
-
-            nPart = nGroups;
-            remF  = nMTF;
-            gs = 0;
-            while (nPart > 0) {
-                tFreq = remF / nPart;
-                ge = gs - 1;
-                aFreq = 0;
-                while (aFreq < tFreq && ge < alphaSize - 1) {
-                    ge++;
-                    aFreq += mtfFreq[ge];
+                for (int parent_k; (parent_k = parent[k]) >= 0;) {
+                    k = parent_k;
+                    j++;
                 }
 
-                if (ge > gs && nPart != nGroups && nPart != 1
-                    && ((nGroups - nPart) % 2 == 1)) {
-                    aFreq -= mtfFreq[ge];
-                    ge--;
+                len[i - 1] = (byte) j;
+                if (j > maxLen) {
+                    tooLong = true;
                 }
+            }
 
-                for (v = 0; v < alphaSize; v++) {
-                    if (v >= gs && v <= ge) {
-                        len[nPart - 1][v] = (char) LESSER_ICOST;
-                    } else {
-                        len[nPart - 1][v] = (char) GREATER_ICOST;
-                    }
+            if (tooLong) {
+                for (int i = 1; i < alphaSize; i++) {
+                    int j = weight[i] >> 8;
+                    j = 1 + (j >> 1);
+                    weight[i] = j << 8;
                 }
-
-                nPart--;
-                gs = ge + 1;
-                remF -= aFreq;
             }
         }
+    }
 
-        int[][] rfreq = new int[N_GROUPS][MAX_ALPHA_SIZE];
-        int[] fave = new int[N_GROUPS];
-        short[] cost = new short[N_GROUPS];
-        /*
-          Iterate up to N_ITERS times to improve the tables.
-        */
-        for (iter = 0; iter < N_ITERS; iter++) {
-            for (t = 0; t < nGroups; t++) {
-                fave[t] = 0;
-            }
+    /**
+     * Index of the last char in the block, so the block size == last + 1.
+     */
+    private int last;
 
-            for (t = 0; t < nGroups; t++) {
-                for (v = 0; v < alphaSize; v++) {
-                    rfreq[t][v] = 0;
-                }
-            }
+    /**
+     * Always: in the range 0 .. 9. The current block size is 100000 * this
+     * number.
+     */
+    private final int blockSize100k;
 
-            nSelectors = 0;
-            totc = 0;
-            gs = 0;
-            while (true) {
+    private int bsBuff;
+    private int bsLive;
+    private final CRC crc = new CRC();
 
-                /* Set group start & end marks. */
-                if (gs >= nMTF) {
-                    break;
-                }
-                ge = gs + G_SIZE - 1;
-                if (ge >= nMTF) {
-                    ge = nMTF - 1;
-                }
+    private int nInUse;
 
-                /*
-                  Calculate the cost of this group as coded
-                  by each of the coding tables.
-                */
-                for (t = 0; t < nGroups; t++) {
-                    cost[t] = 0;
-                }
+    private int nMTF;
 
-                if (nGroups == 6) {
-                    short cost0, cost1, cost2, cost3, cost4, cost5;
-                    cost0 = cost1 = cost2 = cost3 = cost4 = cost5 = 0;
-                    for (i = gs; i <= ge; i++) {
-                        short icv = szptr[i];
-                        cost0 += len[0][icv];
-                        cost1 += len[1][icv];
-                        cost2 += len[2][icv];
-                        cost3 += len[3][icv];
-                        cost4 += len[4][icv];
-                        cost5 += len[5][icv];
-                    }
-                    cost[0] = cost0;
-                    cost[1] = cost1;
-                    cost[2] = cost2;
-                    cost[3] = cost3;
-                    cost[4] = cost4;
-                    cost[5] = cost5;
-                } else {
-                    for (i = gs; i <= ge; i++) {
-                        short icv = szptr[i];
-                        for (t = 0; t < nGroups; t++) {
-                            cost[t] += len[t][icv];
-                        }
-                    }
-                }
+    private int currentChar = -1;
+    private int runLength = 0;
 
-                /*
-                  Find the coding table which is best for this group,
-                  and record its identity in the selector table.
-                */
-                bc = 999999999;
-                bt = -1;
-                for (t = 0; t < nGroups; t++) {
-                    if (cost[t] < bc) {
-                        bc = cost[t];
-                        bt = t;
-                    }
-                };
-                totc += bc;
-                fave[bt]++;
-                selector[nSelectors] = (char) bt;
-                nSelectors++;
+    private int blockCRC;
+    private int combinedCRC;
+    private int allowableBlockSize;
 
-                /*
-                  Increment the symbol frequencies for the selected table.
-                */
-                for (i = gs; i <= ge; i++) {
-                    rfreq[bt][szptr[i]]++;
-                }
+    /**
+     * All memory intensive stuff.
+     */
+    private Data data;
+    private BlockSort blockSorter;
 
-                gs = ge + 1;
-            }
+    private OutputStream out;
 
-            /*
-              Recompute the tables based on the accumulated frequencies.
-            */
-            for (t = 0; t < nGroups; t++) {
-                hbMakeCodeLengths(len[t], rfreq[t], alphaSize, 20);
-            }
-        }
+    /**
+     * Chooses a blocksize based on the given length of the data to compress.
+     *
+     * @return The blocksize, between {@link #MIN_BLOCKSIZE} and
+     *         {@link #MAX_BLOCKSIZE} both inclusive. For a negative
+     *         <tt>inputLength</tt> this method returns <tt>MAX_BLOCKSIZE</tt>
+     *         always.
+     *
+     * @param inputLength
+     *            The length of the data which will be compressed by
+     *            <tt>CBZip2OutputStream</tt>.
+     */
+    public static int chooseBlockSize(long inputLength) {
+        return (inputLength > 0) ? (int) Math
+            .min((inputLength / 132000) + 1, 9) : MAX_BLOCKSIZE;
+    }
 
-        rfreq = null;
-        fave = null;
-        cost = null;
+    /**
+     * Constructs a new <tt>CBZip2OutputStream</tt> with a blocksize of 900k.
+     *
+     * <p>
+     * <b>Attention: </b>The caller is responsible to write the two BZip2 magic
+     * bytes <tt>"BZ"</tt> to the specified stream prior to calling this
+     * constructor.
+     * </p>
+     *
+     * @param out *
+     *            the destination stream.
+     *
+     * @throws IOException
+     *             if an I/O error occurs in the specified stream.
+     * @throws NullPointerException
+     *             if <code>out == null</code>.
+     */
+    public CBZip2OutputStream(final OutputStream out) throws IOException {
+        this(out, MAX_BLOCKSIZE);
+    }
 
-        if (!(nGroups < 8)) {
-            panic();
+    /**
+     * Constructs a new <tt>CBZip2OutputStream</tt> with specified blocksize.
+     *
+     * <p>
+     * <b>Attention: </b>The caller is responsible to write the two BZip2 magic
+     * bytes <tt>"BZ"</tt> to the specified stream prior to calling this
+     * constructor.
+     * </p>
+     *
+     *
+     * @param out
+     *            the destination stream.
+     * @param blockSize
+     *            the blockSize as 100k units.
+     *
+     * @throws IOException
+     *             if an I/O error occurs in the specified stream.
+     * @throws IllegalArgumentException
+     *             if <code>(blockSize < 1) || (blockSize > 9)</code>.
+     * @throws NullPointerException
+     *             if <code>out == null</code>.
+     *
+     * @see #MIN_BLOCKSIZE
+     * @see #MAX_BLOCKSIZE
+     */
+    public CBZip2OutputStream(final OutputStream out, final int blockSize)
+        throws IOException {
+        super();
+
+        if (blockSize < 1) {
+            throw new IllegalArgumentException("blockSize(" + blockSize
+                                               + ") < 1");
         }
-        if (!(nSelectors < 32768 && nSelectors <= (2 + (900000 / G_SIZE)))) {
-            panic();
+        if (blockSize > 9) {
+            throw new IllegalArgumentException("blockSize(" + blockSize
+                                               + ") > 9");
         }
 
+        this.blockSize100k = blockSize;
+        this.out = out;
+        init();
+    }
 
-        /* Compute MTF values for the selectors. */
-        {
-            char[] pos = new char[N_GROUPS];
-            char ll_i, tmp2, tmp;
-            for (i = 0; i < nGroups; i++) {
-                pos[i] = (char) i;
-            }
-            for (i = 0; i < nSelectors; i++) {
-                ll_i = selector[i];
-                j = 0;
-                tmp = pos[j];
-                while (ll_i != tmp) {
-                    j++;
-                    tmp2 = tmp;
-                    tmp = pos[j];
-                    pos[j] = tmp2;
-                }
-                pos[0] = tmp;
-                selectorMtf[i] = (char) j;
-            }
+    /** {@inheritDoc} */
+    @Override
+    public void write(final int b) throws IOException {
+        if (this.out != null) {
+            write0(b);
+        } else {
+            throw new IOException("closed");
         }
+    }
 
-        int[][] code = new int[N_GROUPS][MAX_ALPHA_SIZE];
+    /**
+     * Writes the current byte to the buffer, run-length encoding it
+     * if it has been repeated at least four times (the first step
+     * RLEs sequences of four identical bytes).
+     *
+     * <p>Flushes the current block before writing data if it is
+     * full.</p>
+     *
+     * <p>"write to the buffer" means adding to data.buffer starting
+     * two steps "after" this.last - initially starting at index 1
+     * (not 0) - and updating this.last to point to the last index
+     * written minus 1.</p>
+     */
+    private void writeRun() throws IOException {
+        final int lastShadow = this.last;
 
-        /* Assign actual codes for the tables. */
-        for (t = 0; t < nGroups; t++) {
-            minLen = 32;
-            maxLen = 0;
-            for (i = 0; i < alphaSize; i++) {
-                if (len[t][i] > maxLen) {
-                    maxLen = len[t][i];
-                }
-                if (len[t][i] < minLen) {
-                    minLen = len[t][i];
-                }
-            }
-            if (maxLen > 20) {
-                panic();
-            }
-            if (minLen < 1) {
-                panic();
-            }
-            hbAssignCodes(code[t], len[t], minLen, maxLen, alphaSize);
-        }
+        if (lastShadow < this.allowableBlockSize) {
+            final int currentCharShadow = this.currentChar;
+            final Data dataShadow = this.data;
+            dataShadow.inUse[currentCharShadow] = true;
+            final byte ch = (byte) currentCharShadow;
 
-        /* Transmit the mapping table. */
-        {
-            boolean[] inUse16 = new boolean[16];
-            for (i = 0; i < 16; i++) {
-                inUse16[i] = false;
-                for (j = 0; j < 16; j++) {
-                    if (inUse[i * 16 + j]) {
-                        inUse16[i] = true;
-                    }
-                }
-            }
+            int runLengthShadow = this.runLength;
+            this.crc.updateCRC(currentCharShadow, runLengthShadow);
 
-            nBytes = bytesOut;
-            for (i = 0; i < 16; i++) {
-                if (inUse16[i]) {
-                    bsW(1, 1);
-                } else {
-                    bsW(1, 0);
-                }
-            }
+            switch (runLengthShadow) {
+            case 1:
+                dataShadow.block[lastShadow + 2] = ch;
+                this.last = lastShadow + 1;
+                break;
 
-            for (i = 0; i < 16; i++) {
-                if (inUse16[i]) {
-                    for (j = 0; j < 16; j++) {
-                        if (inUse[i * 16 + j]) {
-                            bsW(1, 1);
-                        } else {
-                            bsW(1, 0);
-                        }
-                    }
-                }
+            case 2:
+                dataShadow.block[lastShadow + 2] = ch;
+                dataShadow.block[lastShadow + 3] = ch;
+                this.last = lastShadow + 2;
+                break;
+
+            case 3: {
+                final byte[] block = dataShadow.block;
+                block[lastShadow + 2] = ch;
+                block[lastShadow + 3] = ch;
+                block[lastShadow + 4] = ch;
+                this.last = lastShadow + 3;
             }
+                break;
 
-        }
+            default: {
+                runLengthShadow -= 4;
+                dataShadow.inUse[runLengthShadow] = true;
+                final byte[] block = dataShadow.block;
+                block[lastShadow + 2] = ch;
+                block[lastShadow + 3] = ch;
+                block[lastShadow + 4] = ch;
+                block[lastShadow + 5] = ch;
+                block[lastShadow + 6] = (byte) runLengthShadow;
+                this.last = lastShadow + 5;
+            }
+                break;
 
-        /* Now the selectors. */
-        nBytes = bytesOut;
-        bsW (3, nGroups);
-        bsW (15, nSelectors);
-        for (i = 0; i < nSelectors; i++) {
-            for (j = 0; j < selectorMtf[i]; j++) {
-                bsW(1, 1);
             }
-            bsW(1, 0);
+        } else {
+            endBlock();
+            initBlock();
+            writeRun();
         }
+    }
 
-        /* Now the coding tables. */
-        nBytes = bytesOut;
-
-        for (t = 0; t < nGroups; t++) {
-            int curr = len[t][0];
-            bsW(5, curr);
-            for (i = 0; i < alphaSize; i++) {
-                while (curr < len[t][i]) {
-                    bsW(2, 2);
-                    curr++; /* 10 */
-                }
-                while (curr > len[t][i]) {
-                    bsW(2, 3);
-                    curr--; /* 11 */
+    /**
+     * Overriden to close the stream.
+     */
+    @Override
+    protected void finalize() throws Throwable {
+        finish();
+        super.finalize();
+    }
+
+
+    public void finish() throws IOException {
+        if (out != null) {
+            try {
+                if (this.runLength > 0) {
+                    writeRun();
                 }
-                bsW (1, 0);
+                this.currentChar = -1;
+                endBlock();
+                endCompression();
+            } finally {
+                this.out = null;
+                this.data = null;
+                this.blockSorter = null;
             }
         }
+    }
 
-        /* And finally, the block data proper */
-        nBytes = bytesOut;
-        selCtr = 0;
-        gs = 0;
-        while (true) {
-            if (gs >= nMTF) {
-                break;
-            }
-            ge = gs + G_SIZE - 1;
-            if (ge >= nMTF) {
-                ge = nMTF - 1;
-            }
-            for (i = gs; i <= ge; i++) {
-                bsW(len[selector[selCtr]][szptr[i]],
-                    code[selector[selCtr]][szptr[i]]);
-            }
-
-            gs = ge + 1;
-            selCtr++;
+    @Override
+    public void close() throws IOException {
+        if (out != null) {
+            OutputStream outShadow = this.out;
+            finish();
+            outShadow.close();
         }
-        if (!(selCtr == nSelectors)) {
-            panic();
+    }
+
+    @Override
+    public void flush() throws IOException {
+        OutputStream outShadow = this.out;
+        if (outShadow != null) {
+            outShadow.flush();
         }
     }
 
-    private void moveToFrontCodeAndSend () throws IOException {
-        bsPutIntVS(24, origPtr);
-        generateMTFValues();
-        sendMTFValues();
+    private void init() throws IOException {
+        // write magic: done by caller who created this stream
+        // this.out.write('B');
+        // this.out.write('Z');
+
+        this.data = new Data(this.blockSize100k);
+        this.blockSorter = new BlockSort(this.data);
+
+        /*
+         * Write `magic' bytes h indicating file-format == huffmanised, followed
+         * by a digit indicating blockSize100k.
+         */
+        bsPutUByte('h');
+        bsPutUByte('0' + this.blockSize100k);
+
+        this.combinedCRC = 0;
+        initBlock();
     }
 
-    private OutputStream bsStream;
+    private void initBlock() {
+        // blockNo++;
+        this.crc.initialiseCRC();
+        this.last = -1;
+        // ch = 0;
+
+        boolean[] inUse = this.data.inUse;
+        for (int i = 256; --i >= 0;) {
+            inUse[i] = false;
+        }
+
+        /* 20 is just a paranoia constant */
+        this.allowableBlockSize = (this.blockSize100k * BZip2Constants.baseBlockSize) - 20;
+    }
 
-    private void simpleSort(int lo, int hi, int d) {
-        int i, j, h, bigN, hp;
-        int v;
+    private void endBlock() throws IOException {
+        this.blockCRC = this.crc.getFinalCRC();
+        this.combinedCRC = (this.combinedCRC << 1) | (this.combinedCRC >>> 31);
+        this.combinedCRC ^= this.blockCRC;
 
-        bigN = hi - lo + 1;
-        if (bigN < 2) {
+        // empty block at end of file
+        if (this.last == -1) {
             return;
         }
 
-        hp = 0;
-        while (incs[hp] < bigN) {
-            hp++;
-        }
-        hp--;
+        /* sort the block and establish posn of original string */
+        blockSort();
 
-        for (; hp >= 0; hp--) {
-            h = incs[hp];
+        /*
+         * A 6-byte block header, the value chosen arbitrarily as 0x314159265359
+         * :-). A 32 bit value does not really give a strong enough guarantee
+         * that the value will not appear by chance in the compressed
+         * datastream. Worst-case probability of this event, for a 900k block,
+         * is about 2.0e-3 for 32 bits, 1.0e-5 for 40 bits and 4.0e-8 for 48
+         * bits. For a compressed file of size 100Gb -- about 100000 blocks --
+         * only a 48-bit marker will do. NB: normal compression/ decompression
+         * donot rely on these statistical properties. They are only important
+         * when trying to recover blocks from damaged files.
+         */
+        bsPutUByte(0x31);
+        bsPutUByte(0x41);
+        bsPutUByte(0x59);
+        bsPutUByte(0x26);
+        bsPutUByte(0x53);
+        bsPutUByte(0x59);
 
-            i = lo + h;
-            while (true) {
-                /* copy 1 */
-                if (i > hi) {
-                    break;
-                }
-                v = zptr[i];
-                j = i;
-                while (fullGtU(zptr[j - h] + d, v + d)) {
-                    zptr[j] = zptr[j - h];
-                    j = j - h;
-                    if (j <= (lo + h - 1)) {
-                        break;
-                    }
-                }
-                zptr[j] = v;
-                i++;
+        /* Now the block's CRC, so it is in a known place. */
+        bsPutInt(this.blockCRC);
 
-                /* copy 2 */
-                if (i > hi) {
-                    break;
-                }
-                v = zptr[i];
-                j = i;
-                while (fullGtU(zptr[j - h] + d, v + d)) {
-                    zptr[j] = zptr[j - h];
-                    j = j - h;
-                    if (j <= (lo + h - 1)) {
-                        break;
-                    }
-                }
-                zptr[j] = v;
-                i++;
+        /* Now a single bit indicating no randomisation. */
+        bsW(1, 0);
 
-                /* copy 3 */
-                if (i > hi) {
-                    break;
-                }
-                v = zptr[i];
-                j = i;
-                while (fullGtU(zptr[j - h] + d, v + d)) {
-                    zptr[j] = zptr[j - h];
-                    j = j - h;
-                    if (j <= (lo + h - 1)) {
-                        break;
-                    }
-                }
-                zptr[j] = v;
-                i++;
+        /* Finally, block's contents proper. */
+        moveToFrontCodeAndSend();
+    }
 
-                if (workDone > workLimit && firstAttempt) {
-                    return;
-                }
-            }
-        }
+    private void endCompression() throws IOException {
+        /*
+         * Now another magic 48-bit number, 0x177245385090, to indicate the end
+         * of the last block. (sqrt(pi), if you want to know. I did want to use
+         * e, but it contains too much repetition -- 27 18 28 18 28 46 -- for me
+         * to feel statistically comfortable. Call me paranoid.)
+         */
+        bsPutUByte(0x17);
+        bsPutUByte(0x72);
+        bsPutUByte(0x45);
+        bsPutUByte(0x38);
+        bsPutUByte(0x50);
+        bsPutUByte(0x90);
+
+        bsPutInt(this.combinedCRC);
+        bsFinishedWithStream();
     }
 
-    private void vswap(int p1, int p2, int n) {
-        int temp = 0;
-        while (n > 0) {
-            temp = zptr[p1];
-            zptr[p1] = zptr[p2];
-            zptr[p2] = temp;
-            p1++;
-            p2++;
-            n--;
-        }
+    /**
+     * Returns the blocksize parameter specified at construction time.
+     */
+    public final int getBlockSize() {
+        return this.blockSize100k;
     }
 
-    private char med3(char a, char b, char c) {
-        char t;
-        if (a > b) {
-            t = a;
-            a = b;
-            b = t;
+    @Override
+    public void write(final byte[] buf, int offs, final int len)
+        throws IOException {
+        if (offs < 0) {
+            throw new IndexOutOfBoundsException("offs(" + offs + ") < 0.");
+        }
+        if (len < 0) {
+            throw new IndexOutOfBoundsException("len(" + len + ") < 0.");
+        }
+        if (offs + len > buf.length) {
+            throw new IndexOutOfBoundsException("offs(" + offs + ") + len("
+                                                + len + ") > buf.length("
+                                                + buf.length + ").");
         }
-        if (b > c) {
-            t = b;
-            b = c;
-            c = t;
+        if (this.out == null) {
+            throw new IOException("stream closed");
         }
-        if (a > b) {
-            b = a;
+
+        for (int hi = offs + len; offs < hi;) {
+            write0(buf[offs++]);
         }
-        return b;
     }
 
-    private static class StackElem {
-        int ll;
-        int hh;
-        int dd;
+    /**
+     * Keeps track of the last bytes written and implicitly performs
+     * run-length encoding as the first step of the bzip2 algorithm.
+     */
+    private void write0(int b) throws IOException {
+        if (this.currentChar != -1) {
+            b &= 0xff;
+            if (this.currentChar == b) {
+                if (++this.runLength > 254) {
+                    writeRun();
+                    this.currentChar = -1;
+                    this.runLength = 0;
+                }
+                // else nothing to do
+            } else {
+                writeRun();
+                this.runLength = 1;
+                this.currentChar = b;
+            }
+        } else {
+            this.currentChar = b & 0xff;
+            this.runLength++;
+        }
     }
 
-    private void qSort3(int loSt, int hiSt, int dSt) {
-        int unLo, unHi, ltLo, gtHi, med, n, m;
-        int sp, lo, hi, d;
-        StackElem[] stack = new StackElem[QSORT_STACK_SIZE];
-        for (int count = 0; count < QSORT_STACK_SIZE; count++) {
-            stack[count] = new StackElem();
+    private static void hbAssignCodes(final int[] code, final byte[] length,
+                                      final int minLen, final int maxLen,
+                                      final int alphaSize) {
+        int vec = 0;
+        for (int n = minLen; n <= maxLen; n++) {
+            for (int i = 0; i < alphaSize; i++) {
+                if ((length[i] & 0xff) == n) {
+                    code[i] = vec;
+                    vec++;
+                }
+            }
+            vec <<= 1;
         }
+    }
 
-        sp = 0;
+    private void bsFinishedWithStream() throws IOException {
+        while (this.bsLive > 0) {
+            int ch = this.bsBuff >> 24;
+            this.out.write(ch); // write 8-bit
+            this.bsBuff <<= 8;
+            this.bsLive -= 8;
+        }
+    }
 
-        stack[sp].ll = loSt;
-        stack[sp].hh = hiSt;
-        stack[sp].dd = dSt;
-        sp++;
+    private void bsW(final int n, final int v) throws IOException {
+        final OutputStream outShadow = this.out;
+        int bsLiveShadow = this.bsLive;
+        int bsBuffShadow = this.bsBuff;
 
-        while (sp > 0) {
-            if (sp >= QSORT_STACK_SIZE) {
-                panic();
-            }
+        while (bsLiveShadow >= 8) {
+            outShadow.write(bsBuffShadow >> 24); // write 8-bit
+            bsBuffShadow <<= 8;
+            bsLiveShadow -= 8;
+        }
 
-            sp--;
-            lo = stack[sp].ll;
-            hi = stack[sp].hh;
-            d = stack[sp].dd;
+        this.bsBuff = bsBuffShadow | (v << (32 - bsLiveShadow - n));
+        this.bsLive = bsLiveShadow + n;
+    }
 
-            if (hi - lo < SMALL_THRESH || d > DEPTH_THRESH) {
-                simpleSort(lo, hi, d);
-                if (workDone > workLimit && firstAttempt) {
-                    return;
-                }
-                continue;
-            }
+    private void bsPutUByte(final int c) throws IOException {
+        bsW(8, c);
+    }
 
-            med = med3(block[zptr[lo] + d + 1],
-                       block[zptr[hi            ] + d  + 1],
-                       block[zptr[(lo + hi) >> 1] + d + 1]);
+    private void bsPutInt(final int u) throws IOException {
+        bsW(8, (u >> 24) & 0xff);
+        bsW(8, (u >> 16) & 0xff);
+        bsW(8, (u >> 8) & 0xff);
+        bsW(8, u & 0xff);
+    }
 
-            unLo = ltLo = lo;
-            unHi = gtHi = hi;
+    private void sendMTFValues() throws IOException {
+        final byte[][] len = this.data.sendMTFValues_len;
+        final int alphaSize = this.nInUse + 2;
 
-            while (true) {
-                while (true) {
-                    if (unLo > unHi) {
-                        break;
-                    }
-                    n = ((int) block[zptr[unLo] + d + 1]) - med;
-                    if (n == 0) {
-                        int temp = 0;
-                        temp = zptr[unLo];
-                        zptr[unLo] = zptr[ltLo];
-                        zptr[ltLo] = temp;
-                        ltLo++;
-                        unLo++;
-                        continue;
-                    };
-                    if (n >  0) {
-                        break;
-                    }
-                    unLo++;
-                }
-                while (true) {
-                    if (unLo > unHi) {
-                        break;
-                    }
-                    n = ((int) block[zptr[unHi] + d + 1]) - med;
-                    if (n == 0) {
-                        int temp = 0;
-                        temp = zptr[unHi];
-                        zptr[unHi] = zptr[gtHi];
-                        zptr[gtHi] = temp;
-                        gtHi--;
-                        unHi--;
-                        continue;
-                    };
-                    if (n <  0) {
-                        break;
-                    }
-                    unHi--;
-                }
-                if (unLo > unHi) {
-                    break;
-                }
-                int temp = 0;
-                temp = zptr[unLo];
-                zptr[unLo] = zptr[unHi];
-                zptr[unHi] = temp;
-                unLo++;
-                unHi--;
+        for (int t = N_GROUPS; --t >= 0;) {
+            byte[] len_t = len[t];
+            for (int v = alphaSize; --v >= 0;) {
+                len_t[v] = GREATER_ICOST;
             }
+        }
 
-            if (gtHi < ltLo) {
-                stack[sp].ll = lo;
-                stack[sp].hh = hi;
-                stack[sp].dd = d + 1;
-                sp++;
-                continue;
-            }
+        /* Decide how many coding tables to use */
+        // assert (this.nMTF > 0) : this.nMTF;
+        final int nGroups = (this.nMTF < 200) ? 2 : (this.nMTF < 600) ? 3
+            : (this.nMTF < 1200) ? 4 : (this.nMTF < 2400) ? 5 : 6;
 
-            n = ((ltLo - lo) < (unLo - ltLo)) ? (ltLo - lo) : (unLo - ltLo);
-            vswap(lo, unLo - n, n);
-            m = ((hi - gtHi) < (gtHi - unHi)) ? (hi - gtHi) : (gtHi - unHi);
-            vswap(unLo, hi - m + 1, m);
+        /* Generate an initial set of coding tables */
+        sendMTFValues0(nGroups, alphaSize);
 
-            n = lo + unLo - ltLo - 1;
-            m = hi - (gtHi - unHi) + 1;
+        /*
+         * Iterate up to N_ITERS times to improve the tables.
+         */
+        final int nSelectors = sendMTFValues1(nGroups, alphaSize);
 
-            stack[sp].ll = lo;
-            stack[sp].hh = n;
-            stack[sp].dd = d;
-            sp++;
+        /* Compute MTF values for the selectors. */
+        sendMTFValues2(nGroups, nSelectors);
 
-            stack[sp].ll = n + 1;
-            stack[sp].hh = m - 1;
-            stack[sp].dd = d + 1;
-            sp++;
+        /* Assign actual codes for the tables. */
+        sendMTFValues3(nGroups, alphaSize);
 
-            stack[sp].ll = m;
-            stack[sp].hh = hi;
-            stack[sp].dd = d;
-            sp++;
-        }
-    }
+        /* Transmit the mapping table. */
+        sendMTFValues4();
 
-    private void mainSort() {
-        int i, j, ss, sb;
-        int[] runningOrder = new int[256];
-        int[] copy = new int[256];
-        boolean[] bigDone = new boolean[256];
-        int c1, c2;
-        int numQSorted;
+        /* Now the selectors. */
+        sendMTFValues5(nGroups, nSelectors);
 
-        /*
-          In the various block-sized structures, live data runs
-          from 0 to last+NUM_OVERSHOOT_BYTES inclusive.  First,
-          set up the overshoot area for block.
-        */
-
-        //   if (verbosity >= 4) fprintf ( stderr, "   sort initialise ...\n" );
-        for (i = 0; i < NUM_OVERSHOOT_BYTES; i++) {
-            block[last + i + 2] = block[(i % (last + 1)) + 1];
-        }
-        for (i = 0; i <= last + NUM_OVERSHOOT_BYTES; i++) {
-            quadrant[i] = 0;
-        }
+        /* Now the coding tables. */
+        sendMTFValues6(nGroups, alphaSize);
 
-        block[0] = (char) (block[last + 1]);
+        /* And finally, the block data proper */
+        sendMTFValues7();
+    }
 
-        if (last < 4000) {
-            /*
-              Use simpleSort(), since the full sorting mechanism
-              has quite a large constant overhead.
-            */
-            for (i = 0; i <= last; i++) {
-                zptr[i] = i;
-            }
-            firstAttempt = false;
-            workDone = workLimit = 0;
-            simpleSort(0, last, 0);
-        } else {
-            numQSorted = 0;
-            for (i = 0; i <= 255; i++) {
-                bigDone[i] = false;
-            }
+    private void sendMTFValues0(final int nGroups, final int alphaSize) {
+        final byte[][] len = this.data.sendMTFValues_len;
+        final int[] mtfFreq = this.data.mtfFreq;
 
-            for (i = 0; i <= 65536; i++) {
-                ftab[i] = 0;
-            }
+        int remF = this.nMTF;
+        int gs = 0;
 
-            c1 = block[0];
-            for (i = 0; i <= last; i++) {
-                c2 = block[i + 1];
-                ftab[(c1 << 8) + c2]++;
-                c1 = c2;
-            }
+        for (int nPart = nGroups; nPart > 0; nPart--) {
+            final int tFreq = remF / nPart;
+            int ge = gs - 1;
+            int aFreq = 0;
 
-            for (i = 1; i <= 65536; i++) {
-                ftab[i] += ftab[i - 1];
+            for (final int a = alphaSize - 1; (aFreq < tFreq) && (ge < a);) {
+                aFreq += mtfFreq[++ge];
             }
 
-            c1 = block[1];
-            for (i = 0; i < last; i++) {
-                c2 = block[i + 2];
-                j = (c1 << 8) + c2;
-                c1 = c2;
-                ftab[j]--;
-                zptr[ftab[j]] = i;
+            if ((ge > gs) && (nPart != nGroups) && (nPart != 1)
+                && (((nGroups - nPart) & 1) != 0)) {
+                aFreq -= mtfFreq[ge--];
             }
 
-            j = ((block[last + 1]) << 8) + (block[1]);
-            ftab[j]--;
-            zptr[ftab[j]] = last;
-
-            /*
-              Now ftab contains the first loc of every small bucket.
-              Calculate the running order, from smallest to largest
-              big bucket.
-            */
-
-            for (i = 0; i <= 255; i++) {
-                runningOrder[i] = i;
+            final byte[] len_np = len[nPart - 1];
+            for (int v = alphaSize; --v >= 0;) {
+                if ((v >= gs) && (v <= ge)) {
+                    len_np[v] = LESSER_ICOST;
+                } else {
+                    len_np[v] = GREATER_ICOST;
+                }
             }
 
-            {
-                int vv;
-                int h = 1;
-                do {
-                    h = 3 * h + 1;
+            gs = ge + 1;
+            remF -= aFreq;
+        }
+    }
+
+    private int sendMTFValues1(final int nGroups, final int alphaSize) {
+        final Data dataShadow = this.data;
+        final int[][] rfreq = dataShadow.sendMTFValues_rfreq;
+        final int[] fave = dataShadow.sendMTFValues_fave;
+        final short[] cost = dataShadow.sendMTFValues_cost;
+        final char[] sfmap = dataShadow.sfmap;
+        final byte[] selector = dataShadow.selector;
+        final byte[][] len = dataShadow.sendMTFValues_len;
+        final byte[] len_0 = len[0];
+        final byte[] len_1 = len[1];
+        final byte[] len_2 = len[2];
+        final byte[] len_3 = len[3];
+        final byte[] len_4 = len[4];
+        final byte[] len_5 = len[5];
+        final int nMTFShadow = this.nMTF;
+
+        int nSelectors = 0;
+
+        for (int iter = 0; iter < N_ITERS; iter++) {
+            for (int t = nGroups; --t >= 0;) {
+                fave[t] = 0;
+                int[] rfreqt = rfreq[t];
+                for (int i = alphaSize; --i >= 0;) {
+                    rfreqt[i] = 0;
                 }
-                while (h <= 256);
-                do {
-                    h = h / 3;
-                    for (i = h; i <= 255; i++) {
-                        vv = runningOrder[i];
-                        j = i;
-                        while ((ftab[((runningOrder[j - h]) + 1) << 8]
-                                - ftab[(runningOrder[j - h]) << 8])
-                                > (ftab[((vv) + 1) << 8] - ftab[(vv) << 8])) {
-                            runningOrder[j] = runningOrder[j - h];
-                            j = j - h;
-                            if (j <= (h - 1)) {
-                                break;
-                            }
-                        }
-                        runningOrder[j] = vv;
-                    }
-                } while (h != 1);
             }
 
-            /*
-              The main sorting loop.
-            */
-            for (i = 0; i <= 255; i++) {
+            nSelectors = 0;
 
-                /*
-                  Process big buckets, starting with the least full.
-                */
-                ss = runningOrder[i];
+            for (int gs = 0; gs < this.nMTF;) {
+                /* Set group start & end marks. */
 
                 /*
-                  Complete the big bucket [ss] by quicksorting
-                  any unsorted small buckets [ss, j].  Hopefully
-                  previous pointer-scanning phases have already
-                  completed many of the small buckets [ss, j], so
-                  we don't have to sort them at all.
-                */
-                for (j = 0; j <= 255; j++) {
-                    sb = (ss << 8) + j;
-                    if (!((ftab[sb] & SETMASK) == SETMASK)) {
-                        int lo = ftab[sb] & CLEARMASK;
-                        int hi = (ftab[sb + 1] & CLEARMASK) - 1;
-                        if (hi > lo) {
-                            qSort3(lo, hi, 2);
-                            numQSorted += (hi - lo + 1);
-                            if (workDone > workLimit && firstAttempt) {
-                                return;
-                            }
-                        }
-                        ftab[sb] |= SETMASK;
+                 * Calculate the cost of this group as coded by each of the
+                 * coding tables.
+                 */
+
+                final int ge = Math.min(gs + G_SIZE - 1, nMTFShadow - 1);
+
+                if (nGroups == N_GROUPS) {
+                    // unrolled version of the else-block
+
+                    short cost0 = 0;
+                    short cost1 = 0;
+                    short cost2 = 0;
+                    short cost3 = 0;
+                    short cost4 = 0;
+                    short cost5 = 0;
+
+                    for (int i = gs; i <= ge; i++) {
+                        final int icv = sfmap[i];
+                        cost0 += len_0[icv] & 0xff;
+                        cost1 += len_1[icv] & 0xff;
+                        cost2 += len_2[icv] & 0xff;
+                        cost3 += len_3[icv] & 0xff;
+                        cost4 += len_4[icv] & 0xff;
+                        cost5 += len_5[icv] & 0xff;
                     }
-                }
 
-                /*
-                  The ss big bucket is now done.  Record this fact,
-                  and update the quadrant descriptors.  Remember to
-                  update quadrants in the overshoot area too, if
-                  necessary.  The "if (i < 255)" test merely skips
-                  this updating for the last bucket processed, since
-                  updating for the last bucket is pointless.
-                */
-                bigDone[ss] = true;
-
-                if (i < 255) {
-                    int bbStart  = ftab[ss << 8] & CLEARMASK;
-                    int bbSize   = (ftab[(ss + 1) << 8] & CLEARMASK) - bbStart;
-                    int shifts   = 0;
-
-                    while ((bbSize >> shifts) > 65534) {
-                        shifts++;
+                    cost[0] = cost0;
+                    cost[1] = cost1;
+                    cost[2] = cost2;
+                    cost[3] = cost3;
+                    cost[4] = cost4;
+                    cost[5] = cost5;
+
+                } else {
+                    for (int t = nGroups; --t >= 0;) {
+                        cost[t] = 0;
                     }
 
-                    for (j = 0; j < bbSize; j++) {
-                        int a2update = zptr[bbStart + j];
-                        int qVal = (j >> shifts);
-                        quadrant[a2update] = qVal;
-                        if (a2update < NUM_OVERSHOOT_BYTES) {
-                            quadrant[a2update + last + 1] = qVal;
+                    for (int i = gs; i <= ge; i++) {
+                        final int icv = sfmap[i];
+                        for (int t = nGroups; --t >= 0;) {
+                            cost[t] += len[t][icv] & 0xff;
                         }
                     }
+                }
 
-                    if (!(((bbSize - 1) >> shifts) <= 65535)) {
-                        panic();
+                /*
+                 * Find the coding table which is best for this group, and
+                 * record its identity in the selector table.
+                 */
+                int bt = -1;
+                for (int t = nGroups, bc = 999999999; --t >= 0;) {
+                    final int cost_t = cost[t];
+                    if (cost_t < bc) {
+                        bc = cost_t;
+                        bt = t;
                     }
                 }
 
+                fave[bt]++;
+                selector[nSelectors] = (byte) bt;
+                nSelectors++;
+
                 /*
-                  Now scan this big bucket so as to synthesise the
-                  sorted order for small buckets [t, ss] for all t != ss.
-                */
-                for (j = 0; j <= 255; j++) {
-                    copy[j] = ftab[(j << 8) + ss] & CLEARMASK;
+                 * Increment the symbol frequencies for the selected table.
+                 */
+                final int[] rfreq_bt = rfreq[bt];
+                for (int i = gs; i <= ge; i++) {
+                    rfreq_bt[sfmap[i]]++;
                 }
 
-                for (j = ftab[ss << 8] & CLEARMASK;
-                     j < (ftab[(ss + 1) << 8] & CLEARMASK); j++) {
-                    c1 = block[zptr[j]];
-                    if (!bigDone[c1]) {
-                        zptr[copy[c1]] = zptr[j] == 0 ? last : zptr[j] - 1;
-                        copy[c1]++;
-                    }
-                }
+                gs = ge + 1;
+            }
 
-                for (j = 0; j <= 255; j++) {
-                    ftab[(j << 8) + ss] |= SETMASK;
-                }
+            /*
+             * Recompute the tables based on the accumulated frequencies.
+             */
+            for (int t = 0; t < nGroups; t++) {
+                hbMakeCodeLengths(len[t], rfreq[t], this.data, alphaSize, 20);
             }
         }
+
+        return nSelectors;
     }
 
-    private void randomiseBlock() {
-        int i;
-        int rNToGo = 0;
-        int rTPos  = 0;
-        for (i = 0; i < 256; i++) {
-            inUse[i] = false;
-        }
+    private void sendMTFValues2(final int nGroups, final int nSelectors) {
+        // assert (nGroups < 8) : nGroups;
 
-        for (i = 0; i <= last; i++) {
-            if (rNToGo == 0) {
-                rNToGo = (char) rNums[rTPos];
-                rTPos++;
-                if (rTPos == 512) {
-                    rTPos = 0;
-                }
-            }
-            rNToGo--;
-            block[i + 1] ^= ((rNToGo == 1) ? 1 : 0);
-            // handle 16 bit signed numbers
-            block[i + 1] &= 0xFF;
+        final Data dataShadow = this.data;
+        byte[] pos = dataShadow.sendMTFValues2_pos;
 
-            inUse[block[i + 1]] = true;
+        for (int i = nGroups; --i >= 0;) {
+            pos[i] = (byte) i;
         }
-    }
 
-    private void doReversibleTransformation() {
-        int i;
+        for (int i = 0; i < nSelectors; i++) {
+            final byte ll_i = dataShadow.selector[i];
+            byte tmp = pos[0];
+            int j = 0;
 
-        workLimit = workFactor * last;
-        workDone = 0;
-        blockRandomised = false;
-        firstAttempt = true;
-
-        mainSort();
+            while (ll_i != tmp) {
+                j++;
+                byte tmp2 = tmp;
+                tmp = pos[j];
+                pos[j] = tmp2;
+            }
 
-        if (workDone > workLimit && firstAttempt) {
-            randomiseBlock();
-            workLimit = workDone = 0;
-            blockRandomised = true;
-            firstAttempt = false;
-            mainSort();
+            pos[0] = tmp;
+            dataShadow.selectorMtf[i] = (byte) j;
         }
+    }
 
-        origPtr = -1;
-        for (i = 0; i <= last; i++) {
-            if (zptr[i] == 0) {
-                origPtr = i;
-                break;
+    private void sendMTFValues3(final int nGroups, final int alphaSize) {
+        int[][] code = this.data.sendMTFValues_code;
+        byte[][] len = this.data.sendMTFValues_len;
+
+        for (int t = 0; t < nGroups; t++) {
+            int minLen = 32;
+            int maxLen = 0;
+            final byte[] len_t = len[t];
+            for (int i = alphaSize; --i >= 0;) {
+                final int l = len_t[i] & 0xff;
+                if (l > maxLen) {
+                    maxLen = l;
+                }
+                if (l < minLen) {
+                    minLen = l;
+                }
             }
-        };
 
-        if (origPtr == -1) {
-            panic();
+            // assert (maxLen <= 20) : maxLen;
+            // assert (minLen >= 1) : minLen;
+
+            hbAssignCodes(code[t], len[t], minLen, maxLen, alphaSize);
         }
     }
 
-    private boolean fullGtU(int i1, int i2) {
-        int k;
-        char c1, c2;
-        int s1, s2;
+    private void sendMTFValues4() throws IOException {
+        final boolean[] inUse = this.data.inUse;
+        final boolean[] inUse16 = this.data.sentMTFValues4_inUse16;
 
-        c1 = block[i1 + 1];
-        c2 = block[i2 + 1];
-        if (c1 != c2) {
-            return (c1 > c2);
+        for (int i = 16; --i >= 0;) {
+            inUse16[i] = false;
+            final int i16 = i * 16;
+            for (int j = 16; --j >= 0;) {
+                if (inUse[i16 + j]) {
+                    inUse16[i] = true;
+                }
+            }
         }
-        i1++;
-        i2++;
 
-        c1 = block[i1 + 1];
-        c2 = block[i2 + 1];
-        if (c1 != c2) {
-            return (c1 > c2);
+        for (int i = 0; i < 16; i++) {
+            bsW(1, inUse16[i] ? 1 : 0);
         }
-        i1++;
-        i2++;
 
-        c1 = block[i1 + 1];
-        c2 = block[i2 + 1];
-        if (c1 != c2) {
-            return (c1 > c2);
+        final OutputStream outShadow = this.out;
+        int bsLiveShadow = this.bsLive;
+        int bsBuffShadow = this.bsBuff;
+
+        for (int i = 0; i < 16; i++) {
+            if (inUse16[i]) {
+                final int i16 = i * 16;
+                for (int j = 0; j < 16; j++) {
+                    // inlined: bsW(1, inUse[i16 + j] ? 1 : 0);
+                    while (bsLiveShadow >= 8) {
+                        outShadow.write(bsBuffShadow >> 24); // write 8-bit
+                        bsBuffShadow <<= 8;
+                        bsLiveShadow -= 8;
+                    }
+                    if (inUse[i16 + j]) {
+                        bsBuffShadow |= 1 << (32 - bsLiveShadow - 1);
+                    }
+                    bsLiveShadow++;
+                }
+            }
         }
-        i1++;
-        i2++;
 
-        c1 = block[i1 + 1];
-        c2 = block[i2 + 1];
-        if (c1 != c2) {
-            return (c1 > c2);
-        }
-        i1++;
-        i2++;
+        this.bsBuff = bsBuffShadow;
+        this.bsLive = bsLiveShadow;
+    }
 
-        c1 = block[i1 + 1];
-        c2 = block[i2 + 1];
-        if (c1 != c2) {
-            return (c1 > c2);
-        }
-        i1++;
-        i2++;
+    private void sendMTFValues5(final int nGroups, final int nSelectors)
+        throws IOException {
+        bsW(3, nGroups);
+        bsW(15, nSelectors);
+
+        final OutputStream outShadow = this.out;
+        final byte[] selectorMtf = this.data.selectorMtf;
+
+        int bsLiveShadow = this.bsLive;
+        int bsBuffShadow = this.bsBuff;
+
+        for (int i = 0; i < nSelectors; i++) {
+            for (int j = 0, hj = selectorMtf[i] & 0xff; j < hj; j++) {
+                // inlined: bsW(1, 1);
+                while (bsLiveShadow >= 8) {
+                    outShadow.write(bsBuffShadow >> 24);
+                    bsBuffShadow <<= 8;
+                    bsLiveShadow -= 8;
+                }
+                bsBuffShadow |= 1 << (32 - bsLiveShadow - 1);
+                bsLiveShadow++;
+            }
 
-        c1 = block[i1 + 1];
-        c2 = block[i2 + 1];
-        if (c1 != c2) {
-            return (c1 > c2);
+            // inlined: bsW(1, 0);
+            while (bsLiveShadow >= 8) {
+                outShadow.write(bsBuffShadow >> 24);
+                bsBuffShadow <<= 8;
+                bsLiveShadow -= 8;
+            }
+            // bsBuffShadow |= 0 << (32 - bsLiveShadow - 1);
+            bsLiveShadow++;
         }
-        i1++;
-        i2++;
 
-        k = last + 1;
+        this.bsBuff = bsBuffShadow;
+        this.bsLive = bsLiveShadow;
+    }
 
-        do {
-            c1 = block[i1 + 1];
-            c2 = block[i2 + 1];
-            if (c1 != c2) {
-                return (c1 > c2);
-            }
-            s1 = quadrant[i1];
-            s2 = quadrant[i2];
-            if (s1 != s2) {
-                return (s1 > s2);
-            }
-            i1++;
-            i2++;
+    private void sendMTFValues6(final int nGroups, final int alphaSize)
+        throws IOException {
+        final byte[][] len = this.data.sendMTFValues_len;
+        final OutputStream outShadow = this.out;
 
-            c1 = block[i1 + 1];
-            c2 = block[i2 + 1];
-            if (c1 != c2) {
-                return (c1 > c2);
-            }
-            s1 = quadrant[i1];
-            s2 = quadrant[i2];
-            if (s1 != s2) {
-                return (s1 > s2);
-            }
-            i1++;
-            i2++;
+        int bsLiveShadow = this.bsLive;
+        int bsBuffShadow = this.bsBuff;
 
-            c1 = block[i1 + 1];
-            c2 = block[i2 + 1];
-            if (c1 != c2) {
-                return (c1 > c2);
-            }
-            s1 = quadrant[i1];
-            s2 = quadrant[i2];
-            if (s1 != s2) {
-                return (s1 > s2);
-            }
-            i1++;
-            i2++;
+        for (int t = 0; t < nGroups; t++) {
+            byte[] len_t = len[t];
+            int curr = len_t[0] & 0xff;
 
-            c1 = block[i1 + 1];
-            c2 = block[i2 + 1];
-            if (c1 != c2) {
-                return (c1 > c2);
+            // inlined: bsW(5, curr);
+            while (bsLiveShadow >= 8) {
+                outShadow.write(bsBuffShadow >> 24); // write 8-bit
+                bsBuffShadow <<= 8;
+                bsLiveShadow -= 8;
             }
-            s1 = quadrant[i1];
-            s2 = quadrant[i2];
-            if (s1 != s2) {
-                return (s1 > s2);
+            bsBuffShadow |= curr << (32 - bsLiveShadow - 5);
+            bsLiveShadow += 5;
+
+            for (int i = 0; i < alphaSize; i++) {
+                int lti = len_t[i] & 0xff;
+                while (curr < lti) {
+                    // inlined: bsW(2, 2);
+                    while (bsLiveShadow >= 8) {
+                        outShadow.write(bsBuffShadow >> 24); // write 8-bit
+                        bsBuffShadow <<= 8;
+                        bsLiveShadow -= 8;
+                    }
+                    bsBuffShadow |= 2 << (32 - bsLiveShadow - 2);
+                    bsLiveShadow += 2;
+
+                    curr++; /* 10 */
+                }
+
+                while (curr > lti) {
+                    // inlined: bsW(2, 3);
+                    while (bsLiveShadow >= 8) {
+                        outShadow.write(bsBuffShadow >> 24); // write 8-bit
+                        bsBuffShadow <<= 8;
+                        bsLiveShadow -= 8;
+                    }
+                    bsBuffShadow |= 3 << (32 - bsLiveShadow - 2);
+                    bsLiveShadow += 2;
+
+                    curr--; /* 11 */
+                }
+
+                // inlined: bsW(1, 0);
+                while (bsLiveShadow >= 8) {
+                    outShadow.write(bsBuffShadow >> 24); // write 8-bit
+                    bsBuffShadow <<= 8;
+                    bsLiveShadow -= 8;
+                }
+                // bsBuffShadow |= 0 << (32 - bsLiveShadow - 1);
+                bsLiveShadow++;
             }
-            i1++;
-            i2++;
-
-            if (i1 > last) {
-                i1 -= last;
-                i1--;
-            };
-            if (i2 > last) {
-                i2 -= last;
-                i2--;
-            };
-
-            k -= 4;
-            workDone++;
-        } while (k >= 0);
-
-        return false;
+        }
+
+        this.bsBuff = bsBuffShadow;
+        this.bsLive = bsLiveShadow;
     }
 
-    /*
-      Knuth's increments seem to work better
-      than Incerpi-Sedgewick here.  Possibly
-      because the number of elems to sort is
-      usually small, typically <= 20.
-    */
-    private int[] incs = {1, 4, 13, 40, 121, 364, 1093, 3280,
-                           9841, 29524, 88573, 265720,
-                           797161, 2391484};
-
-    private void allocateCompressStructures () {
-        int n = baseBlockSize * blockSize100k;
-        block = new char[(n + 1 + NUM_OVERSHOOT_BYTES)];
-        quadrant = new int[(n + NUM_OVERSHOOT_BYTES)];
-        zptr = new int[n];
-        ftab = new int[65537];
-
-        if (block == null || quadrant == null || zptr == null
-            || ftab == null) {
-            //int totalDraw = (n + 1 + NUM_OVERSHOOT_BYTES) + (n + NUM_OVERSHOOT_BYTES) + n + 65537;
-            //compressOutOfMemory ( totalDraw, n );
+    private void sendMTFValues7() throws IOException {
+        final Data dataShadow = this.data;
+        final byte[][] len = dataShadow.sendMTFValues_len;
+        final int[][] code = dataShadow.sendMTFValues_code;
+        final OutputStream outShadow = this.out;
+        final byte[] selector = dataShadow.selector;
+        final char[] sfmap = dataShadow.sfmap;
+        final int nMTFShadow = this.nMTF;
+
+        int selCtr = 0;
+
+        int bsLiveShadow = this.bsLive;
+        int bsBuffShadow = this.bsBuff;
+
+        for (int gs = 0; gs < nMTFShadow;) {
+            final int ge = Math.min(gs + G_SIZE - 1, nMTFShadow - 1);
+            final int selector_selCtr = selector[selCtr] & 0xff;
+            final int[] code_selCtr = code[selector_selCtr];
+            final byte[] len_selCtr = len[selector_selCtr];
+
+            while (gs <= ge) {
+                final int sfmap_i = sfmap[gs];
+
+                //
+                // inlined: bsW(len_selCtr[sfmap_i] & 0xff,
+                // code_selCtr[sfmap_i]);
+                //
+                while (bsLiveShadow >= 8) {
+                    outShadow.write(bsBuffShadow >> 24);
+                    bsBuffShadow <<= 8;
+                    bsLiveShadow -= 8;
+                }
+                final int n = len_selCtr[sfmap_i] & 0xFF;
+                bsBuffShadow |= code_selCtr[sfmap_i] << (32 - bsLiveShadow - n);
+                bsLiveShadow += n;
+
+                gs++;
+            }
+
+            gs = ge + 1;
+            selCtr++;
         }
 
-        /*
-          The back end needs a place to store the MTF values
-          whilst it calculates the coding tables.  We could
-          put them in the zptr array.  However, these values
-          will fit in a short, so we overlay szptr at the
-          start of zptr, in the hope of reducing the number
-          of cache misses induced by the multiple traversals
-          of the MTF values when calculating coding tables.
-          Seems to improve compression speed by about 1%.
-        */
-        //    szptr = zptr;
-
-
-        szptr = new short[2 * n];
+        this.bsBuff = bsBuffShadow;
+        this.bsLive = bsLiveShadow;
+    }
+
+    private void moveToFrontCodeAndSend() throws IOException {
+        bsW(24, this.data.origPtr);
+        generateMTFValues();
+        sendMTFValues();
+    }
+
+    private void blockSort() {
+        blockSorter.blockSort(data, last);
     }
 
+    /*
+     * Performs Move-To-Front on the Burrows-Wheeler transformed
+     * buffer, storing the MTFed data in data.sfmap in RUNA/RUNB
+     * run-length-encoded form.
+     *
+     * <p>Keeps track of byte frequencies in data.mtfFreq at the same time.</p>
+     */
     private void generateMTFValues() {
-        char[] yy = new char[256];
-        int  i, j;
-        char tmp;
-        char tmp2;
-        int zPend;
-        int wr;
-        int EOB;
-
-        makeMaps();
-        EOB = nInUse + 1;
-
-        for (i = 0; i <= EOB; i++) {
-            mtfFreq[i] = 0;
+        final int lastShadow = this.last;
+        final Data dataShadow = this.data;
+        final boolean[] inUse = dataShadow.inUse;
+        final byte[] block = dataShadow.block;
+        final int[] fmap = dataShadow.fmap;
+        final char[] sfmap = dataShadow.sfmap;
+        final int[] mtfFreq = dataShadow.mtfFreq;
+        final byte[] unseqToSeq = dataShadow.unseqToSeq;
+        final byte[] yy = dataShadow.generateMTFValues_yy;
+
+        // make maps
+        int nInUseShadow = 0;
+        for (int i = 0; i < 256; i++) {
+            if (inUse[i]) {
+                unseqToSeq[i] = (byte) nInUseShadow;
+                nInUseShadow++;
+            }
         }
+        this.nInUse = nInUseShadow;
 
-        wr = 0;
-        zPend = 0;
-        for (i = 0; i < nInUse; i++) {
-            yy[i] = (char) i;
+        final int eob = nInUseShadow + 1;
+
+        for (int i = eob; i >= 0; i--) {
+            mtfFreq[i] = 0;
         }
 
+        for (int i = nInUseShadow; --i >= 0;) {
+            yy[i] = (byte) i;
+        }
 
-        for (i = 0; i <= last; i++) {
-            char ll_i;
+        int wr = 0;
+        int zPend = 0;
 
-            ll_i = unseqToSeq[block[zptr[i]]];
+        for (int i = 0; i <= lastShadow; i++) {
+            final byte ll_i = unseqToSeq[block[fmap[i]] & 0xff];
+            byte tmp = yy[0];
+            int j = 0;
 
-            j = 0;
-            tmp = yy[j];
             while (ll_i != tmp) {
                 j++;
-                tmp2 = tmp;
+                byte tmp2 = tmp;
                 tmp = yy[j];
                 yy[j] = tmp2;
-            };
+            }
             yy[0] = tmp;
 
             if (j == 0) {
@@ -1574,26 +1467,25 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
                 if (zPend > 0) {
                     zPend--;
                     while (true) {
-                        switch (zPend % 2) {
-                        case 0:
-                            szptr[wr] = (short) RUNA;
+                        if ((zPend & 1) == 0) {
+                            sfmap[wr] = RUNA;
                             wr++;
                             mtfFreq[RUNA]++;
-                            break;
-                        case 1:
-                            szptr[wr] = (short) RUNB;
+                        } else {
+                            sfmap[wr] = RUNB;
                             wr++;
                             mtfFreq[RUNB]++;
-                            break;
-                        };
-                        if (zPend < 2) {
+                        }
+
+                        if (zPend >= 2) {
+                            zPend = (zPend - 2) >> 1;
+                        } else {
                             break;
                         }
-                        zPend = (zPend - 2) / 2;
-                    };
+                    }
                     zPend = 0;
                 }
-                szptr[wr] = (short) (j + 1);
+                sfmap[wr] = (char) (j + 1);
                 wr++;
                 mtfFreq[j + 1]++;
             }
@@ -1602,31 +1494,87 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
         if (zPend > 0) {
             zPend--;
             while (true) {
-                switch (zPend % 2) {
-                case 0:
-                    szptr[wr] = (short) RUNA;
+                if ((zPend & 1) == 0) {
+                    sfmap[wr] = RUNA;
                     wr++;
                     mtfFreq[RUNA]++;
-                    break;
-                case 1:
-                    szptr[wr] = (short) RUNB;
+                } else {
+                    sfmap[wr] = RUNB;
                     wr++;
                     mtfFreq[RUNB]++;
-                    break;
                 }
-                if (zPend < 2) {
+
+                if (zPend >= 2) {
+                    zPend = (zPend - 2) >> 1;
+                } else {
                     break;
                 }
-                zPend = (zPend - 2) / 2;
             }
         }
 
-        szptr[wr] = (short) EOB;
-        wr++;
-        mtfFreq[EOB]++;
-
-        nMTF = wr;
+        sfmap[wr] = (char) eob;
+        mtfFreq[eob]++;
+        this.nMTF = wr + 1;
     }
-}
 
+    static final class Data extends Object {
+
+        // with blockSize 900k
+        /* maps unsigned byte => "does it occur in block" */
+        final boolean[] inUse = new boolean[256]; // 256 byte
+        final byte[] unseqToSeq = new byte[256]; // 256 byte
+        final int[] mtfFreq = new int[MAX_ALPHA_SIZE]; // 1032 byte
+        final byte[] selector = new byte[MAX_SELECTORS]; // 18002 byte
+        final byte[] selectorMtf = new byte[MAX_SELECTORS]; // 18002 byte
+
+        final byte[] generateMTFValues_yy = new byte[256]; // 256 byte
+        final byte[][] sendMTFValues_len = new byte[N_GROUPS][MAX_ALPHA_SIZE]; // 1548
+        // byte
+        final int[][] sendMTFValues_rfreq = new int[N_GROUPS][MAX_ALPHA_SIZE]; // 6192
+        // byte
+        final int[] sendMTFValues_fave = new int[N_GROUPS]; // 24 byte
+        final short[] sendMTFValues_cost = new short[N_GROUPS]; // 12 byte
+        final int[][] sendMTFValues_code = new int[N_GROUPS][MAX_ALPHA_SIZE]; // 6192
+        // byte
+        final byte[] sendMTFValues2_pos = new byte[N_GROUPS]; // 6 byte
+        final boolean[] sentMTFValues4_inUse16 = new boolean[16]; // 16 byte
+
+        final int[] heap = new int[MAX_ALPHA_SIZE + 2]; // 1040 byte
+        final int[] weight = new int[MAX_ALPHA_SIZE * 2]; // 2064 byte
+        final int[] parent = new int[MAX_ALPHA_SIZE * 2]; // 2064 byte
+
+        // ------------
+        // 333408 byte
+
+        /* holds the RLEd block of original data starting at index 1.
+         * After sorting the last byte added to the buffer is at index
+         * 0. */
+        final byte[] block; // 900021 byte
+        /* maps index in Burrows-Wheeler transformed block => index of
+         * byte in original block */
+        final int[] fmap; // 3600000 byte
+        final char[] sfmap; // 3600000 byte
+        // ------------
+        // 8433529 byte
+        // ============
+
+        /**
+         * Index of original line in Burrows-Wheeler table.
+         *
+         * <p>This is the index in fmap that points to the last byte
+         * of the original data.</p>
+         */
+        int origPtr;
+
+        Data(int blockSize100k) {
+            super();
+
+            final int n = blockSize100k * BZip2Constants.baseBlockSize;
+            this.block = new byte[(n + 1 + NUM_OVERSHOOT_BYTES)];
+            this.fmap = new int[n];
+            this.sfmap = new char[2 * n];
+        }
+
+    }
 
+}
diff --git a/src/tests/junit/org/apache/tools/bzip2/BlockSortTest.java b/src/tests/junit/org/apache/tools/bzip2/BlockSortTest.java
new file mode 100644
index 0000000..caa43e4
--- /dev/null
+++ b/src/tests/junit/org/apache/tools/bzip2/BlockSortTest.java
@@ -0,0 +1,171 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.tools.bzip2;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class BlockSortTest {
+
+    private static final byte[] FIXTURE = { 0, 1, (byte) 252, (byte) 253, (byte) 255,
+                                            (byte) 254, 3, 2, (byte) 128 };
+
+    /*
+      Burrows-Wheeler transform of fixture the manual way:
+
+      * build the matrix
+
+      0, 1, 252, 253, 255, 254, 3, 2, 128
+      1, 252, 253, 255, 254, 3, 2, 128, 0
+      252, 253, 255, 254, 3, 2, 128, 0, 1
+      253, 255, 254, 3, 2, 128, 0, 1, 252
+      255, 254, 3, 2, 128, 0, 1, 252, 253
+      254, 3, 2, 128, 0, 1, 252, 253, 255
+      3, 2, 128, 0, 1, 252, 253, 255, 254
+      2, 128, 0, 1, 252, 253, 255, 254, 3
+      128, 0, 1, 252, 253, 255, 254, 3, 2
+
+      * sort it
+
+      0, 1, 252, 253, 255, 254, 3, 2, 128
+      1, 252, 253, 255, 254, 3, 2, 128, 0
+      2, 128, 0, 1, 252, 253, 255, 254, 3
+      3, 2, 128, 0, 1, 252, 253, 255, 254
+      128, 0, 1, 252, 253, 255, 254, 3, 2
+      252, 253, 255, 254, 3, 2, 128, 0, 1
+      253, 255, 254, 3, 2, 128, 0, 1, 252
+      254, 3, 2, 128, 0, 1, 252, 253, 255
+      255, 254, 3, 2, 128, 0, 1, 252, 253
+
+      * grab last column
+
+      128, 0, 3, 254, 2, 1, 252, 255, 253
+
+        and the original line has been 0
+    */
+
+    private static final byte[] FIXTURE_BWT = { (byte) 128, 0, 3, (byte) 254, 2, 1, 
+                                                (byte) 252, (byte) 255, (byte) 253 };
+
+    private static final int[] FIXTURE_SORTED = {
+        0, 1, 7, 6, 8, 2, 3, 5, 4
+    };
+
+    private static final byte[] FIXTURE2 = { 
+        'C', 'o', 'm', 'm', 'o', 'n', 's', ' ', 'C', 'o', 'm', 'p', 'r', 'e', 's', 's', 
+    };
+
+    private static final byte[] FIXTURE2_BWT = {
+        's', 's', ' ', 'r', 'o', 'm', 'o', 'o', 'C', 'C', 'm', 'm', 'p', 'n', 's', 'e', 
+    };
+
+    @Test
+    public void testSortFixture() {
+        DS ds = setUpFixture();
+        ds.s.blockSort(ds.data, FIXTURE.length - 1);
+        assertFixtureSorted(ds.data);
+        assertEquals(0, ds.data.origPtr);
+    }
+
+    @Test
+    public void testSortFixtureMainSort() {
+        DS ds = setUpFixture();
+        ds.s.mainSort(ds.data, FIXTURE.length - 1);
+        assertFixtureSorted(ds.data);
+    }
+
+    @Test
+    public void testSortFixtureFallbackSort() {
+        DS ds = setUpFixture();
+        ds.s.fallbackSort(ds.data, FIXTURE.length - 1);
+        assertFixtureSorted(ds.data);
+    }
+
+    @Test
+    public void testSortFixture2() {
+        DS ds = setUpFixture2();
+        ds.s.blockSort(ds.data, FIXTURE2.length - 1);
+        assertFixture2Sorted(ds.data);
+        assertEquals(1, ds.data.origPtr);
+    }
+
+    @Test
+    public void testSortFixture2MainSort() {
+        DS ds = setUpFixture2();
+        ds.s.mainSort(ds.data, FIXTURE2.length - 1);
+        assertFixture2Sorted(ds.data);
+    }
+
+    @Test
+    public void testSortFixture2FallbackSort() {
+        DS ds = setUpFixture2();
+        ds.s.fallbackSort(ds.data, FIXTURE2.length - 1);
+        assertFixture2Sorted(ds.data);
+    }
+
+    @Test
+    public void testFallbackSort() {
+        CBZip2OutputStream.Data data = new CBZip2OutputStream.Data(1);
+        BlockSort s = new BlockSort(data);
+        int[] fmap = new int[FIXTURE.length];
+        s.fallbackSort(fmap, FIXTURE, FIXTURE.length);
+        assertArrayEquals(FIXTURE_SORTED, fmap);
+    }
+
+    private DS setUpFixture() {
+        return setUpFixture(FIXTURE);
+    }
+
+    private void assertFixtureSorted(CBZip2OutputStream.Data data) {
+        assertFixtureSorted(data, FIXTURE, FIXTURE_BWT);
+    }
+
+    private DS setUpFixture2() {
+        return setUpFixture(FIXTURE2);
+    }
+
+    private void assertFixture2Sorted(CBZip2OutputStream.Data data) {
+        assertFixtureSorted(data, FIXTURE2, FIXTURE2_BWT);
+    }
+
+    private DS setUpFixture(byte[] fixture) {
+        CBZip2OutputStream.Data data = new CBZip2OutputStream.Data(1);
+        System.arraycopy(fixture, 0, data.block, 1, fixture.length);
+        return new DS(data, new BlockSort(data));
+    }
+
+    private void assertFixtureSorted(CBZip2OutputStream.Data data,
+                                     byte[] fixture, byte[] fixtureBwt) {
+        assertEquals(fixture[fixture.length - 1], data.block[0]);
+        for (int i = 0; i < fixture.length; i++) {
+            assertEquals(fixtureBwt[i], data.block[data.fmap[i]]);
+        }
+    }
+
+    private static class DS {
+        private final CBZip2OutputStream.Data data;
+        private final BlockSort s;
+        DS(CBZip2OutputStream.Data data, BlockSort s) {
+            this.data = data;
+            this.s = s;
+        }
+    }
+}
\ No newline at end of file
-- 
1.7.10.4

