Index: src/test/org/apache/lucene/index/values/TestIndexValues.java
===================================================================
--- src/test/org/apache/lucene/index/values/TestIndexValues.java	(revision 0)
+++ src/test/org/apache/lucene/index/values/TestIndexValues.java	(revision 0)
@@ -0,0 +1,292 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import java.io.IOException;
+import java.util.Random;
+
+import org.apache.lucene.util.*;
+import org.apache.lucene.analysis.WhitespaceAnalyzer;
+import org.apache.lucene.store.*;
+import org.apache.lucene.index.*;
+import org.apache.lucene.document.*;
+
+public class TestIndexValues extends LuceneTestCase {
+
+  // nocommit -- for sorted test, do our own Sort of the
+  // values and verify it's identical
+  public void testBytes() throws IOException {
+    final Random rand = newRandom();
+    final boolean SIMPLE_ASCII = true;
+
+    final UnicodeUtil.UTF8Result utf8Result = new UnicodeUtil.UTF8Result();
+    final BytesRef bytesRef = new BytesRef();
+    bytesRef.offset = 0;
+
+    for(int t=0;t<6;t++) {
+      //System.out.println("\nTEST t=" + t);
+      final BytesBaseImpl.Mode mode;
+      if (t%3 == 0) {
+        mode = BytesBaseImpl.Mode.STRAIGHT;
+      } else if (t%3 == 1) {
+        mode = BytesBaseImpl.Mode.DEREF;
+      } else {
+        mode = BytesBaseImpl.Mode.SORTED;
+      }
+
+      final boolean fixedSize;
+      if (t/3 == 0) {
+        fixedSize = true;
+      } else {
+        fixedSize = false;
+      }
+
+      final BytesRef.Comparator comp = mode == BytesBaseImpl.Mode.SORTED ? BytesRef.getUTF8SortedAsUTF16Comparator() : null;
+
+      Directory dir = new MockRAMDirectory();
+      Bytes.Writer w = BytesBaseImpl.getWriter(dir, "test",
+                                               mode,
+                                               comp,
+                                               fixedSize);
+
+      final String[] values = new String[220];
+      final int lenMin, lenMax;
+      if (fixedSize) {
+        lenMin = lenMax = 6;
+      } else {
+        lenMin = 1;
+        lenMax = 20;
+      }
+      for(int i=0;i<100;i++) {
+        final String s;
+        if (i > 0 && rand.nextInt(5) <= 2) {
+          // use prior value
+          s = values[2*rand.nextInt(i)];
+        } else {
+          s = new String(_TestUtil.getRandomText(rand, lenMin, lenMax, true, SIMPLE_ASCII || fixedSize));
+        }
+        values[2*i] = s;
+
+        UnicodeUtil.UTF16toUTF8(s, 0, s.length(), utf8Result);
+        bytesRef.bytes = utf8Result.result;
+        bytesRef.length = utf8Result.length;
+
+        w.add(2*i, bytesRef);
+      }
+      w.finish(220);
+
+      Bytes.Reader r = BytesBaseImpl.getReader(dir, "test", mode, fixedSize, 220);
+
+      // Verify we can load source twice:
+      for(int iter=0;iter<2;iter++) {
+        Bytes.Source s;
+        Bytes.SortedSource ss;
+        if (mode == BytesBaseImpl.Mode.SORTED) {
+          s = ss = r.loadSorted(comp);
+        } else {
+          s = r.load();
+          ss = null;
+        }
+
+        for(int i=0;i<100;i++) {
+          final int idx = 2*i;
+          assertNotNull("doc " + idx + "; value=" + values[idx] + " t=" + t, s.get(idx));
+          assertEquals("doc " + idx, values[idx], s.get(idx).utf8ToString());
+          if (ss != null) {
+            assertEquals("doc " + idx, values[idx], ss.getByOrd(ss.ord(idx)).utf8ToString());
+            
+            Bytes.SortedSource.LookupResult result = ss.getByValue(new BytesRef(values[idx]));
+            assertTrue(result.found);
+            assertEquals(ss.ord(idx), result.ord);
+          }
+        }
+
+        // Lookup random strings:
+        if (mode == BytesBaseImpl.Mode.SORTED) {
+          BytesRef b2 = ss.getByOrd(1);
+          final String first = new String(b2.bytes, b2.offset, b2.length, "UTF-8");
+          final int numValues = ss.getValueCount();
+          b2 = ss.getByOrd(numValues);
+          final String last = new String(b2.bytes, b2.offset, b2.length, "UTF-8");
+          for(int i=0;i<100;i++) {
+            final String s2 = new String(_TestUtil.getRandomText(rand, lenMin, lenMax, true, SIMPLE_ASCII || fixedSize));
+            BytesRef b = new BytesRef(s2);
+            Bytes.SortedSource.LookupResult result = ss.getByValue(b);
+            if (result.found) {
+              assert result.ord > 0;
+              assertTrue(b.bytesEquals(ss.getByOrd(result.ord)));
+              int count = 0;
+              for(int k=0;k<100;k++) {
+                if (s2.equals(values[2*k])) {
+                  assertEquals(ss.ord(2*k), result.ord);
+                  count++;
+                }
+              }
+              assertTrue(count > 0);
+            } else {
+              assert result.ord >= 0;
+              if (result.ord == 0) {
+                // random string was before our first
+                assertTrue(first.compareTo(s2) > 0);
+              } else if (result.ord == numValues) {
+                // random string was after our last
+                assertTrue(last.compareTo(s2) < 0);
+              } else {
+                // random string fell between two of our
+                // values
+                b2 = ss.getByOrd(result.ord);
+                final String s3 = new String(b2.bytes, b2.offset, b2.length, "UTF-8");
+                b2 = ss.getByOrd(result.ord+1);
+                final String s4 = new String(b2.bytes, b2.offset, b2.length, "UTF-8");
+                assertTrue(s3.compareTo(s2) < 0);
+                assertTrue(s2.compareTo(s4) < 0);
+              }
+            }
+          }
+        }
+      }
+
+      r.close();
+      dir.close();
+    }
+  }
+
+  public void testInts() throws IOException {
+    long maxV = 1;
+    final Random rand = newRandom();
+    final int NUM_VALUES = 1000;
+    final long[] values = new long[NUM_VALUES];
+    for(int rx=1;rx<63;rx++) {
+      for(int b=0;b<2;b++) {
+        //System.out.println("TEST: maxV=" + maxV + " b=" + b + " r=" + rx);
+        Directory dir = new MockRAMDirectory();
+        boolean useFixedArrays = b==0;
+        Ints.Writer w = PackedIntsImpl.getWriter(dir, "test", useFixedArrays);
+        for(int i=0;i<NUM_VALUES;i++) {
+          final long v = rand.nextLong() % (1+maxV);
+          values[i] = v;
+          w.add(i, v);
+          //System.out.println("  write i=" + i + " v=" + v);
+        }
+        w.finish(NUM_VALUES+10);
+
+        Ints.Reader r = PackedIntsImpl.getReader(dir, "test");
+        for(int iter=0;iter<2;iter++) {
+          Ints.Source s = r.load();
+          for(int i=0;i<NUM_VALUES;i++) {
+            final long v = s.get(i);
+            //System.out.println("  read i=" + i + " v=" + v);
+            assertEquals(values[i], v);
+          }
+        }
+        r.close();
+        dir.close();
+      }
+
+      maxV *= 2;
+    }
+  }
+
+  public void testFloats() throws IOException {
+    Directory dir = new MockRAMDirectory();
+    Floats.Writer w = SimpleFloatsImpl.getWriter(dir, "test", 8);
+    final int NUM_VALUES = 1000;
+    final double[] values = new double[NUM_VALUES];
+    final Random rand = newRandom();
+    for(int i=0;i<NUM_VALUES;i++) {
+      final double v = rand.nextDouble();
+      values[i] = v;
+      w.add(i, v);
+    }
+    w.finish(NUM_VALUES+10);
+
+    Floats.Reader r = SimpleFloatsImpl.getReader(dir, "test", NUM_VALUES+10);
+    for(int iter=0;iter<2;iter++) {
+      Floats.Source s = r.load();
+      for(int i=0;i<NUM_VALUES;i++) {
+        assertEquals(values[i], s.get(i));
+      }
+    }
+
+    r.close();
+    dir.close();
+  }
+
+  public void testIndex() throws IOException {
+
+    Directory d = new MockRAMDirectory();
+    IndexWriter w = new IndexWriter(d, new WhitespaceAnalyzer(), IndexWriter.MaxFieldLength.UNLIMITED);
+
+    // nocommit -- test with CFS, too
+    //w.setUseCompoundFile(false);
+
+    //w.setInfoStream(System.out);
+    Document doc = new Document();
+
+    NumericField intField = new NumericField("int");
+    doc.add(intField);
+    intField.setIndexValues(Field.Values.PACKED_INTS);
+
+    NumericField floatField = new NumericField("float");
+    doc.add(floatField);
+    floatField.setIndexValues(Field.Values.SIMPLE_FLOAT_4BYTE);
+
+    byte[] b = new byte[7];
+
+    // nocommit - test other options for bytes too:
+    Field bytesField = new Field("bytes", b, 0, b.length);
+    doc.add(bytesField);
+    bytesField.setIndexValues(Field.Values.BYTES_FIXED_SORTED);
+
+    byte upto = 0;
+    for(int i=0;i<177;i++) {
+      intField.setLongValue(i);
+      floatField.setFloatValue((float) (2.0*i));
+      for(int j=0;j<b.length;j++) {
+        b[j] = upto++;
+      }
+      w.addDocument(doc);
+      
+      if (i%7 == 0) {
+        w.commit();
+      }
+    }
+
+    w.optimize();
+
+    IndexReader r = w.getReader();
+    assertEquals(177, r.numDocs());
+    Ints.Source ints = r.getIndexValuesInts("int").load();
+    Floats.Source floats = r.getIndexValuesFloats("float").load();
+    Bytes.Source bytes = r.getIndexValuesBytes("bytes").load();
+    upto = 0;
+    for(int i=0;i<177;i++) {
+      assertEquals(i, ints.get(i));
+      assertEquals(2.0*i, floats.get(i), 0.00001);
+      BytesRef br = bytes.get(i);
+      for(int j=0;j<7;j++) {
+        assertEquals(upto++, br.bytes[br.offset+j]);
+      }
+    }
+
+    // nocommit -- test with deletions
+    r.close();
+    w.close();
+    d.close();
+  }
+}

Property changes on: src/test/org/apache/lucene/index/values/TestIndexValues.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/test/org/apache/lucene/index/TestByteSlices.java
===================================================================
--- src/test/org/apache/lucene/index/TestByteSlices.java	(revision 900008)
+++ src/test/org/apache/lucene/index/TestByteSlices.java	(working copy)
@@ -25,7 +25,7 @@
     
     /* Allocate another byte[] from the shared pool */
     @Override
-    synchronized byte[] getByteBlock(boolean trackAllocations) {
+    public synchronized byte[] getByteBlock(boolean trackAllocations) {
       final int size = freeByteBlocks.size();
       final byte[] b;
       if (0 == size)
@@ -37,10 +37,15 @@
 
     /* Return a byte[] to the pool */
     @Override
-    synchronized void recycleByteBlocks(byte[][] blocks, int start, int end) {
+    public synchronized void recycleByteBlocks(byte[][] blocks, int start, int end) {
       for(int i=start;i<end;i++)
         freeByteBlocks.add(blocks[i]);
     }
+
+    @Override
+    public long ramBytesUsed() {
+      throw new UnsupportedOperationException();
+    }
   }
 
   public void testBasic() throws Throwable {
Index: src/test/org/apache/lucene/util/_TestUtil.java
===================================================================
--- src/test/org/apache/lucene/util/_TestUtil.java	(revision 900008)
+++ src/test/org/apache/lucene/util/_TestUtil.java	(working copy)
@@ -119,4 +119,42 @@
     return 1024 + new Random().nextInt(64512);
   }
 
+  public static int nextInt(Random rand, int min, int max) {
+    return min+rand.nextInt(max-min);
+  }
+
+  public static char[] getRandomText(Random rand, int lenMin, int lenMax, boolean doSurrogates, boolean simpleASCII) {
+
+    final int len;
+    if (lenMin == lenMax) {
+      len = lenMin;
+    } else {
+      len = lenMin+rand.nextInt(lenMax-lenMin);
+    }
+
+    char[] buffer = new char[len];
+    for(int i=0;i<len;i++) {
+      if (simpleASCII) {
+        buffer[i] = (char) nextInt(rand, 97, 122);
+      } else {
+        final int t = rand.nextInt(5);
+        if (0 == t && i < len-1 && doSurrogates) {
+          // Make a surrogate pair
+          // High surrogate
+          buffer[i++] = (char) nextInt(rand, 0xd800, 0xdc00);
+          // Low surrogate
+          buffer[i] = (char) nextInt(rand, 0xdc00, 0xe000);
+        } else if (t <= 1) {
+          buffer[i] = (char) rand.nextInt(0x80);
+        } else if (2 == t) {
+          buffer[i] = (char) nextInt(rand, 0x80, 0x800);
+        } else if (3 == t) {
+          buffer[i] = (char) nextInt(rand, 0x800, 0xd800);
+        } else {
+          buffer[i] = (char) nextInt(rand, 0xe000, 0xffff);
+        }
+      }
+    }
+    return buffer;
+  }
 }
Index: src/test/org/apache/lucene/util/TestPackedInts.java
===================================================================
--- src/test/org/apache/lucene/util/TestPackedInts.java	(revision 0)
+++ src/test/org/apache/lucene/util/TestPackedInts.java	(revision 0)
@@ -0,0 +1,62 @@
+package org.apache.lucene.util;
+
+/**
+* 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.
+*/
+
+import org.apache.lucene.store.*;
+
+import java.util.Random;
+import java.io.IOException;
+
+public class TestPackedInts extends LuceneTestCase {
+
+  public void testPackedInts() throws IOException {
+    
+    Random rand = newRandom();
+    for(int iter=0;iter<50;iter++) {
+      long ceil = 2;
+      // nocommit -- need to get the 64 bit case working
+      for(int nbits=1;nbits<63;nbits++) {
+        final int valueCount = 100+rand.nextInt(500);
+        final Directory d = new MockRAMDirectory();
+
+        IndexOutput out = d.createOutput("out.bin");
+        PackedInts.Writer w = PackedInts.getWriter(out, ceil-1, valueCount, -1);
+
+        final long[] values = new long[valueCount];
+        for(int i=0;i<valueCount;i++) {
+          long v = rand.nextLong() % ceil;
+          if (v < 0) {
+            v = -v;
+          }
+          values[i] = v;
+          w.add(values[i]);
+        }
+        w.finish();
+        out.close();
+
+        IndexInput in = d.openInput("out.bin");
+        PackedInts.Reader r = PackedInts.getReader(in);
+        for(int i=0;i<valueCount;i++) {
+          assertEquals("i=" + i + " ceil=" + ceil, values[i], r.get(i));
+        }
+        in.close();
+        ceil *= 2;
+      }
+    }
+  }
+}

Property changes on: src/test/org/apache/lucene/util/TestPackedInts.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/search/FieldComparator.java
===================================================================
--- src/java/org/apache/lucene/search/FieldComparator.java	(revision 900008)
+++ src/java/org/apache/lucene/search/FieldComparator.java	(working copy)
@@ -29,6 +29,10 @@
 import org.apache.lucene.search.FieldCache.IntParser;
 import org.apache.lucene.search.FieldCache.ShortParser;
 import org.apache.lucene.search.FieldCache.StringIndex;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.index.values.Floats;
+import org.apache.lucene.index.values.Ints;
+import org.apache.lucene.index.values.Bytes;
 
 /**
  * Expert: a FieldComparator compares hits so as to determine their
@@ -141,7 +145,6 @@
    * @param reader current reader
    * @param docBase docBase of this reader 
    * @throws IOException
-   * @throws IOException
    */
   public abstract void setNextReader(IndexReader reader, int docBase) throws IOException;
 
@@ -316,6 +319,64 @@
     }
   }
 
+  /** Uses float index values to sort by ascending value */
+  public static final class FloatIndexValuesComparator extends FieldComparator {
+    private final double[] values;
+    private Floats.Source currentReaderValues;
+    private final String field;
+    private double bottom;
+
+    FloatIndexValuesComparator(int numHits, String field) {
+      values = new double[numHits];
+      this.field = field;
+    }
+
+    @Override
+    public int compare(int slot1, int slot2) {
+      final double v1 = values[slot1];
+      final double v2 = values[slot2];
+      if (v1 > v2) {
+        return 1;
+      } else if (v1 < v2) {
+        return -1;
+      } else {
+        return 0;
+      }
+    }
+
+    @Override
+    public int compareBottom(int doc) {
+      final double v2 = currentReaderValues.get(doc);
+      if (bottom > v2) {
+        return 1;
+      } else if (bottom < v2) {
+        return -1;
+      } else {
+        return 0;
+      }
+    }
+
+    @Override
+    public void copy(int slot, int doc) {
+      values[slot] = currentReaderValues.get(doc);
+    }
+
+    @Override
+    public void setNextReader(IndexReader reader, int docBase) throws IOException {
+      currentReaderValues = reader.getIndexValuesCache().getFloats(field);
+    }
+    
+    @Override
+    public void setBottom(final int bottom) {
+      this.bottom = values[bottom];
+    }
+
+    @Override
+    public Comparable value(int slot) {
+      return Double.valueOf(values[slot]);
+    }
+  }
+
   /** Parses field's values as float (using {@link
    *  FieldCache#getFloats} and sorts by ascending value */
   public static final class FloatComparator extends FieldComparator {
@@ -450,6 +511,68 @@
     }
   }
 
+  /** Loads int index values and sorts by ascending value. */
+  public static final class IntIndexValuesComparator extends FieldComparator {
+    private final long[] values;
+    private Ints.Source currentReaderValues;
+    private final String field;
+    private long bottom;
+
+    IntIndexValuesComparator(int numHits, String field) {
+      values = new long[numHits];
+      this.field = field;
+    }
+
+    @Override
+    public int compare(int slot1, int slot2) {
+      // TODO: there are sneaky non-branch ways to compute
+      // -1/+1/0 sign
+      final long v1 = values[slot1];
+      final long v2 = values[slot2];
+      if (v1 > v2) {
+        return 1;
+      } else if (v1 < v2) {
+        return -1;
+      } else {
+        return 0;
+      }
+    }
+
+    @Override
+    public int compareBottom(int doc) {
+      // TODO: there are sneaky non-branch ways to compute
+      // -1/+1/0 sign
+      final long v2 = currentReaderValues.get(doc);
+      if (bottom > v2) {
+        return 1;
+      } else if (bottom < v2) {
+        return -1;
+      } else {
+        return 0;
+      }
+    }
+
+    @Override
+    public void copy(int slot, int doc) {
+      values[slot] = currentReaderValues.get(doc);
+    }
+
+    @Override
+    public void setNextReader(IndexReader reader, int docBase) throws IOException {
+      currentReaderValues = reader.getIndexValuesCache().getInts(field);
+    }
+    
+    @Override
+    public void setBottom(final int bottom) {
+      this.bottom = values[bottom];
+    }
+
+    @Override
+    public Comparable value(int slot) {
+      return Long.valueOf(values[slot]);
+    }
+  }
+
   /** Parses field's values as long (using {@link
    *  FieldCache#getLongs} and sorts by ascending value */
   public static final class LongComparator extends FieldComparator {
@@ -843,6 +966,144 @@
     }
   }
 
+  /** Sorts by bytes index values */
+  public static final class BytesIndexValuesComparator extends FieldComparator {
+
+    private final BytesRef.Comparator comp;
+    private final int[] ords;
+    private final BytesRef[] values;
+    private final int[] readerGen;
+
+    private int currentReaderGen = -1;
+    private Bytes.SortedSource currentReaderValues;
+    private final String field;
+
+    private int bottomSlot = -1;
+    private int bottomOrd;
+    private BytesRef bottomValue;
+    private final boolean reversed;
+    private final int sortPos;
+
+    public BytesIndexValuesComparator(BytesRef.Comparator comp, int numHits, String field, int sortPos, boolean reversed) {
+      ords = new int[numHits];
+      values = new BytesRef[numHits];
+      readerGen = new int[numHits];
+      this.sortPos = sortPos;
+      this.reversed = reversed;
+      this.field = field;
+      this.comp = comp;
+    }
+
+    @Override
+    public int compare(int slot1, int slot2) {
+      if (readerGen[slot1] == readerGen[slot2]) {
+        int cmp = ords[slot1] - ords[slot2];
+        if (cmp != 0) {
+          return cmp;
+        }
+      }
+
+      // nocommit -- offer control on which way nulls sort
+      final BytesRef val1 = values[slot1];
+      final BytesRef val2 = values[slot2];
+      if (val1 == null) {
+        if (val2 == null) {
+          return 0;
+        }
+        return -1;
+      } else if (val2 == null) {
+        return 1;
+      }
+      return comp.compare(val1, val2);
+    }
+
+    @Override
+    public int compareBottom(int doc) {
+      assert bottomSlot != -1;
+      int order = currentReaderValues.ord(doc);
+      final int cmp = bottomOrd - order;
+      if (cmp != 0) {
+        return cmp;
+      }
+
+      final BytesRef val2 = currentReaderValues.getByOrd(order);
+      if (bottomValue == null) {
+        if (val2 == null) {
+          return 0;
+        }
+        // bottom wins
+        return -1;
+      } else if (val2 == null) {
+        // doc wins
+        return 1;
+      }
+      return comp.compare(bottomValue, val2);
+    }
+
+    private void convert(int slot) {
+      readerGen[slot] = currentReaderGen;
+      int index = 0;
+      BytesRef value = values[slot];
+      if (value == null) {
+        ords[slot] = 0;
+        return;
+      }
+
+      // nocommit -- nothing different if found or not?
+      ords[slot] = currentReaderValues.getByValue(value).ord;
+    }
+
+    @Override
+    public void copy(int slot, int doc) {
+      final int ord = currentReaderValues.ord(doc);
+      ords[slot] = ord;
+      assert ord >= 0;
+      // nocommit -- reuse
+      values[slot] = new BytesRef(currentReaderValues.getByOrd(ord));
+      readerGen[slot] = currentReaderGen;
+    }
+
+    @Override
+    public void setNextReader(IndexReader reader, int docBase) throws IOException {
+      currentReaderValues = reader.getIndexValuesCache().getSortedBytes(field, comp);
+      currentReaderGen++;
+      if (bottomSlot != -1) {
+        convert(bottomSlot);
+        bottomOrd = ords[bottomSlot];
+      }
+    }
+    
+    @Override
+    public void setBottom(final int bottom) {
+      bottomSlot = bottom;
+      if (readerGen[bottom] != currentReaderGen) {
+        convert(bottomSlot);
+      }
+      bottomOrd = ords[bottom];
+      assert bottomOrd >= 0;
+      assert bottomOrd < currentReaderValues.getValueCount();
+      bottomValue = values[bottom];
+    }
+
+    @Override
+    public Comparable value(int slot) {
+      final BytesRef b = values[slot];
+      if (b == null) {
+        return null;
+      } else {
+        return BytesRef.getComparableBytesRef(b, comp);
+      }
+    }
+
+    public int getBottomSlot() {
+      return bottomSlot;
+    }
+
+    public String getField() {
+      return field;
+    }
+  }
+
   /** Sorts by field's natural String sort order.  All
    *  comparisons are done using String.compareTo, which is
    *  slow for medium to large result sets but possibly
Index: src/java/org/apache/lucene/search/SortField.java
===================================================================
--- src/java/org/apache/lucene/search/SortField.java	(revision 900008)
+++ src/java/org/apache/lucene/search/SortField.java	(working copy)
@@ -22,7 +22,12 @@
 import java.util.Locale;
 
 import org.apache.lucene.util.StringHelper;
+import org.apache.lucene.util.BytesRef;
 
+// nocommit -- for cleaner transition, maybe we should make
+// a new SortField that subclasses this one and always uses
+// index values?
+
 /**
  * Stores information about how to sort documents by terms in an individual
  * field.  Fields must be indexed in order to sort by them.
@@ -83,6 +88,9 @@
    * uses ordinals to do the sorting. */
   public static final int STRING_VAL = 11;
   
+  /** Sort use byte[] index values. */
+  public static final int BYTES = 12;
+  
   // IMPLEMENTATION NOTE: the FieldCache.STRING_INDEX is in the same "namespace"
   // as the above static int values.  Any new values must not have the same value
   // as FieldCache.STRING_INDEX.
@@ -362,6 +370,26 @@
       field = StringHelper.intern(field);
   }
 
+  private boolean useIndexValues;
+
+  public void setUseIndexValues(boolean b) {
+    useIndexValues = b;
+  }
+
+  public boolean getUseIndexValues() {
+    return useIndexValues;
+  }
+
+  private BytesRef.Comparator bytesComparator = BytesRef.getStraightComparator();
+
+  public void setBytesComparator(BytesRef.Comparator b) {
+    bytesComparator = b;
+  }
+
+  public BytesRef.Comparator getBytesComparator() {
+    return bytesComparator;
+  }
+
   /** Returns the {@link FieldComparator} to use for
    * sorting.
    *
@@ -392,10 +420,18 @@
       return new FieldComparator.DocComparator(numHits);
 
     case SortField.INT:
-      return new FieldComparator.IntComparator(numHits, field, parser);
+      if (useIndexValues) {
+        return new FieldComparator.IntIndexValuesComparator(numHits, field);
+      } else {
+        return new FieldComparator.IntComparator(numHits, field, parser);
+      }
 
     case SortField.FLOAT:
-      return new FieldComparator.FloatComparator(numHits, field, parser);
+      if (useIndexValues) {
+        return new FieldComparator.FloatIndexValuesComparator(numHits, field);
+      } else {
+        return new FieldComparator.FloatComparator(numHits, field, parser);
+      }
 
     case SortField.LONG:
       return new FieldComparator.LongComparator(numHits, field, parser);
@@ -414,8 +450,15 @@
       return comparatorSource.newComparator(field, numHits, sortPos, reverse);
 
     case SortField.STRING:
-      return new FieldComparator.StringOrdValComparator(numHits, field, sortPos, reverse);
+      if (useIndexValues) {
+        return new FieldComparator.BytesIndexValuesComparator(BytesRef.getUTF8SortedAsUTF16Comparator(), numHits, field, sortPos, reverse);
+      } else {
+        return new FieldComparator.StringOrdValComparator(numHits, field, sortPos, reverse);
+      }
 
+    case SortField.BYTES:
+      return new FieldComparator.BytesIndexValuesComparator(bytesComparator, numHits, field, sortPos, reverse);
+
     case SortField.STRING_VAL:
       return new FieldComparator.StringValComparator(numHits, field);
         
Index: src/java/org/apache/lucene/index/ByteBlockPool.java
===================================================================
--- src/java/org/apache/lucene/index/ByteBlockPool.java	(revision 900008)
+++ src/java/org/apache/lucene/index/ByteBlockPool.java	(working copy)
@@ -35,11 +35,19 @@
 
 import java.util.Arrays;
 
-final class ByteBlockPool {
+/** <p>NOTE: this class is meant only to be used internally
+ *  by Lucene; it's only public so it can be shared across
+ *  packages.  This means the API is freely subject to
+ *  change, and, the class could be removed entirely, in any
+ *  Lucene release.  Use directly at your own risk!
+ */
 
-  abstract static class Allocator {
-    abstract void recycleByteBlocks(byte[][] blocks, int start, int end);
-    abstract byte[] getByteBlock(boolean trackAllocations);
+public final class ByteBlockPool {
+
+  public abstract static class Allocator {
+    public abstract void recycleByteBlocks(byte[][] blocks, int start, int end);
+    public abstract byte[] getByteBlock(boolean trackAllocations);
+    public abstract long ramBytesUsed();
   }
 
   public byte[][] buffers = new byte[10][];
Index: src/java/org/apache/lucene/index/FieldInfos.java
===================================================================
--- src/java/org/apache/lucene/index/FieldInfos.java	(revision 900008)
+++ src/java/org/apache/lucene/index/FieldInfos.java	(working copy)
@@ -18,6 +18,7 @@
  */
 
 import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
 import org.apache.lucene.document.Fieldable;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.IndexInput;
@@ -41,7 +42,10 @@
   // First used in 2.9; prior to 2.9 there was no format header
   public static final int FORMAT_START = -2;
 
-  static final int CURRENT_FORMAT = FORMAT_START;
+  // Records index values for this field
+  public static final int FORMAT_INDEX_VALUES = -3;
+
+  static final int CURRENT_FORMAT = FORMAT_INDEX_VALUES;
   
   static final byte IS_INDEXED = 0x1;
   static final byte STORE_TERMVECTOR = 0x2;
@@ -322,9 +326,51 @@
       if (fi.omitNorms) bits |= OMIT_NORMS;
       if (fi.storePayloads) bits |= STORE_PAYLOADS;
       if (fi.omitTermFreqAndPositions) bits |= OMIT_TERM_FREQ_AND_POSITIONS;
-      
+
       output.writeString(fi.name);
       output.writeByte(bits);
+
+      final byte b;
+
+      if (fi.indexValues == null) {
+        b = 0;
+      } else {
+        switch(fi.indexValues) {
+        case PACKED_INTS:
+          b = 1;
+          break;
+        case SIMPLE_FLOAT_4BYTE:
+          b = 2;
+          break;
+        case SIMPLE_FLOAT_8BYTE:
+          b = 3;
+          break;
+        case BYTES_FIXED_STRAIGHT:
+          b = 4;
+          break;
+        case BYTES_FIXED_DEREF:
+          b = 5;
+          break;
+        case BYTES_FIXED_SORTED:
+          b = 6;
+          break;
+        case BYTES_VAR_STRAIGHT:
+          b = 7;
+          break;
+        case BYTES_VAR_DEREF:
+          b = 8;
+          break;
+        case BYTES_VAR_SORTED:
+          b = 9;
+          break;
+        case PACKED_INTS_FIXED:
+          b = 10;
+          break;
+        default:
+          throw new IllegalStateException("unhandled indexValues type " + fi.indexValues);
+        }
+      }
+      output.writeByte(b);
     }
   }
 
@@ -338,7 +384,7 @@
       format = FORMAT_PRE;
     }
 
-    if (format != FORMAT_PRE & format != FORMAT_START) {
+    if (format != FORMAT_PRE && format != FORMAT_START && format != FORMAT_INDEX_VALUES) {
       throw new CorruptIndexException("unrecognized format " + format + " in file \"" + fileName + "\"");
     }
 
@@ -360,7 +406,49 @@
       boolean storePayloads = (bits & STORE_PAYLOADS) != 0;
       boolean omitTermFreqAndPositions = (bits & OMIT_TERM_FREQ_AND_POSITIONS) != 0;
       
-      addInternal(name, isIndexed, storeTermVector, storePositionsWithTermVector, storeOffsetWithTermVector, omitNorms, storePayloads, omitTermFreqAndPositions);
+      FieldInfo fi = addInternal(name, isIndexed, storeTermVector, storePositionsWithTermVector, storeOffsetWithTermVector, omitNorms, storePayloads, omitTermFreqAndPositions);
+
+      if (format <= FORMAT_INDEX_VALUES) {
+        final byte b = input.readByte();
+
+        switch(b) {
+        case 0:
+          fi.indexValues = null;
+          break;
+        case 1:
+          fi.indexValues = Field.Values.PACKED_INTS;
+          break;
+        case 2:
+          fi.indexValues = Field.Values.SIMPLE_FLOAT_4BYTE;
+          break;
+        case 3:
+          fi.indexValues = Field.Values.SIMPLE_FLOAT_8BYTE;
+          break;
+        case 4:
+          fi.indexValues = Field.Values.BYTES_FIXED_STRAIGHT;
+          break;
+        case 5:
+          fi.indexValues = Field.Values.BYTES_FIXED_DEREF;
+          break;
+        case 6:
+          fi.indexValues = Field.Values.BYTES_FIXED_SORTED;
+          break;
+        case 7:
+          fi.indexValues = Field.Values.BYTES_VAR_STRAIGHT;
+          break;
+        case 8:
+          fi.indexValues = Field.Values.BYTES_VAR_DEREF;
+          break;
+        case 9:
+          fi.indexValues = Field.Values.BYTES_VAR_SORTED;
+          break;
+        case 10:
+          fi.indexValues = Field.Values.PACKED_INTS_FIXED;
+          break;
+        default:
+          throw new IllegalStateException("unhandled indexValues type " + b);
+        }
+      }
     }
 
     if (input.getFilePointer() != input.length()) {
Index: src/java/org/apache/lucene/index/SegmentInfo.java
===================================================================
--- src/java/org/apache/lucene/index/SegmentInfo.java	(revision 900008)
+++ src/java/org/apache/lucene/index/SegmentInfo.java	(working copy)
@@ -621,6 +621,12 @@
       files.add(delFileName);
     }
 
+    // nocommit -- need something cleaner!
+    for(int i=0;i<10;i++) {
+      addIfExists(files, name + "_" + i + ".dat");
+      addIfExists(files, name + "_" + i + ".idx");
+    }
+
     // Careful logic for norms files    
     if (normGen != null) {
       for(int i=0;i<normGen.length;i++) {
Index: src/java/org/apache/lucene/index/values/VarSortedBytesImpl.java
===================================================================
--- src/java/org/apache/lucene/index/values/VarSortedBytesImpl.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/VarSortedBytesImpl.java	(revision 0)
@@ -0,0 +1,263 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesHash;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.PackedInts;
+import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.lucene.util.CodecUtil;
+import java.io.IOException;
+
+import java.util.Collection;
+
+// Stores variable-length byte[] by deref, ie when two docs
+// have the same value, they store only 1 byte[] and both
+// docs reference that single source
+
+class VarSortedBytesImpl {
+
+  static final String CODEC_NAME = "VarDerefBytes";
+  static final int VERSION_START = 0;
+  static final int VERSION_CURRENT = VERSION_START;
+
+  static class Writer extends BytesBaseImpl.Writer {
+    private Entry[] docToEntry;
+    private final BytesRef.Comparator comp;
+
+    final class Entry extends BytesHash.Entry {
+      int index;
+      long offset;
+    }
+
+    private final BytesHash<Entry> hash = new BytesHash<Entry>(Entry.class) {
+      @Override
+      protected VarSortedBytesImpl.Writer.Entry newEntry() {
+        return new VarSortedBytesImpl.Writer.Entry();
+      }
+      @Override
+      public long bytesPerEntry() {
+        return super.bytesPerEntry() + RamUsageEstimator.NUM_BYTES_INT + RamUsageEstimator.NUM_BYTES_LONG;
+      }
+    };
+
+    public Writer(Directory dir, String id, BytesRef.Comparator comp) throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_CURRENT, true);
+      this.comp = comp;
+      docToEntry = new Entry[1];
+    }
+
+    @Override
+    synchronized public void add(int docID, BytesRef bytes) throws IOException {
+      if (docID >= docToEntry.length) {
+        Entry[] newArray = new Entry[ArrayUtil.getNextSize(1+docID)];
+        System.arraycopy(docToEntry, 0, newArray, 0, docToEntry.length);
+        docToEntry = newArray;
+      }
+      docToEntry[docID] = hash.add(bytes);
+    }      
+
+    @Override
+    synchronized public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_OBJ_REF * docToEntry.length + hash.ramBytesUsed();
+    }
+
+    // Important that we get docCount, in case there were
+    // some last docs that we didn't see
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+
+      Entry[] sortedEntries = hash.sort(comp);
+      final int count = hash.size();
+
+      // first dump bytes data, recording index & offset as
+      // we go
+      long offset = 0;
+      long lastOffset = 0;
+      for(int i=0;i<count;i++) {
+        final Entry e = sortedEntries[i];
+        e.offset = offset;
+        e.index = 1+i;
+
+        final BytesRef bytes = hash.getBytes(e);
+        // TODO: we could prefix code...
+        datOut.writeBytes(bytes.bytes, bytes.offset, bytes.length);
+        lastOffset = offset;
+        offset += bytes.length;
+      }
+
+      // total bytes of data
+      idxOut.writeLong(offset);
+
+      // write index -- first doc -> 1+ord
+      // nocommit -- allow not -1:
+      PackedInts.Writer w = PackedInts.getWriter(idxOut, count, docCount,
+                                                 PackedInts.getNextFixedSize(PackedInts.bitsRequired(count)));
+      final int limit;
+      if (docCount > docToEntry.length) {
+        limit = docToEntry.length;
+      } else {
+        limit = docCount;
+      }
+      for(int i=0;i<limit;i++) {
+        final Entry e = docToEntry[i];
+        if (e == null) {
+          w.add(0);
+        } else {
+          w.add(e.index);
+        }
+      }
+      for(int i=limit;i<docCount;i++) {
+        w.add(0);
+      }
+      w.finish();
+
+      // next ord (0-based) -> offset
+      // nocommit -- allow not -1:
+      w = PackedInts.getWriter(idxOut, lastOffset, count,
+                               PackedInts.getNextFixedSize(PackedInts.bitsRequired(lastOffset)));
+
+      for(int i=0;i<count;i++) {
+        w.add(sortedEntries[i].offset);
+      }
+      w.finish();
+
+      super.finish(docCount);
+    }
+  }
+
+  public static class Reader extends BytesBaseImpl.Reader {
+    private final int maxDoc;
+
+    Reader(Directory dir, String id, int maxDoc)
+      throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_START, true);
+      this.maxDoc = maxDoc;
+    }
+
+    @Override
+    public Bytes.Source load() throws IOException {
+      return loadSorted(null);
+    }
+
+    @Override
+    public Bytes.SortedSource loadSorted(BytesRef.Comparator comp) throws IOException {
+      return new Source(comp);
+    }
+
+    private class Source extends Bytes.SortedSource {
+      // TODO: paged data
+      private final byte[] data;
+      private final BytesRef bytesRef = new BytesRef();
+      private final PackedInts.Reader docToOrd;
+      private final PackedInts.Reader ordToOffset;   // 0-based
+      private final long totBytes;
+      private final int numUniqueValues;
+      private final LookupResult lookupResult = new LookupResult();
+      private final BytesRef.Comparator comp;
+
+      public Source(BytesRef.Comparator comp) throws IOException {
+        datIn.seek(CodecUtil.headerLength(CODEC_NAME));
+        idxIn.seek(CodecUtil.headerLength(CODEC_NAME));
+
+        totBytes = idxIn.readLong();
+        data = new byte[(int) totBytes];
+        datIn.readBytes(data, 0, (int) totBytes);
+
+        docToOrd = PackedInts.getReader(idxIn);
+        numUniqueValues = (int) docToOrd.getMaxValue();
+        ordToOffset = PackedInts.getReader(idxIn);
+        bytesRef.bytes = data;
+        if (comp == null) {
+          // default byte sort order 
+          this.comp = BytesRef.getStraightComparator();
+        } else {
+          this.comp = comp;
+        }
+      }
+
+      @Override
+      public BytesRef getByOrd(int ord) {
+        if (ord == 0) {
+          return null;
+        } else {
+          ord -= 1;
+          return deref(ord);
+        }
+      }
+
+      @Override
+      public int ord(int docID) {
+        return (int) docToOrd.get(docID);
+      }
+
+      @Override
+      public LookupResult getByValue(BytesRef bytes) {
+        return binarySearch(bytes, 0, numUniqueValues-1);
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + data.length + docToOrd.ramBytesUsed() + ordToOffset.ramBytesUsed();
+      }
+
+      @Override
+      public int getValueCount() {
+        return numUniqueValues;
+      }
+
+      // ord is 0-based
+      private BytesRef deref(int ord) {
+        bytesRef.offset = (int) ordToOffset.get(ord);
+        final long nextOffset;
+        if (ord == numUniqueValues-1) {
+          nextOffset = totBytes;
+        } else {
+          nextOffset = ordToOffset.get(1+ord);
+        }
+        bytesRef.length = (int) (nextOffset - bytesRef.offset);
+        return bytesRef;
+      }
+
+      // TODO: share w/ FixedSortedBytesValues?
+      private LookupResult binarySearch(BytesRef b, int low, int high) {
+
+        while (low <= high) {
+          int mid = (low + high) >>> 1;
+          deref(mid);
+          int cmp = comp.compare(bytesRef, b);
+          if (cmp < 0) {
+            low = mid + 1;
+          } else if (cmp > 0) {
+            high = mid - 1;
+          } else {
+            lookupResult.ord = mid+1;
+            lookupResult.found = true;
+            return lookupResult;
+          }
+        }
+        assert comp.compare(bytesRef, b) != 0;
+        lookupResult.ord = low;
+        lookupResult.found = false;
+        return lookupResult;
+      }
+    }
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/VarSortedBytesImpl.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/Cache.java
===================================================================
--- src/java/org/apache/lucene/index/values/Cache.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/Cache.java	(revision 0)
@@ -0,0 +1,94 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.util.BytesRef;
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
+
+public class Cache {
+  final IndexReader r;
+  final Map<String,Ints.Source> ints = new HashMap<String,Ints.Source>();
+  final Map<String,Floats.Source> floats = new HashMap<String,Floats.Source>();
+  final Map<String,Bytes.Source> bytes = new HashMap<String,Bytes.Source>();
+  final Map<String,Bytes.SortedSource> sortedBytes = new HashMap<String,Bytes.SortedSource>();
+
+  public Cache(IndexReader r) {
+    this.r = r;
+  }
+
+  synchronized public Ints.Source getInts(String id) throws IOException {
+    Ints.Source s = ints.get(id);
+    if (s == null) {
+      s = r.getIndexValuesInts(id).load();
+      ints.put(id, s);
+    }
+
+    return s;
+  }
+
+  synchronized public Floats.Source getFloats(String id) throws IOException {
+    Floats.Source s = floats.get(id);
+    if (s == null) {
+      s = r.getIndexValuesFloats(id).load();
+      floats.put(id, s);
+    }
+
+    return s;
+  }
+
+  synchronized public Bytes.SortedSource getSortedBytes(String id, BytesRef.Comparator comp) throws IOException {
+    Bytes.SortedSource s = sortedBytes.get(id);
+    if (s == null) {
+      s = r.getIndexValuesBytes(id).loadSorted(comp);
+      sortedBytes.put(id, s);
+    } else {
+      // TODO: verify comp is the same!
+    }
+
+    return s;
+  }
+
+  synchronized public Bytes.Source getBytes(String id) throws IOException {
+    Bytes.Source s = bytes.get(id);
+    if (s == null) {
+      s = r.getIndexValuesBytes(id).load();
+      bytes.put(id, s);
+    }
+
+    return s;
+  }
+
+  public void purgeInts(String id) {
+    ints.remove(id);
+  }
+
+  public void purgeFloats(String id) {
+    floats.remove(id);
+  }
+
+  public void purgeBytes(String id) {
+    bytes.remove(id);
+  }
+
+  public void purgeSortedBytes(String id) {
+    sortedBytes.remove(id);
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/Cache.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/BytesBaseImpl.java
===================================================================
--- src/java/org/apache/lucene/index/values/BytesBaseImpl.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/BytesBaseImpl.java	(revision 0)
@@ -0,0 +1,177 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+/** Base class for specific Bytes Reader/Writer implementations */
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.CodecUtil;
+import java.util.Collection;
+import java.io.IOException;
+
+public final class BytesBaseImpl {
+
+  // don't instantiate!
+  private BytesBaseImpl() {
+  }
+
+  private static final String DATA_EXTENSION = "dat";
+  private static final String INDEX_EXTENSION = "idx";
+
+  public static enum Mode {STRAIGHT, DEREF, SORTED};
+
+  public static void files(Directory dir, String id, Collection<String> files) throws IOException {
+    files.add(id + "." + DATA_EXTENSION);
+    String idxFile = id + "." + INDEX_EXTENSION;
+    if (dir.fileExists(idxFile)) {
+      files.add(idxFile);
+    }
+  }
+
+  // nocommit -- i shouldn't have to specify fixed?  can
+  // track itself & do the write thing at write time?
+  public static Bytes.Writer getWriter(Directory dir, String id, Mode mode, BytesRef.Comparator comp, boolean fixedSize)
+    throws IOException {
+
+    if (comp == null) {
+      // default byte sort order 
+      // nocommit
+      //comp = BytesRef.getStraightComparator();
+      comp = BytesRef.getUTF8SortedAsUTF16Comparator();
+    }
+
+    if (fixedSize) {
+      if (mode == Mode.STRAIGHT) {
+        return new FixedStraightBytesImpl.Writer(dir, id);
+      } else if (mode == Mode.DEREF) {
+        return new FixedDerefBytesImpl.Writer(dir, id);
+      } else if (mode == Mode.SORTED) {
+        return new FixedSortedBytesImpl.Writer(dir, id, comp);
+      }
+    } else {
+      if (mode == Mode.STRAIGHT) {
+        return new VarStraightBytesImpl.Writer(dir, id);
+      } else if (mode == Mode.DEREF) {
+        return new VarDerefBytesImpl.Writer(dir, id);
+      } else if (mode == Mode.SORTED) {
+        return new VarSortedBytesImpl.Writer(dir, id, comp);
+      }
+    }
+
+    throw new IllegalArgumentException("");
+  }
+
+  // nocommit -- I can peek @ header to determing fixed/mode?
+  public static Bytes.Reader getReader(Directory dir, String id, Mode mode, boolean fixedSize, int maxDoc)
+    throws IOException {
+    if (fixedSize) {
+      if (mode == Mode.STRAIGHT) {
+        return new FixedStraightBytesImpl.Reader(dir, id, maxDoc);
+      } else if (mode == Mode.DEREF) {
+        return new FixedDerefBytesImpl.Reader(dir, id, maxDoc);
+      } else if (mode == Mode.SORTED) {
+        return new FixedSortedBytesImpl.Reader(dir, id, maxDoc);
+      }
+    } else {
+      if (mode == Mode.STRAIGHT) {
+        return new VarStraightBytesImpl.Reader(dir, id, maxDoc);
+      } else if (mode == Mode.DEREF) {
+        return new VarDerefBytesImpl.Reader(dir, id, maxDoc);
+      } else if (mode == Mode.SORTED) {
+        return new VarSortedBytesImpl.Reader(dir, id, maxDoc);
+      }
+    }
+
+    throw new IllegalArgumentException("");
+  }
+
+  public static abstract class Writer extends Bytes.Writer {
+
+    protected IndexOutput idxOut;
+    protected IndexOutput datOut;
+    private final BytesRef bytesRef = new BytesRef();
+
+    protected Writer(Directory dir, String id,  String codecName, int version, boolean doIndex) throws IOException {
+      // nocommit -- shouold we create only when really
+      // necessary?  many impls don't write anything until finish
+      datOut = dir.createOutput(id + "." + DATA_EXTENSION);
+      CodecUtil.writeHeader(datOut, codecName, version);
+      assert datOut.getFilePointer() == CodecUtil.headerLength(codecName);
+      if (doIndex) {
+        idxOut = dir.createOutput(id + "." + INDEX_EXTENSION);
+        CodecUtil.writeHeader(idxOut, codecName, version);
+      } else {
+        idxOut = null;
+      }
+    }
+
+    /** Must be called only with increasing docIDs. It's OK
+     *  for some docIDs to be skipped; they will be filled
+     *  with 0 bytes. */
+    @Override
+    public abstract void add(int docID, BytesRef bytes) throws IOException;
+
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+      datOut.close();
+      if (idxOut != null) {
+        idxOut.close();
+      }
+    }
+  }
+
+  /** Opens all necessary files, but does not read any data
+   *  in until you call {@link #load}. */
+  public static abstract class Reader extends Bytes.Reader {
+
+    protected final IndexInput idxIn;
+    protected final IndexInput datIn;
+    protected final int version;
+    protected final String id;
+
+    protected Reader(Directory dir, String id, String codecName, int maxVersion, boolean doIndex) throws IOException {
+      this.id = id;
+      datIn = dir.openInput(id + "." + DATA_EXTENSION);
+      version = CodecUtil.checkHeader(datIn, codecName, maxVersion);
+
+      if (doIndex) {
+        idxIn = dir.openInput(id + "." + INDEX_EXTENSION);
+        final int version2 = CodecUtil.checkHeader(idxIn, codecName, maxVersion);
+        assert version == version2;
+      } else {
+        idxIn = null;
+      }
+    }
+
+    @Override
+    public abstract Bytes.Source load() throws IOException;
+
+    @Override
+    public void close() throws IOException {
+      if (datIn != null) {
+        datIn.close();
+      }
+      if (idxIn != null) {
+        idxIn.close();
+      }
+    }
+  }
+}
\ No newline at end of file

Property changes on: src/java/org/apache/lucene/index/values/BytesBaseImpl.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/SimpleFloatsImpl.java
===================================================================
--- src/java/org/apache/lucene/index/values/SimpleFloatsImpl.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/SimpleFloatsImpl.java	(revision 0)
@@ -0,0 +1,241 @@
+package org.apache.lucene.index.values;
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.document.Fieldable;
+import org.apache.lucene.document.NumericField;
+import org.apache.lucene.util.UnicodeUtil;
+import org.apache.lucene.util.CodecUtil;
+import org.apache.lucene.util.PackedInts;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.RamUsageEstimator;
+
+import java.io.IOException;
+import java.util.Collection;
+
+/** Exposes writer/reader for floating point values.  You
+ *  can specify 4 (java float) or 8 (java double) byte
+ *  precision. */
+
+public class SimpleFloatsImpl {
+  private static final String CODEC_NAME = "SimpleFloats";
+  static final int VERSION_START = 0;
+  static final int VERSION_CURRENT = VERSION_START;
+
+  private static final String DATA_EXTENSION = "dat";
+
+  public static void files(String id, Collection<String> files) {
+    files.add(id + "." + DATA_EXTENSION);
+  }
+
+  public static Floats.Writer getWriter(Directory dir, String id, int precisionBytes) throws IOException {
+    if (precisionBytes != 4 && precisionBytes != 8) {
+      throw new IllegalArgumentException("precisionBytes must be 4 or 8; got " + precisionBytes);
+    }
+    if (precisionBytes == 4) {
+      return new Float4Writer(dir, id);
+    } else {
+      return new Float8Writer(dir, id);
+    }
+  }
+
+  public static Reader getReader(Directory dir, String id, int maxDoc) throws IOException {
+    return new Reader(dir, id, maxDoc);
+  }
+
+  // Writes 4 bytes (float) per value
+  public static class Float4Writer extends Floats.Writer {
+
+    private float[] docToValue;
+    private final Directory dir;
+    private final String id;
+
+    protected Float4Writer(Directory dir, String id) throws IOException {
+      this.dir = dir;
+      this.id = id;
+      docToValue = new float[1];
+    }
+
+    @Override
+    synchronized public void add(int docID, double v) throws IOException {
+      if (docID >= docToValue.length) {
+        float[] newArray = new float[ArrayUtil.getNextSize(1+docID)];
+        System.arraycopy(docToValue, 0, newArray, 0, docToValue.length);
+        docToValue = newArray;
+      }
+      docToValue[docID] = (float) v;
+    }
+
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+      final IndexOutput datOut = dir.createOutput(id + "." + DATA_EXTENSION);
+      CodecUtil.writeHeader(datOut, CODEC_NAME, VERSION_CURRENT);
+      assert datOut.getFilePointer() == CodecUtil.headerLength(CODEC_NAME);
+      datOut.writeByte((byte) 4);
+
+      final int limit;
+      if (docCount > docToValue.length) {
+        limit = docToValue.length;
+      } else {
+        limit = docCount;
+      }
+      for(int i=0;i<limit;i++) {
+        datOut.writeInt(Float.floatToRawIntBits((float) docToValue[i]));
+      }
+      for(int i=limit;i<docCount;i++) {
+        datOut.writeInt(0);
+      }
+
+      datOut.close();
+    }
+
+    @Override
+    public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + docToValue.length * RamUsageEstimator.NUM_BYTES_FLOAT;
+    }
+  }
+
+  // Writes 8 bytes (double) per value
+  public static class Float8Writer extends Floats.Writer {
+
+    private double[] docToValue;
+
+    private final Directory dir;
+    private final String id;
+
+    protected Float8Writer(Directory dir, String id) throws IOException {
+      this.dir = dir;
+      this.id = id;
+      docToValue = new double[1];
+    }
+
+    @Override
+    synchronized public void add(int docID, double v) throws IOException {
+      if (docID >= docToValue.length) {
+        double[] newArray = new double[ArrayUtil.getNextSize(1+docID)];
+        System.arraycopy(docToValue, 0, newArray, 0, docToValue.length);
+        docToValue = newArray;
+      }
+      docToValue[docID] = v;
+    }
+
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+      final IndexOutput datOut = dir.createOutput(id + "." + DATA_EXTENSION);
+      CodecUtil.writeHeader(datOut, CODEC_NAME, VERSION_CURRENT);
+      assert datOut.getFilePointer() == CodecUtil.headerLength(CODEC_NAME);
+      datOut.writeByte((byte) 8);
+
+      final int limit;
+      if (docCount > docToValue.length) {
+        limit = docToValue.length;
+      } else {
+        limit = docCount;
+      }
+      for(int i=0;i<limit;i++) {
+        datOut.writeLong(Double.doubleToRawLongBits(docToValue[i]));
+      }
+      for(int i=limit;i<docCount;i++) {
+        datOut.writeLong(0);
+      }
+
+      datOut.close();
+    }
+
+    @Override
+    public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + docToValue.length * RamUsageEstimator.NUM_BYTES_DOUBLE;
+    }
+  }
+
+  /** Opens all necessary files, but does not read any data
+   *  in until you call {@link #load}. */
+  public static class Reader extends Floats.Reader {
+
+    private final IndexInput datIn;
+    private final String id;
+    private final int precisionBytes;
+    private final int maxDoc;
+
+    protected Reader(Directory dir, String id, int maxDoc) throws IOException {
+      this.id = id;
+      datIn = dir.openInput(id + "." + DATA_EXTENSION);
+      this.maxDoc = maxDoc;
+      CodecUtil.checkHeader(datIn, CODEC_NAME, VERSION_START);
+      precisionBytes = datIn.readByte();
+      assert precisionBytes == 4 || precisionBytes == 8;
+    }
+
+    /** Loads the actual values.  You may call this more
+     *  than once, eg if you already previously loaded but
+     *  then discarded the Source. */
+    @Override
+    public Floats.Source load() throws IOException {
+      if (precisionBytes == 4) {
+        return new Source4();
+      } else {
+        return new Source8();
+      }
+    }
+
+    private class Source4 extends Floats.Source {
+      private final float[] values;
+
+      public Source4() throws IOException {
+        datIn.seek(CodecUtil.headerLength(CODEC_NAME));
+
+        // skip precision:
+        final byte b = datIn.readByte();
+
+        // TODO: switch to ByteBuffer
+        values = new float[maxDoc];
+        for(int i=0;i<maxDoc;i++) {
+          values[i] = Float.intBitsToFloat(datIn.readInt());
+        }
+      }
+
+      @Override
+      public double get(int docID) {
+        return values[docID];
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + values.length * RamUsageEstimator.NUM_BYTES_FLOAT;
+      }
+    }
+
+    private class Source8 extends Floats.Source {
+      private final double[] values;
+
+      public Source8() throws IOException {
+        datIn.seek(CodecUtil.headerLength(CODEC_NAME));
+
+        // skip precision:
+        datIn.readByte();
+
+        // TODO: switch to ByteBuffer
+        values = new double[maxDoc];
+        for(int i=0;i<maxDoc;i++) {
+          values[i] = Double.longBitsToDouble(datIn.readLong());
+        }
+      }
+
+      @Override
+      public double get(int docID) {
+        return values[docID];
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + values.length * RamUsageEstimator.NUM_BYTES_DOUBLE;
+      }
+    }
+
+    @Override
+    public void close() throws IOException {
+      datIn.close();
+    }
+  }
+}
\ No newline at end of file

Property changes on: src/java/org/apache/lucene/index/values/SimpleFloatsImpl.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/Bytes.java
===================================================================
--- src/java/org/apache/lucene/index/values/Bytes.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/Bytes.java	(revision 0)
@@ -0,0 +1,122 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.document.Fieldable;
+import org.apache.lucene.util.UnicodeUtil;
+import org.apache.lucene.util.CodecUtil;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.ConsumesRAM;
+import org.apache.lucene.index.IndexReader;
+
+import java.io.IOException;
+import java.io.Closeable;
+import java.util.Collection;
+import java.util.List;
+
+/** Provides concrete Writer/Reader impls for byte[] value
+ *  per document.  There are 6 package-private impls of
+ *  this, for all combinations of STRAIGHT/DEREF/SORTED X
+ *  fixed/not fixed.
+ *
+ * <p>NOTE: The total amount of byte[] data stored (across a
+ *    single segment) cannot exceed 2GB. </p>
+ * <p>NOTE: Each byte[] must be <= 32768 bytes in length</p> */
+
+public class Bytes {
+
+  public static abstract class Source implements ConsumesRAM {
+    public abstract BytesRef get(int docID);
+
+    /** Returns number of unique values.  Some impls may
+     * throw UnsupportedOperationException. */
+    public abstract int getValueCount();
+  }
+
+  public static abstract class SortedSource extends Source {
+
+    @Override
+    public BytesRef get(int docID) {
+      return getByOrd(ord(docID));
+    }
+
+    /** Returns ord for specified docID.  If this docID had
+     *  not been added to the Writer, the ord is 0.  Ord is
+     *  dense, ie, starts at 0, then increments by 1 for the
+     *  next (as defined by {@link Comparator} value.  */
+    public abstract int ord(int docID);
+
+    /** Returns value for specified ord. */
+    public abstract BytesRef getByOrd(int ord);
+
+    public static class LookupResult {
+      public boolean found;
+      public int ord;
+    }
+
+    /** Finds the largest ord whose value is <= the
+     *  requested value.  If {@link LookupResult#found} is
+     *  true, then ord is an exact match.  The returned
+     *  {@link LookupResult} may be reused across calls. */
+    public abstract LookupResult getByValue(BytesRef value);
+  }
+
+
+  /** Writes one segment's worth of values */
+  public static abstract class Writer implements ConsumesRAM {
+
+    /** Records the specfied value for the docID */
+    public abstract void add(int docID, BytesRef value) throws IOException;
+
+    /** Finish writing, close any files */
+    public abstract void finish(int docCount) throws IOException;
+
+    public static class MergeState {
+      public Reader bytesReader;
+      public IndexReader reader;                         // TODO: change to Bits with flex
+      public int docBase;
+      public int docCount;
+    }
+
+    public void add(List<MergeState> states) throws IOException {
+      // TODO: replace with more efficient, non RAM resident merging
+      for(MergeState state : states) {
+        final Source s = state.bytesReader.load();
+        int docID = state.docBase;
+        for(int i=0;i<state.docCount;i++) {
+          if (!state.reader.isDeleted(i)) {
+            add(docID++, s.get(i));
+          }
+        }
+      }
+    }
+  }
+
+  public static abstract class Reader implements Closeable {
+    public abstract Source load() throws IOException;
+
+    /** NOTE: the comparator provided here must match the
+     *  one used at indexing. */
+    public SortedSource loadSorted(BytesRef.Comparator comp) throws IOException {
+      throw new UnsupportedOperationException();
+    }
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/Bytes.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/PackedIntsImpl.java
===================================================================
--- src/java/org/apache/lucene/index/values/PackedIntsImpl.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/PackedIntsImpl.java	(revision 0)
@@ -0,0 +1,184 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.util.PackedInts;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.CodecUtil;
+import org.apache.lucene.util.RamUsageEstimator;
+
+import java.util.Collection;
+import java.io.IOException;
+
+/** Stores ints packed with fixed-bit precision. */
+public class PackedIntsImpl {
+
+  private static final String CODEC_NAME = "PackedInts";
+
+  private static final String DATA_EXTENSION = "dat";
+
+  static final int VERSION_START = 0;
+  static final int VERSION_CURRENT = VERSION_START;
+
+  public static void files(String id, Collection<String> files) throws IOException {
+    files.add(id + "." + DATA_EXTENSION);
+  }
+
+  public static Writer getWriter(Directory dir, String id, boolean useFixedArray) throws IOException {
+    return new Writer(dir, id, useFixedArray);
+  }
+
+  public static Reader getReader(Directory dir, String id) throws IOException {
+    return new Reader(dir, id);
+  }
+
+  private static class Writer extends Ints.Writer {
+
+    private long[] docToValue;
+    private long minValue;
+    private long maxValue;
+    private boolean started;
+    private final Directory dir;
+    private final String id;
+    private final boolean useFixedArray;
+
+    protected Writer(Directory dir, String id, boolean useFixedArray) throws IOException {
+      this.dir = dir;
+      this.id = id;
+      this.useFixedArray = useFixedArray;
+      docToValue = new long[1];
+    }
+
+    @Override
+    synchronized public void add(int docID, long v) throws IOException {
+      if (!started) {
+        minValue = maxValue = v;
+        started = true;
+      } else {
+        if (v < minValue) {
+          minValue = v;
+        } else if (v > maxValue) {
+          maxValue = v;
+        }
+      }
+      if (docID >= docToValue.length) {
+        docToValue = ArrayUtil.grow(docToValue, 1+docID);
+      }
+      docToValue[docID] = v;
+    }
+
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+      final IndexOutput datOut = dir.createOutput(id + "." + DATA_EXTENSION);
+      CodecUtil.writeHeader(datOut, CODEC_NAME, VERSION_CURRENT);
+
+      // nocommit -- long can't work right since it's signed
+
+      datOut.writeLong(minValue);
+      final int forceBits;
+      // Detect overflow to mean we need 64 bits
+      if (maxValue - minValue < maxValue) {
+        // nocommit -- is this in fact correct?
+        forceBits = 64;
+      } else if (useFixedArray) {
+        forceBits = PackedInts.getNextFixedSize(PackedInts.bitsRequired(maxValue - minValue));
+      } else {
+        // Let PackedInts fully pack
+        forceBits = -1;
+      }
+
+      // System.out.println("  packed impl minValue=" + minValue);
+
+      PackedInts.Writer w = PackedInts.getWriter(datOut, maxValue-minValue, docCount, forceBits);
+
+      final int limit;
+      if (docCount > docToValue.length) {
+        limit = docToValue.length;
+      } else {
+        limit = docCount;
+      }
+      for(int i=0;i<limit;i++) {
+        w.add(docToValue[i] - minValue);
+      }
+      for(int i=limit;i<docCount;i++) {
+        w.add(0);
+      }
+      w.finish();
+
+      datOut.close();
+    }
+
+    @Override
+    public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + docToValue.length * RamUsageEstimator.NUM_BYTES_LONG;
+    }
+  }
+
+  /** Opens all necessary files, but does not read any data
+   *  in until you call {@link #load}. */
+  private static class Reader extends Ints.Reader {
+
+    private final IndexInput datIn;
+    private final String id;
+
+    protected Reader(Directory dir, String id) throws IOException {
+      this.id = id;
+      datIn = dir.openInput(id + "." + DATA_EXTENSION);
+      CodecUtil.checkHeader(datIn, CODEC_NAME, VERSION_START);
+    }
+
+    /** Loads the actual values.  You may call this more
+     *  than once, eg if you already previously loaded but
+     *  then discarded the Source. */
+    @Override
+    public Source load() throws IOException {
+      return new Source();
+    }
+
+    private class Source extends Ints.Source {
+      private final long minValue;
+      private final PackedInts.Reader values;
+
+      public Source() throws IOException {
+        datIn.seek(CodecUtil.headerLength(CODEC_NAME));
+        minValue = datIn.readLong();
+        values = PackedInts.getReader(datIn);
+      }
+
+      @Override
+      public long get(int docID) {
+        // nocommit -- can we somehow avoid 2X method calls
+        // on each get?  must push minValue down, and make
+        // PackedInts implement Ints.Source
+        return minValue + values.get(docID);
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        return values.ramBytesUsed();
+      }
+    }
+
+    @Override
+    public void close() throws IOException {
+      datIn.close();
+    }
+  }
+}
\ No newline at end of file

Property changes on: src/java/org/apache/lucene/index/values/PackedIntsImpl.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/VarDerefBytesImpl.java
===================================================================
--- src/java/org/apache/lucene/index/values/VarDerefBytesImpl.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/VarDerefBytesImpl.java	(revision 0)
@@ -0,0 +1,187 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesHash;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.PackedInts;
+import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.lucene.util.CodecUtil;
+import java.io.IOException;
+
+import java.util.Collection;
+
+// Stores variable-length byte[] by deref, ie when two docs
+// have the same value, they store only 1 byte[] and both
+// docs reference that single source
+
+class VarDerefBytesImpl {
+
+  static final String CODEC_NAME = "VarDerefBytes";
+  static final int VERSION_START = 0;
+  static final int VERSION_CURRENT = VERSION_START;
+
+  static class Writer extends BytesBaseImpl.Writer {
+    private int[] docToAddress;
+    private int address = 1;
+
+    final class Entry extends BytesHash.Entry {
+      int address;
+    }
+
+    private final BytesHash<Entry> hash = new BytesHash<Entry>(Entry.class) {
+      @Override
+      protected VarDerefBytesImpl.Writer.Entry newEntry() {
+        return new VarDerefBytesImpl.Writer.Entry();
+      }
+      @Override
+      public long bytesPerEntry() {
+        return super.bytesPerEntry() + RamUsageEstimator.NUM_BYTES_INT;
+      }
+    };
+
+    public Writer(Directory dir, String id) throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_CURRENT, true);
+      docToAddress = new int[1];
+    }
+
+    @Override
+    synchronized public void add(int docID, BytesRef bytes) throws IOException {
+      Entry e = hash.add(bytes);
+
+      if (docID >= docToAddress.length) {
+        docToAddress = ArrayUtil.grow(docToAddress, 1+docID);
+      }
+      if (e.address == 0) {
+        e.address = address;
+        // New
+        if (bytes.length < 128) {
+          // 1 byte to store length
+          datOut.writeByte((byte) bytes.length);
+          address++;
+        } else {
+          // 2 byte to store length
+          datOut.writeByte((byte) (0x80 | (bytes.length & 0x7f)));
+          datOut.writeByte((byte) ((bytes.length>>7) & 0xff));
+          address += 2;
+        }
+        datOut.writeBytes(bytes.bytes, bytes.offset, bytes.length);
+        address += bytes.length;
+      }
+
+      docToAddress[docID] = e.address;
+    }
+
+    @Override
+    synchronized public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_INT * docToAddress.length + hash.ramBytesUsed();
+    }
+
+    // Important that we get docCount, in case there were
+    // some last docs that we didn't see
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+
+      idxOut.writeInt(address-1);
+
+      // write index
+      // nocommit -- allow forcing fixed array (not -1)
+      PackedInts.Writer w = PackedInts.getWriter(idxOut, address-1, docCount, -1);
+      final int limit;
+      if (docCount > docToAddress.length) {
+        limit = docToAddress.length;
+      } else {
+        limit = docCount;
+      }
+      for(int i=0;i<limit;i++) {
+        w.add(docToAddress[i]);
+      }
+      for(int i=limit;i<docCount;i++) {
+        w.add(0);
+      }
+      w.finish();
+
+      super.finish(docCount);
+    }
+  }
+
+  public static class Reader extends BytesBaseImpl.Reader {
+    private final int maxDoc;
+
+    Reader(Directory dir, String id, int maxDoc)
+      throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_START, true);
+      this.maxDoc = maxDoc;
+    }
+
+    @Override
+    public Bytes.Source load() throws IOException {
+      return new Source();
+    }
+
+    private class Source extends Bytes.Source {
+      // TODO: paged data
+      private final byte[] data;
+      private final BytesRef bytesRef = new BytesRef();
+      private final PackedInts.Reader index;
+
+      public Source() throws IOException {
+        datIn.seek(CodecUtil.headerLength(CODEC_NAME));
+        idxIn.seek(CodecUtil.headerLength(CODEC_NAME));
+
+        final int totBytes = idxIn.readInt();
+        data = new byte[totBytes];
+        datIn.readBytes(data, 0, totBytes);
+
+        index = PackedInts.getReader(idxIn);
+        bytesRef.bytes = data;
+      }
+
+      @Override
+      public BytesRef get(int docID) {
+        int address = (int) index.get(docID);
+        if (address == 0) {
+          return null;
+        } else {
+          address -= 1;
+          if ((data[address] & 0x80) == 0) {
+            // length is 1 byte
+            bytesRef.length = data[address];
+            bytesRef.offset = address+1;
+          } else {
+            bytesRef.length = (data[address]&0x7f) + ((data[address+1]&0xff)<<7);
+            bytesRef.offset = address+2;
+          }
+          return bytesRef;
+        }
+      }
+      
+      @Override
+      public int getValueCount() {
+        return (int) index.getMaxValue();
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + data.length + index.ramBytesUsed();
+      }
+    }
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/VarDerefBytesImpl.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/VarStraightBytesImpl.java
===================================================================
--- src/java/org/apache/lucene/index/values/VarStraightBytesImpl.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/VarStraightBytesImpl.java	(revision 0)
@@ -0,0 +1,147 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.PackedInts;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.lucene.util.CodecUtil;
+import java.io.IOException;
+
+import java.util.Collection;
+
+// Variable length byte[] per document, no sharing
+
+class VarStraightBytesImpl {
+
+  static final String CODEC_NAME = "VarStraightBytes";
+  static final int VERSION_START = 0;
+  static final int VERSION_CURRENT = VERSION_START;
+
+  static class Writer extends BytesBaseImpl.Writer {
+    private int address;
+    private int lastDocID;
+    private int[] docToAddress;
+
+    public Writer(Directory dir, String id) throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_CURRENT, true);
+      docToAddress = new int[1];
+    }
+
+    // Fills up to but not including this docID
+    private void fill(final int docID) {
+      if (docID >= docToAddress.length) {
+        docToAddress = ArrayUtil.grow(docToAddress, 1+docID);
+      }
+      for(int i=lastDocID+1;i<docID;i++) {
+        docToAddress[i] = address;
+      }
+      lastDocID = docID;
+    }
+
+    @Override
+    synchronized public void add(int docID, BytesRef bytes) throws IOException {
+      fill(docID);
+      docToAddress[docID] = address;
+      datOut.writeBytes(bytes.bytes, bytes.offset, bytes.length);
+      address += bytes.length;
+    }
+
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+      // write all lengths to index
+      // write index
+      fill(docCount);
+      idxOut.writeVInt(address);
+      // nocommit -- allow not -1
+      PackedInts.Writer w = PackedInts.getWriter(idxOut, address, docCount, -1);
+      final int limit;
+      for(int i=0;i<docCount;i++) {
+        w.add(docToAddress[i]);
+      }
+      w.finish();
+
+      super.finish(docCount);
+    }
+
+    @Override
+    synchronized public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + RamUsageEstimator.NUM_BYTES_INT * docToAddress.length;
+    }
+  }
+
+  public static class Reader extends BytesBaseImpl.Reader {
+    private final int maxDoc;
+
+    Reader(Directory dir, String id, int maxDoc)
+      throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_START, true);
+      this.maxDoc = maxDoc;
+    }
+
+    @Override
+    public Bytes.Source load() throws IOException {
+      return new Source();
+    }
+
+    private class Source extends Bytes.Source {
+      private final int totBytes;
+      // TODO: paged data
+      private final byte[] data;
+      private final BytesRef bytesRef = new BytesRef();
+      private final PackedInts.Reader addresses;
+
+      public Source() throws IOException {
+        datIn.seek(CodecUtil.headerLength(CODEC_NAME));
+        idxIn.seek(CodecUtil.headerLength(CODEC_NAME));
+
+        totBytes = idxIn.readVInt();
+        data = new byte[totBytes];
+        datIn.readBytes(data, 0, totBytes);
+
+        addresses = PackedInts.getReader(idxIn);
+
+        bytesRef.bytes = data;
+      }
+
+      @Override
+      public BytesRef get(int docID) {
+        final int address = (int) addresses.get(docID);
+        bytesRef.offset = address;
+        if (docID == maxDoc-1) {
+          bytesRef.length = totBytes - bytesRef.offset;
+        } else {
+          bytesRef.length = (int) addresses.get(1+docID) - bytesRef.offset;
+        }
+        return bytesRef;
+      }
+
+      @Override
+      public int getValueCount() {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        return addresses.ramBytesUsed() + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + data.length;
+      }
+    }
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/VarStraightBytesImpl.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/Floats.java
===================================================================
--- src/java/org/apache/lucene/index/values/Floats.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/Floats.java	(revision 0)
@@ -0,0 +1,86 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.document.Fieldable;
+import org.apache.lucene.document.NumericField;
+import org.apache.lucene.util.UnicodeUtil;
+import org.apache.lucene.util.CodecUtil;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.PackedInts;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.lucene.util.ConsumesRAM;
+
+import java.io.IOException;
+import java.io.Closeable;
+import java.util.Collection;
+import java.util.List;
+
+/** Represents writers & readers of a single float value per
+ *  field X document. */
+
+public final class Floats {
+
+  /** Source of floating point number (returned as java
+   *  double), per document.  The underlying implementation
+   *  may use different numbers of bits per value; double is
+   *  only used since it can handle all precisions.  */
+  public static abstract class Source implements ConsumesRAM {
+    public abstract double get(int docID);
+  }
+
+  /** Writes one segment's worth of values */
+  public static abstract class Writer implements ConsumesRAM {
+    /** Records the specfied value for the docID */
+    public abstract void add(int docID, double value) throws IOException;
+
+    /** Finish writing, close any files */
+    public abstract void finish(int docCount) throws IOException;
+
+    public static class MergeState {
+      public Reader floatsReader;
+      public IndexReader reader;                         // TODO: change to Bits with flex
+      public int docBase;
+      public int docCount;
+    }
+
+    public void add(List<MergeState> states) throws IOException {
+      // TODO: replace with more efficient, non RAM resident merging
+      for(MergeState state : states) {
+        final Source s = state.floatsReader.load();
+        int docID = state.docBase;
+        for(int i=0;i<state.docCount;i++) {
+          if (!state.reader.isDeleted(i)) {
+            add(docID++, s.get(i));
+          }
+        }
+      }
+    }
+  }
+
+  /** Opens files but does not read them until load() is
+   *  called. */
+  public static abstract class Reader implements Closeable {
+    public abstract Source load() throws IOException;
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/Floats.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/FixedSortedBytesImpl.java
===================================================================
--- src/java/org/apache/lucene/index/values/FixedSortedBytesImpl.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/FixedSortedBytesImpl.java	(revision 0)
@@ -0,0 +1,241 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesHash;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.PackedInts;
+import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.lucene.util.CodecUtil;
+import java.io.IOException;
+
+import java.util.Collection;
+
+// Stores fixed-length byte[] by deref, ie when two docs
+// have the same value, they store only 1 byte[]
+
+class FixedSortedBytesImpl {
+
+  static final String CODEC_NAME = "FixedSortedBytes";
+  static final int VERSION_START = 0;
+  static final int VERSION_CURRENT = VERSION_START;
+
+  static class Writer extends BytesBaseImpl.Writer {
+    private int size = -1;
+    private Entry[] docToEntry;
+    private final BytesRef.Comparator comp;
+
+    final static class Entry extends BytesHash.Entry {
+      int address;
+    }
+
+    private final BytesHash<Entry> hash = new BytesHash<Entry>(Entry.class) {
+      @Override
+      protected FixedSortedBytesImpl.Writer.Entry newEntry() {
+        return new FixedSortedBytesImpl.Writer.Entry();
+      }
+      @Override
+      public long bytesPerEntry() {
+        return super.bytesPerEntry() + RamUsageEstimator.NUM_BYTES_INT;
+      }
+    };
+
+    public Writer(Directory dir, String id, BytesRef.Comparator comp) throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_CURRENT, true);
+      docToEntry = new Entry[1];
+      this.comp = comp;
+    }
+
+    @Override
+    synchronized public void add(int docID, BytesRef bytes) throws IOException {
+      if (size == -1) {
+        size = bytes.length;
+        datOut.writeInt(size);
+      } else if (bytes.length != size) {
+        throw new IllegalArgumentException("expected bytes size=" + size + " but got " + bytes.length);
+      }
+      if (docID >= docToEntry.length) {
+        Entry[] newArray = new Entry[ArrayUtil.getNextSize(1+docID)];
+        System.arraycopy(docToEntry, 0, newArray, 0, docToEntry.length);
+        docToEntry = newArray;
+      }
+      docToEntry[docID] = hash.add(bytes);
+    }
+
+    @Override
+    synchronized public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_OBJ_REF * docToEntry.length + hash.ramBytesUsed();
+    }
+
+    // Important that we get docCount, in case there were
+    // some last docs that we didn't see
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+
+      Entry[] sortedEntries = hash.sort(comp);
+      final int count = hash.size();
+
+      // first dump bytes data, recording address as we go
+      for(int i=0;i<count;i++) {
+        final Entry e = sortedEntries[i];
+        final BytesRef bytes = hash.getBytes(e);
+        assert bytes.length == size;
+        datOut.writeBytes(bytes.bytes, bytes.offset, bytes.length);
+        e.address = 1+i;
+      }
+
+      idxOut.writeInt(count);
+
+      // nocommit -- allow forcing bit size (not just -1)
+      // for better perf
+      // next write index
+      PackedInts.Writer w = PackedInts.getWriter(idxOut, count, docCount, -1);
+      final int limit;
+      if (docCount > docToEntry.length) {
+        limit = docToEntry.length;
+      } else {
+        limit = docCount;
+      }
+      for(int i=0;i<limit;i++) {
+        final Entry e = docToEntry[i];
+        if (e == null) {
+          // null is encoded as zero
+          w.add(0);
+        } else {
+          w.add(e.address);
+        }
+      }
+
+      for(int i=limit;i<docCount;i++) {
+        w.add(0);
+      }
+      w.finish();
+
+      super.finish(docCount);
+    }
+  }
+  
+  public static class Reader extends BytesBaseImpl.Reader {
+    // nocommit -- allow/require byte[] paging here?
+    private final int size;
+    private final int maxDoc;
+
+    public Reader(Directory dir, String id, int maxDoc)
+      throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_START, true);
+      size = datIn.readInt();
+      this.maxDoc = maxDoc;
+    }
+
+    @Override
+    public Bytes.Source load() throws IOException {
+      return loadSorted(null);
+    }
+
+    @Override
+    public Bytes.SortedSource loadSorted(BytesRef.Comparator comp) throws IOException {
+      return new Source(comp);
+    }
+
+    private class Source extends Bytes.SortedSource {
+
+      // TODO: paged data
+      private final byte[] data;
+      private final BytesRef bytesRef = new BytesRef();
+      private final PackedInts.Reader index;
+      private final LookupResult lookupResult = new LookupResult();
+      private final int numValue;
+      private final BytesRef.Comparator comp;
+
+      public Source(BytesRef.Comparator comp) throws IOException {
+        datIn.seek(CodecUtil.headerLength(CODEC_NAME) + 4);
+        idxIn.seek(CodecUtil.headerLength(CODEC_NAME));
+
+        numValue = idxIn.readInt();
+        data = new byte[size*numValue];
+        datIn.readBytes(data, 0, size*numValue);
+        datIn.close();
+
+        index = PackedInts.getReader(idxIn);
+        idxIn.close();
+
+        bytesRef.bytes = data;
+        bytesRef.length = size;
+        if (comp == null) {
+          // default byte sort order 
+          this.comp = BytesRef.getStraightComparator();
+        } else {
+          this.comp = comp;
+        }
+      }
+
+      @Override
+      public int ord(int docID) {
+        return (int) index.get(docID);
+      }
+
+      @Override
+      public BytesRef getByOrd(int ord) {
+        if (ord == 0) {
+          return null;
+        } else {
+          bytesRef.offset = (int) ((ord-1) * size);
+          return bytesRef;
+        }
+      }
+
+      @Override
+      public LookupResult getByValue(BytesRef bytes) {
+        return binarySearch(bytes, 0, numValue-1);
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + data.length + index.ramBytesUsed();
+      }
+
+      @Override
+      public int getValueCount() {
+        return numValue;
+      }
+
+      private LookupResult binarySearch(BytesRef b, int low, int high) {
+        
+        while (low <= high) {
+          int mid = (low + high) >>> 1;
+          bytesRef.offset = mid * size;
+          int cmp = comp.compare(bytesRef, b);
+          if (cmp < 0) {
+            low = mid + 1;
+          } else if (cmp > 0) {
+            high = mid - 1;
+          } else {
+            lookupResult.ord = mid+1;
+            lookupResult.found = true;
+            return lookupResult;
+          }
+        }
+        lookupResult.ord = low;
+        lookupResult.found = false;
+        return lookupResult;
+      }
+    }
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/FixedSortedBytesImpl.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/Ints.java
===================================================================
--- src/java/org/apache/lucene/index/values/Ints.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/Ints.java	(revision 0)
@@ -0,0 +1,87 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.document.Fieldable;
+import org.apache.lucene.document.NumericField;
+import org.apache.lucene.util.UnicodeUtil;
+import org.apache.lucene.util.CodecUtil;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.PackedInts;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.lucene.util.ConsumesRAM;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.io.Closeable;
+import java.util.List;
+
+/** Represents writers & readers of a single int value per
+ *  field X document. */
+
+public final class Ints {
+
+  /** Source of integer (returned as java long), per
+   *  document.  The underlying implementation may use
+   *  different numbers of bits per value; long is only
+   *  used since it can handle all precisions.  */
+  public static abstract class Source implements ConsumesRAM {
+    public abstract long get(int docID);
+  }
+
+  /** Writes one segment's worth of values */
+  public static abstract class Writer implements ConsumesRAM {
+
+    /** Records the specfied value for the docID */
+    public abstract void add(int docID, long value) throws IOException;
+
+    /** Finish writing, close any files */
+    public abstract void finish(int docCount) throws IOException;
+
+    public static class MergeState {
+      public Reader intsReader;
+      public IndexReader reader;                         // TODO: change to Bits with flex
+      public int docBase;
+      public int docCount;
+    }
+
+    public void add(List<MergeState> states) throws IOException {
+      // TODO: replace with more efficient, non RAM resident merging
+      for(MergeState state : states) {
+        final Source s = state.intsReader.load();
+        int docID = state.docBase;
+        for(int i=0;i<state.docCount;i++) {
+          if (!state.reader.isDeleted(i)) {
+            add(docID++, s.get(i));
+          }
+        }
+      }
+    }
+  }
+
+  /** Opens files but does not read them until load() is
+   *  called. */
+  public static abstract class Reader implements Closeable {
+    public abstract Source load() throws IOException;
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/Ints.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/FixedDerefBytesImpl.java
===================================================================
--- src/java/org/apache/lucene/index/values/FixedDerefBytesImpl.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/FixedDerefBytesImpl.java	(revision 0)
@@ -0,0 +1,182 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesHash;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.PackedInts;
+import org.apache.lucene.util.RamUsageEstimator;
+import org.apache.lucene.util.CodecUtil;
+import java.io.IOException;
+
+import java.util.Collection;
+
+// Stores fixed-length byte[] by deref, ie when two docs
+// have the same value, they store only 1 byte[]
+
+class FixedDerefBytesImpl {
+
+  static final String CODEC_NAME = "FixedDerefBytes";
+  static final int VERSION_START = 0;
+  static final int VERSION_CURRENT = VERSION_START;
+
+  static class Writer extends BytesBaseImpl.Writer {
+    private int size = -1;
+    private int idUpto = 1;
+    private int[] docToID;
+
+    final class Entry extends BytesHash.Entry {
+      int id;
+      public Entry() {
+        id = idUpto++;
+      }
+    }
+
+    private final BytesHash<Entry> hash = new BytesHash<Entry>(Entry.class) {
+      @Override
+      protected FixedDerefBytesImpl.Writer.Entry newEntry() {
+        return new FixedDerefBytesImpl.Writer.Entry();
+      }
+      @Override
+      public long bytesPerEntry() {
+        return super.bytesPerEntry() + RamUsageEstimator.NUM_BYTES_INT;
+      }
+    };
+
+    public Writer(Directory dir, String id) throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_CURRENT, true);
+      docToID = new int[1];
+    }
+
+    @Override
+    synchronized public void add(int docID, BytesRef bytes) throws IOException {
+      if (size == -1) {
+        size = bytes.length;
+        datOut.writeInt(size);
+      } else if (bytes.length != size) {
+        throw new IllegalArgumentException("expected bytes size=" + size + " but got " + bytes.length);
+      }
+      final int idUptoStart = idUpto;
+      Entry e = hash.add(bytes);
+
+      if (e.id == idUptoStart) {
+        // New
+        datOut.writeBytes(bytes.bytes, bytes.offset, bytes.length);
+      }
+
+      if (docID >= docToID.length) {
+        docToID = ArrayUtil.grow(docToID, 1+docID);
+      }
+      docToID[docID] = e.id;
+    }
+
+    @Override
+    synchronized public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_INT * docToID.length + hash.ramBytesUsed();
+    }
+
+    // Important that we get docCount, in case there were
+    // some last docs that we didn't see
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+
+      idxOut.writeInt(idUpto-1);
+
+      // write index
+      // nocommit -- optionally use force bits:
+      PackedInts.Writer w = PackedInts.getWriter(idxOut, idUpto-1, docCount, -1);
+      final int limit;
+      if (docCount > docToID.length) {
+        limit = docToID.length;
+      } else {
+        limit = docCount;
+      }
+      for(int i=0;i<limit;i++) {
+        w.add(docToID[i]);
+      }
+      for(int i=limit;i<docCount;i++) {
+        w.add(0);
+      }
+      w.finish();
+
+      super.finish(docCount);
+    }
+  }
+
+  public static class Reader extends BytesBaseImpl.Reader {
+    private final int size;
+    private final int maxDoc;
+
+    Reader(Directory dir, String id, int maxDoc)
+      throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_START, true);
+
+      size = datIn.readInt();
+      this.maxDoc = maxDoc;
+    }
+
+    @Override
+    public Bytes.Source load() throws IOException {
+      return new Source();
+    }
+
+    private class Source extends Bytes.Source {
+      // TODO: paged data
+      private final byte[] data;
+      private final BytesRef bytesRef = new BytesRef();
+      private final PackedInts.Reader index;
+      private final int numValue;
+
+      public Source() throws IOException {
+        datIn.seek(CodecUtil.headerLength(CODEC_NAME) + 4);
+        idxIn.seek(CodecUtil.headerLength(CODEC_NAME));
+
+        numValue = idxIn.readInt();
+        data = new byte[size*numValue];
+        datIn.readBytes(data, 0, size*numValue);
+
+        index = PackedInts.getReader(idxIn);
+        bytesRef.bytes = data;
+        bytesRef.length = size;
+      }
+
+      @Override
+      public BytesRef get(int docID) {
+        final int id = (int) index.get(docID);
+        if (id == 0) {
+          return null;
+        } else {
+          bytesRef.offset = (int) ((id-1) * size);
+          return bytesRef;
+        }
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + data.length + index.ramBytesUsed();
+      }
+
+      @Override
+      public int getValueCount() {
+        return numValue;
+      }
+    }
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/FixedDerefBytesImpl.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/values/FixedStraightBytesImpl.java
===================================================================
--- src/java/org/apache/lucene/index/values/FixedStraightBytesImpl.java	(revision 0)
+++ src/java/org/apache/lucene/index/values/FixedStraightBytesImpl.java	(revision 0)
@@ -0,0 +1,133 @@
+package org.apache.lucene.index.values;
+
+/**
+ * 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.
+ */
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.CodecUtil;
+import org.apache.lucene.util.RamUsageEstimator;
+import java.io.IOException;
+
+import java.util.Collection;
+
+// Simplest storage: stores fixed length byte[] per
+// document, with no dedup and no sorting.
+
+class FixedStraightBytesImpl {
+
+  static final String CODEC_NAME = "FixedStraightBytes";
+  static final int VERSION_START = 0;
+  static final int VERSION_CURRENT = VERSION_START;
+
+  static class Writer extends BytesBaseImpl.Writer {
+    private int size = -1;
+    private int lastDocID;
+
+    protected Writer(Directory dir, String id) throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_CURRENT, false);
+    }
+
+    @Override
+    synchronized public void add(int docID, BytesRef bytes) throws IOException {
+      if (size == -1) {
+        size = bytes.length;
+        datOut.writeInt(size);
+      } else if (bytes.length != size) {
+        throw new IllegalArgumentException("expected bytes size=" + size + " but got " + bytes.length);
+      }
+      fill(docID);
+      // nocommit -- should IndexOutput have a writeBytes(ByteRef)?
+      datOut.writeBytes(bytes.bytes, bytes.offset, bytes.length);
+    }
+
+    // Fills up to but not including this docID
+    private void fill(int docID) throws IOException {
+      final int fill = size*(docID - lastDocID - 1);
+      for(int i=0;i<fill;i++) {
+        datOut.writeByte((byte) 0);
+      }
+      lastDocID = docID;
+    }
+
+    @Override
+    synchronized public void finish(int docCount) throws IOException {
+      fill(docCount);
+      super.finish(docCount);
+    }
+
+    @Override
+    synchronized public long ramBytesUsed() {
+      return 0;
+    }
+  }
+
+  public static class Reader extends BytesBaseImpl.Reader {
+    private final int size;
+    private final int maxDoc;
+
+    Reader(Directory dir, String id, int maxDoc)
+      throws IOException {
+      super(dir, id, CODEC_NAME, VERSION_START, false);
+
+      size = datIn.readInt();
+      this.maxDoc = maxDoc;
+    }
+
+    @Override
+    public Bytes.Source load() throws IOException {
+      return new Source();
+    }
+
+    @Override
+    public void close() throws IOException {
+      datIn.close();
+    }
+
+    private class Source extends Bytes.Source {
+      // TODO: paged data
+      private final byte[] data;
+      private final BytesRef bytesRef = new BytesRef();
+
+      public Source() throws IOException {
+        datIn.seek(CodecUtil.headerLength(CODEC_NAME) + 4);
+
+        data = new byte[size*maxDoc];
+        datIn.readBytes(data, 0, size*maxDoc);
+
+        bytesRef.bytes = data;
+        bytesRef.length = size;
+      }
+
+      @Override
+      public BytesRef get(int docID) {
+        bytesRef.offset = docID * size;
+        return bytesRef;
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + data.length;
+      }
+
+      @Override
+      public int getValueCount() {
+        throw new UnsupportedOperationException();
+      }
+    }
+  }
+}

Property changes on: src/java/org/apache/lucene/index/values/FixedStraightBytesImpl.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/index/SegmentReader.java
===================================================================
--- src/java/org/apache/lucene/index/SegmentReader.java	(revision 900008)
+++ src/java/org/apache/lucene/index/SegmentReader.java	(working copy)
@@ -30,6 +30,7 @@
 
 import java.util.concurrent.atomic.AtomicInteger;
 import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
 import org.apache.lucene.document.FieldSelector;
 import org.apache.lucene.search.Similarity;
 import org.apache.lucene.store.BufferedIndexInput;
@@ -38,7 +39,14 @@
 import org.apache.lucene.store.IndexOutput;
 import org.apache.lucene.util.BitVector;
 import org.apache.lucene.util.CloseableThreadLocal;
+import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.search.FieldCache; // not great (circular); used only to purge FieldCache entry on close
+import org.apache.lucene.index.values.Ints;
+import org.apache.lucene.index.values.PackedIntsImpl;
+import org.apache.lucene.index.values.Floats;
+import org.apache.lucene.index.values.SimpleFloatsImpl;
+import org.apache.lucene.index.values.Bytes;
+import org.apache.lucene.index.values.BytesBaseImpl;
 
 /**
  * <p><b>NOTE:</b> This API is new and still experimental
@@ -136,6 +144,9 @@
         } else {
           proxStream = null;
         }
+
+        openIndexValuesReaders(cfsDir, si);
+
         success = true;
       } finally {
         if (!success) {
@@ -150,6 +161,55 @@
       this.origInstance = origInstance;
     }
 
+    final Map<String,Ints.Reader> intValues = new HashMap<String,Ints.Reader>();
+    final Map<String,Floats.Reader> floatValues = new HashMap<String,Floats.Reader>();
+    final Map<String,Bytes.Reader> bytesValues = new HashMap<String,Bytes.Reader>();
+
+    // Only opens files... doesn't actually load any values
+    private void openIndexValuesReaders(Directory dir, SegmentInfo si) throws IOException {
+      final int numFields = fieldInfos.size();
+      for(int i=0;i<numFields;i++) {
+        final FieldInfo fieldInfo = fieldInfos.fieldInfo(i);
+        final Field.Values v = fieldInfo.getIndexValues();
+        if (v != null) {
+          final String field = fieldInfo.name;
+          final String id = segment + "_" + fieldInfo.number;
+          switch(v) {
+          case PACKED_INTS:
+          case PACKED_INTS_FIXED:
+            intValues.put(field, PackedIntsImpl.getReader(dir, id));
+            break;
+          case SIMPLE_FLOAT_4BYTE:
+            floatValues.put(field, SimpleFloatsImpl.getReader(dir, id, si.docCount));
+            break;
+          case SIMPLE_FLOAT_8BYTE:
+            floatValues.put(field, SimpleFloatsImpl.getReader(dir, id, si.docCount));
+            break;
+          case BYTES_FIXED_STRAIGHT:
+            bytesValues.put(field, BytesBaseImpl.getReader(dir, id, BytesBaseImpl.Mode.STRAIGHT, true, si.docCount));
+            break;
+          case BYTES_FIXED_DEREF:
+            bytesValues.put(field, BytesBaseImpl.getReader(dir, id, BytesBaseImpl.Mode.DEREF, true, si.docCount));
+            break;
+          case BYTES_FIXED_SORTED:
+            bytesValues.put(field, BytesBaseImpl.getReader(dir, id, BytesBaseImpl.Mode.SORTED, true, si.docCount));
+            break;
+          case BYTES_VAR_STRAIGHT:
+            bytesValues.put(field, BytesBaseImpl.getReader(dir, id, BytesBaseImpl.Mode.STRAIGHT, false, si.docCount));
+            break;
+          case BYTES_VAR_DEREF:
+            bytesValues.put(field, BytesBaseImpl.getReader(dir, id, BytesBaseImpl.Mode.DEREF, false, si.docCount));
+            break;
+          case BYTES_VAR_SORTED:
+            bytesValues.put(field, BytesBaseImpl.getReader(dir, id, BytesBaseImpl.Mode.SORTED, false, si.docCount));
+            break;
+          default:
+            throw new IllegalStateException("unrecognized index values mode " + v);
+          }
+        }
+      }
+    }
+
     synchronized TermVectorsReader getTermVectorsReaderOrig() {
       return termVectorsReaderOrig;
     }
@@ -243,12 +303,26 @@
         }
 
         // Force FieldCache to evict our entries at this point
-        if (freqStream != null) {
+        if (freqStream != null && origInstance != null) {
           FieldCache.DEFAULT.purge(origInstance);
         }
+
+        closeIndexValuesReaders();
       }
     }
 
+    private void closeIndexValuesReaders() throws IOException {
+      for(Ints.Reader reader : intValues.values()) {
+        reader.close();
+      }
+      for(Floats.Reader reader : floatValues.values()) {
+        reader.close();
+      }
+      for(Bytes.Reader reader : bytesValues.values()) {
+        reader.close();
+      }
+    }
+
     synchronized void openDocStores(SegmentInfo si) throws IOException {
 
       assert si.name.equals(segment);
@@ -1302,4 +1376,19 @@
   public int getTermInfosIndexDivisor() {
     return core.termsIndexDivisor;
   }
+
+  @Override
+  public Ints.Reader getIndexValuesInts(String field) {
+    return core.intValues.get(field);
+  }
+
+  @Override
+  public Floats.Reader getIndexValuesFloats(String field) {
+    return core.floatValues.get(field);
+  }
+
+  @Override
+  public Bytes.Reader getIndexValuesBytes(String field) {
+    return core.bytesValues.get(field);
+  }
 }
Index: src/java/org/apache/lucene/index/DocFieldProcessorPerThread.java
===================================================================
--- src/java/org/apache/lucene/index/DocFieldProcessorPerThread.java	(revision 900008)
+++ src/java/org/apache/lucene/index/DocFieldProcessorPerThread.java	(working copy)
@@ -242,8 +242,16 @@
     // here.
     quickSort(fields, 0, fieldCount-1);
 
-    for(int i=0;i<fieldCount;i++)
+    for(int i=0;i<fieldCount;i++) {
       fields[i].consumer.processFields(fields[i].fields, fields[i].fieldCount);
+      final DocFieldProcessor.IndexValuesProcessor p = docFieldProcessor.getProcessor(docState.docWriter.directory,
+                                                                    docState.docWriter.segment,
+                                                                    fields[i].fields[0],
+                                                                    fields[i].fieldInfo);
+      if (p != null) {
+        p.add(docState.docID, fields[i].fields[0]);
+      }
+    }
 
     if (docState.maxTermPrefix != null && docState.infoStream != null) {
       docState.infoStream.println("WARNING: document contains at least one immense term (longer than the max length " + DocumentsWriter.MAX_TERM_LENGTH + "), all of which were skipped.  Please correct the analyzer to not produce such terms.  The prefix of the first immense term is: '" + docState.maxTermPrefix + "...'");
Index: src/java/org/apache/lucene/index/DirectoryReader.java
===================================================================
--- src/java/org/apache/lucene/index/DirectoryReader.java	(revision 900008)
+++ src/java/org/apache/lucene/index/DirectoryReader.java	(working copy)
@@ -36,6 +36,9 @@
 import org.apache.lucene.store.Lock;
 import org.apache.lucene.store.LockObtainFailedException;
 import org.apache.lucene.search.FieldCache; // not great (circular); used only to purge FieldCache entry on close
+import org.apache.lucene.index.values.Ints;
+import org.apache.lucene.index.values.Floats;
+import org.apache.lucene.index.values.Bytes;
 
 /** 
  * An IndexReader which reads indexes with multiple segments.
@@ -1301,4 +1304,31 @@
       return ((TermPositions) current).isPayloadAvailable();
     }
   }
+
+  public Ints.Reader getIndexValuesInts(String field) {
+    ensureOpen();
+    if (subReaders.length == 1) {
+      return subReaders[0].getIndexValuesInts(field);
+    } else {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  public Floats.Reader getIndexValuesFloats(String field) {
+    ensureOpen();
+    if (subReaders.length == 1) {
+      return subReaders[0].getIndexValuesFloats(field);
+    } else {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  public Bytes.Reader getIndexValuesBytes(String field) {
+    ensureOpen();
+    if (subReaders.length == 1) {
+      return subReaders[0].getIndexValuesBytes(field);
+    } else {
+      throw new UnsupportedOperationException();
+    }
+  }
 }
Index: src/java/org/apache/lucene/index/SegmentMerger.java
===================================================================
--- src/java/org/apache/lucene/index/SegmentMerger.java	(revision 900008)
+++ src/java/org/apache/lucene/index/SegmentMerger.java	(working copy)
@@ -24,8 +24,15 @@
 import java.util.List;
 
 import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
 import org.apache.lucene.index.IndexReader.FieldOption;
 import org.apache.lucene.index.MergePolicy.MergeAbortedException;
+import org.apache.lucene.index.values.Ints;
+import org.apache.lucene.index.values.PackedIntsImpl;
+import org.apache.lucene.index.values.Floats;
+import org.apache.lucene.index.values.SimpleFloatsImpl;
+import org.apache.lucene.index.values.Bytes;
+import org.apache.lucene.index.values.BytesBaseImpl;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.IndexInput;
 import org.apache.lucene.store.IndexOutput;
@@ -157,6 +164,8 @@
     if (mergeDocStores && fieldInfos.hasVectors())
       mergeVectors();
 
+    mergeIndexValues();
+
     return mergedDocs;
   }
 
@@ -200,6 +209,31 @@
       }
     }
 
+    // Index values files
+    for (int i = 0; i < fieldInfos.size(); i++) {
+      FieldInfo fi = fieldInfos.fieldInfo(i);
+      if (fi.indexValues != null) {
+        final String id = segment + "_" + fi.number;
+        switch(fi.indexValues) {
+        case PACKED_INTS:
+          PackedIntsImpl.files(id, files);
+          break;
+        case SIMPLE_FLOAT_4BYTE:
+        case SIMPLE_FLOAT_8BYTE:
+          SimpleFloatsImpl.files(id, files);
+          break;
+        case BYTES_FIXED_STRAIGHT:
+        case BYTES_FIXED_DEREF:
+        case BYTES_FIXED_SORTED:
+        case BYTES_VAR_STRAIGHT:
+        case BYTES_VAR_DEREF:
+        case BYTES_VAR_SORTED:
+          BytesBaseImpl.files(directory, id, files);
+          break;
+        }
+      }
+    }
+
     // Vector files
     if (fieldInfos.hasVectors() && mergeDocStores) {
       for (int i = 0; i < IndexFileNames.VECTOR_EXTENSIONS.length; i++) {
@@ -292,10 +326,18 @@
         int numReaderFieldInfos = readerFieldInfos.size();
         for (int j = 0; j < numReaderFieldInfos; j++) {
           FieldInfo fi = readerFieldInfos.fieldInfo(j);
-          fieldInfos.add(fi.name, fi.isIndexed, fi.storeTermVector,
-              fi.storePositionWithTermVector, fi.storeOffsetWithTermVector,
-              !reader.hasNorms(fi.name), fi.storePayloads,
-              fi.omitTermFreqAndPositions);
+          FieldInfo merged = fieldInfos.add(fi.name, fi.isIndexed, fi.storeTermVector,
+                                            fi.storePositionWithTermVector, fi.storeOffsetWithTermVector,
+                                            !reader.hasNorms(fi.name), fi.storePayloads,
+                                            fi.omitTermFreqAndPositions);
+          final Field.Values fiIndexValues = fi.indexValues;
+          final Field.Values mergedIndexValues = merged.indexValues;
+          if (mergedIndexValues == null) {
+            merged.setIndexValues(fiIndexValues);
+          } else if (mergedIndexValues != fiIndexValues) {
+            // nocommit -- what to do?
+            throw new IllegalStateException("cannot merge field " + fi.name + " indexValues changed from " + mergedIndexValues + " to " + fiIndexValues);
+          }
         }
       } else {
         addIndexed(reader, fieldInfos, reader.getFieldNames(FieldOption.TERMVECTOR_WITH_POSITION_OFFSET), true, true, true, false, false);
@@ -306,6 +348,8 @@
         addIndexed(reader, fieldInfos, reader.getFieldNames(FieldOption.STORES_PAYLOADS), false, false, false, true, false);
         addIndexed(reader, fieldInfos, reader.getFieldNames(FieldOption.INDEXED), false, false, false, false, false);
         fieldInfos.add(reader.getFieldNames(FieldOption.UNINDEXED), false);
+
+        // nocommit -- how should we handle index values here?
       }
     }
     fieldInfos.write(directory, segment + ".fnm");
@@ -363,6 +407,144 @@
     return docCount;
   }
 
+  private void mergeIndexValues() throws IOException {
+    final int numFields = fieldInfos.size();
+    for(int i=0;i<numFields;i++) {
+      final FieldInfo fieldInfo = fieldInfos.fieldInfo(i);
+
+      final Field.Values v = fieldInfo.indexValues;
+
+      if (v != null) {
+
+        int docBase = 0;
+
+        List<Ints.Writer.MergeState> intsMergeStates = null;
+        List<Floats.Writer.MergeState> floatsMergeStates = null;
+        List<Bytes.Writer.MergeState> bytesMergeStates = null;
+
+        for(IndexReader reader : readers) {
+          Ints.Reader ints = reader.getIndexValuesInts(fieldInfo.name);
+          if (ints != null) {
+            if (intsMergeStates == null) {
+              intsMergeStates = new ArrayList<Ints.Writer.MergeState>();
+            }
+            final Ints.Writer.MergeState state = new Ints.Writer.MergeState();
+            state.intsReader = ints;
+            state.reader = reader;
+            state.docBase = docBase;
+            state.docCount = reader.maxDoc();
+            intsMergeStates.add(state);
+          }
+
+          Floats.Reader floats = reader.getIndexValuesFloats(fieldInfo.name);
+          if (floats != null) {
+            if (floatsMergeStates == null) {
+              floatsMergeStates = new ArrayList<Floats.Writer.MergeState>();
+            }
+            final Floats.Writer.MergeState state = new Floats.Writer.MergeState();
+            state.floatsReader = floats;
+            state.reader = reader;
+            state.docBase = docBase;
+            state.docCount = reader.maxDoc();
+            floatsMergeStates.add(state);
+          }
+
+          Bytes.Reader bytes = reader.getIndexValuesBytes(fieldInfo.name);
+          if (bytes != null) {
+            if (bytesMergeStates == null) {
+              bytesMergeStates = new ArrayList<Bytes.Writer.MergeState>();
+            }
+            final Bytes.Writer.MergeState state = new Bytes.Writer.MergeState();
+            state.bytesReader = bytes;
+            state.reader = reader;
+            state.docBase = docBase;
+            state.docCount = reader.maxDoc();
+            bytesMergeStates.add(state);
+          }
+
+          docBase += reader.numDocs();
+        }
+
+        final String id = segment + "_" + fieldInfo.number;
+
+        switch(v) {
+        case PACKED_INTS:
+          {
+            Ints.Writer writer = PackedIntsImpl.getWriter(directory, id, false);
+            writer.add(intsMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        case PACKED_INTS_FIXED:
+          {
+            Ints.Writer writer = PackedIntsImpl.getWriter(directory, id, true);
+            writer.add(intsMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        case SIMPLE_FLOAT_4BYTE:
+          {
+            Floats.Writer writer = SimpleFloatsImpl.getWriter(directory, id, 4);
+            writer.add(floatsMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        case SIMPLE_FLOAT_8BYTE:
+          {
+            Floats.Writer writer = SimpleFloatsImpl.getWriter(directory, id, 8);
+            writer.add(floatsMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        case BYTES_FIXED_STRAIGHT:
+          {
+            Bytes.Writer writer = BytesBaseImpl.getWriter(directory, id, BytesBaseImpl.Mode.STRAIGHT, null, true);
+            writer.add(bytesMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        case BYTES_FIXED_DEREF:
+          {
+            Bytes.Writer writer = BytesBaseImpl.getWriter(directory, id, BytesBaseImpl.Mode.DEREF, null, true);
+            writer.add(bytesMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        case BYTES_FIXED_SORTED:
+          {
+            // nocommit -- enable setting Comparator
+            Bytes.Writer writer = BytesBaseImpl.getWriter(directory, id, BytesBaseImpl.Mode.SORTED, null, true);
+            writer.add(bytesMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        case BYTES_VAR_STRAIGHT:
+          {
+            Bytes.Writer writer = BytesBaseImpl.getWriter(directory, id, BytesBaseImpl.Mode.STRAIGHT, null, false);
+            writer.add(bytesMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        case BYTES_VAR_DEREF:
+          {
+            Bytes.Writer writer = BytesBaseImpl.getWriter(directory, id, BytesBaseImpl.Mode.DEREF, null, false);
+            writer.add(bytesMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        case BYTES_VAR_SORTED:
+          {
+            // nocommit -- enable setting Comparator
+            Bytes.Writer writer = BytesBaseImpl.getWriter(directory, id, BytesBaseImpl.Mode.SORTED, null, false);
+            writer.add(bytesMergeStates);
+            writer.finish(mergedDocs);
+            break;
+          }
+        }
+      }
+    }
+  }
+
   private int copyFieldsWithDeletions(final FieldsWriter fieldsWriter, final IndexReader reader,
                                       final FieldsReader matchingFieldsReader)
     throws IOException, MergeAbortedException, CorruptIndexException {
Index: src/java/org/apache/lucene/index/DocFieldProcessor.java
===================================================================
--- src/java/org/apache/lucene/index/DocFieldProcessor.java	(revision 900008)
+++ src/java/org/apache/lucene/index/DocFieldProcessor.java	(working copy)
@@ -17,6 +17,20 @@
  * limitations under the License.
  */
 
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.document.Fieldable;
+import org.apache.lucene.index.values.Floats;
+import org.apache.lucene.index.values.SimpleFloatsImpl;
+import org.apache.lucene.index.values.Ints;
+import org.apache.lucene.index.values.PackedIntsImpl;
+import org.apache.lucene.index.values.Bytes;
+import org.apache.lucene.index.values.BytesBaseImpl;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.UnicodeUtil;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.AbstractField;
+import org.apache.lucene.document.NumericField;
+
 import java.io.IOException;
 import java.util.Collection;
 import java.util.Map;
@@ -37,7 +51,200 @@
   final FieldInfos fieldInfos = new FieldInfos();
   final DocFieldConsumer consumer;
   final StoredFieldsWriter fieldsWriter;
+  final private Map<String,IndexValuesProcessor> indexValues = new HashMap<String,IndexValuesProcessor>();
 
+  synchronized IndexValuesProcessor getProcessor(Directory dir, String segment, Fieldable field, FieldInfo fieldInfo)
+    throws IOException {
+    IndexValuesProcessor p = indexValues.get(field.name());
+    if (p == null) {
+      if (field instanceof AbstractField) {
+        final AbstractField f = (AbstractField) field;
+        Field.Values v = f.getIndexValues();
+        if (v == null) {
+          indexValues.put(field.name(), null);
+          return null;
+        }
+        final String id = segment + "_" + fieldInfo.number;
+        switch(v) {
+        case PACKED_INTS:
+          p = new IntValuesProcessor(dir, id, false);
+          break;
+        case PACKED_INTS_FIXED:
+          p = new IntValuesProcessor(dir, id, true);
+          break;
+        case SIMPLE_FLOAT_4BYTE:
+          p = new FloatValuesProcessor(dir, id, 4);
+          break;
+        case SIMPLE_FLOAT_8BYTE:
+          p = new FloatValuesProcessor(dir, id, 8);
+          break;
+        case BYTES_FIXED_STRAIGHT:
+          p = new BytesValuesProcessor(dir, id, true, null, BytesBaseImpl.Mode.STRAIGHT);
+          break;
+        case BYTES_FIXED_DEREF:
+          p = new BytesValuesProcessor(dir, id, true, null, BytesBaseImpl.Mode.DEREF);
+          break;
+        case BYTES_FIXED_SORTED:
+          p = new BytesValuesProcessor(dir, id, true, f.getBytesComparator(), BytesBaseImpl.Mode.SORTED);
+          break;
+        case BYTES_VAR_STRAIGHT:
+          p = new BytesValuesProcessor(dir, id, false, null, BytesBaseImpl.Mode.STRAIGHT);
+          break;
+        case BYTES_VAR_DEREF:
+          p = new BytesValuesProcessor(dir, id, false, null, BytesBaseImpl.Mode.DEREF);
+          break;
+        case BYTES_VAR_SORTED:
+          p = new BytesValuesProcessor(dir, id, false, f.getBytesComparator(), BytesBaseImpl.Mode.SORTED);
+          break;
+        }
+        fieldInfo.setIndexValues(v);
+        indexValues.put(field.name(), p);
+      } else {
+        indexValues.put(field.name(), null);
+        return null;
+      }
+    }
+
+    return p;
+  }
+
+  static abstract class IndexValuesProcessor {
+    public abstract void add(int docID, Fieldable field) throws IOException;
+    public abstract void finish(int docCount) throws IOException;
+    public abstract void files(Collection<String> files) throws IOException;
+  }
+
+  static class FloatValuesProcessor extends IndexValuesProcessor {
+    private final int precision;
+    private final Floats.Writer writer;
+    private final String id;
+
+    public FloatValuesProcessor(Directory dir, String id, int precision) throws IOException {
+      this.precision = precision;
+      this.id = id;
+      writer = SimpleFloatsImpl.getWriter(dir, id, precision);
+    }
+
+    @Override
+    public void add(int docID, Fieldable field) throws IOException {
+      if (field instanceof NumericField) {
+        final Number n = ((NumericField) field).getNumericValue();
+        writer.add(docID, n.doubleValue());
+        return;
+      } else {
+        final String s = field.stringValue();
+        if (s != null) {
+          writer.add(docID, Double.parseDouble(s));
+          return;
+        }
+      }
+
+      throw new IllegalArgumentException("could not extract float/double from field " + field);
+    }
+
+    @Override
+    public void finish(int docCount) throws IOException {
+      writer.finish(docCount);
+    }
+
+    @Override
+    public void files(Collection<String> files) {
+      SimpleFloatsImpl.files(id, files);
+    }
+  }
+
+  static class IntValuesProcessor extends IndexValuesProcessor {
+    private final Ints.Writer writer;
+    private final String id;
+
+    public IntValuesProcessor(Directory dir, String id, boolean fixedArray) throws IOException {
+      this.id = id;
+      writer = PackedIntsImpl.getWriter(dir, id, fixedArray);
+    }
+
+    @Override
+    public void add(int docID, Fieldable field) throws IOException {
+      if (field instanceof NumericField) {
+        final Number n = ((NumericField) field).getNumericValue();
+        writer.add(docID, n.longValue());
+        return;
+      } else {
+        final String s = field.stringValue();
+        if (s != null) {
+          writer.add(docID, Long.parseLong(s));
+          return;
+        }
+      }
+
+      throw new IllegalArgumentException("could not extract int/long from field " + field);
+    }
+
+    @Override
+    public void finish(int docCount) throws IOException {
+      writer.finish(docCount);
+    }
+
+    @Override
+    public void files(Collection<String> files) throws IOException {
+      PackedIntsImpl.files(id, files);
+    }
+  }
+
+  static class BytesValuesProcessor extends IndexValuesProcessor {
+    private final Bytes.Writer writer;
+    private final String id;
+    private final Directory dir;
+
+    public BytesValuesProcessor(Directory dir, String id, boolean fixedSize, BytesRef.Comparator comp, BytesBaseImpl.Mode mode) throws IOException {
+      this.id = id;
+      writer = BytesBaseImpl.getWriter(dir, id, mode, comp, fixedSize);
+      this.dir = dir;
+    }
+
+    private final UnicodeUtil.UTF8Result utf8Result = new UnicodeUtil.UTF8Result();
+    private final BytesRef bytesRef = new BytesRef();
+
+    // nocommit -- make this thread private and not sync'd
+    @Override
+    public synchronized void add(int docID, Fieldable field) throws IOException {
+      // nocommit -- should we insist on upfront binding, ie,
+      // "this field will be binary" or "this field will be
+      // String", and enforce here?  as is, one could flip
+      // back and forth per document
+      // nocommit -- also, we could use this to
+      // differentiate best default Comparator
+      if (field.isBinary()) {
+        bytesRef.bytes = field.getBinaryValue();
+        bytesRef.length = field.getBinaryLength();
+        bytesRef.offset = field.getBinaryOffset();
+        writer.add(docID, bytesRef);
+        return;
+      } else {
+        final String v = field.stringValue();
+        if (v != null) {
+          UnicodeUtil.UTF16toUTF8(v, 0, v.length(), utf8Result);
+          bytesRef.bytes = utf8Result.result;
+          bytesRef.length = utf8Result.length;
+          bytesRef.offset = 0;
+          writer.add(docID, bytesRef);
+          return;
+        }
+      }
+
+      throw new IllegalArgumentException("could not extract byte[] from field " + field);
+    }
+
+    @Override
+    public void finish(int docCount) throws IOException {
+      writer.finish(docCount);
+    }
+
+    @Override
+    public void files(Collection<String> files) throws IOException {
+      BytesBaseImpl.files(dir, id, files);
+    }
+  }
+
   public DocFieldProcessor(DocumentsWriter docWriter, DocFieldConsumer consumer) {
     this.docWriter = docWriter;
     this.consumer = consumer;
@@ -63,6 +270,14 @@
     fieldsWriter.flush(state);
     consumer.flush(childThreadsAndFields, state);
 
+    for(IndexValuesProcessor p : indexValues.values()) {
+      if (p != null) {
+        p.finish(state.numDocs);
+        p.files(state.flushedFiles);
+      }
+    }
+    indexValues.clear();
+
     // Important to save after asking consumer to flush so
     // consumer can alter the FieldInfo* if necessary.  EG,
     // FreqProxTermsWriter does this with
Index: src/java/org/apache/lucene/index/FieldInfo.java
===================================================================
--- src/java/org/apache/lucene/index/FieldInfo.java	(revision 900008)
+++ src/java/org/apache/lucene/index/FieldInfo.java	(working copy)
@@ -17,10 +17,13 @@
  * limitations under the License.
  */
 
+import org.apache.lucene.document.Field;
+
 final class FieldInfo {
   String name;
   boolean isIndexed;
   int number;
+  Field.Values indexValues;
 
   // true if term vector for this field should be stored
   boolean storeTermVector;
@@ -87,4 +90,18 @@
       }
     }
   }
+
+  void setIndexValues(Field.Values v) {
+    if (indexValues != null) {
+      if (indexValues != v) {
+        throw new IllegalArgumentException("indexValues is already set to " + indexValues + "; cannot change to " + v);
+      }
+    } else {
+      indexValues = v;
+    }
+  }
+
+  Field.Values getIndexValues() {
+    return indexValues;
+  }
 }
Index: src/java/org/apache/lucene/index/IndexReader.java
===================================================================
--- src/java/org/apache/lucene/index/IndexReader.java	(revision 900008)
+++ src/java/org/apache/lucene/index/IndexReader.java	(working copy)
@@ -21,6 +21,10 @@
 import org.apache.lucene.document.FieldSelector;
 import org.apache.lucene.search.Similarity;
 import org.apache.lucene.store.*;
+import org.apache.lucene.index.values.Ints;
+import org.apache.lucene.index.values.Floats;
+import org.apache.lucene.index.values.Bytes;
+import org.apache.lucene.index.values.Cache;
 
 import java.io.File;
 import java.io.FileOutputStream;
@@ -1202,4 +1206,23 @@
   public int getTermInfosIndexDivisor() {
     throw new UnsupportedOperationException("This reader does not support this method.");
   }
+
+  public Ints.Reader getIndexValuesInts(String field) {
+    throw new UnsupportedOperationException();
+  }
+
+  public Floats.Reader getIndexValuesFloats(String field) {
+    throw new UnsupportedOperationException();
+  }
+
+  public Bytes.Reader getIndexValuesBytes(String field) {
+    throw new UnsupportedOperationException();
+  }
+
+  private final Cache indexValuesCache = new Cache(this);
+
+  // nocommit -- don't expose readers if we have this?
+  public Cache getIndexValuesCache() {
+    return indexValuesCache;
+  }
 }
Index: src/java/org/apache/lucene/index/DocumentsWriter.java
===================================================================
--- src/java/org/apache/lucene/index/DocumentsWriter.java	(revision 900008)
+++ src/java/org/apache/lucene/index/DocumentsWriter.java	(working copy)
@@ -1196,7 +1196,7 @@
     
     /* Allocate another byte[] from the shared pool */
     @Override
-    byte[] getByteBlock(boolean trackAllocations) {
+    public byte[] getByteBlock(boolean trackAllocations) {
       synchronized(DocumentsWriter.this) {
         final int size = freeByteBlocks.size();
         final byte[] b;
@@ -1220,12 +1220,17 @@
 
     /* Return byte[]'s to the pool */
     @Override
-    void recycleByteBlocks(byte[][] blocks, int start, int end) {
+    public void recycleByteBlocks(byte[][] blocks, int start, int end) {
       synchronized(DocumentsWriter.this) {
         for(int i=start;i<end;i++)
           freeByteBlocks.add(blocks[i]);
       }
     }
+
+    @Override
+    public long ramBytesUsed() {
+      throw new UnsupportedOperationException();
+    }
   }
 
   /* Initial chunks size of the shared int[] blocks used to
Index: src/java/org/apache/lucene/index/IndexFileDeleter.java
===================================================================
--- src/java/org/apache/lucene/index/IndexFileDeleter.java	(revision 900008)
+++ src/java/org/apache/lucene/index/IndexFileDeleter.java	(working copy)
@@ -102,7 +102,8 @@
 
   /** Change to true to see details of reference counts when
    *  infoStream != null */
-  public static boolean VERBOSE_REF_COUNTS = false;
+  // nocommit -- false again
+  public static boolean VERBOSE_REF_COUNTS = true;
 
   void setInfoStream(PrintStream infoStream) {
     this.infoStream = infoStream;
Index: src/java/org/apache/lucene/store/IndexInput.java
===================================================================
--- src/java/org/apache/lucene/store/IndexInput.java	(revision 900008)
+++ src/java/org/apache/lucene/store/IndexInput.java	(working copy)
@@ -64,6 +64,13 @@
     readBytes(b, offset, len);
   }
 
+  /** Reads two bytes and returns a short.
+   * @see IndexOutput#writeInt(int)
+   */
+  public short readShort() throws IOException {
+    return (short) (((readByte() & 0xFF) <<  8) |  (readByte() & 0xFF));
+  }
+
   /** Reads four bytes and returns an int.
    * @see IndexOutput#writeInt(int)
    */
Index: src/java/org/apache/lucene/store/IndexOutput.java
===================================================================
--- src/java/org/apache/lucene/store/IndexOutput.java	(revision 900008)
+++ src/java/org/apache/lucene/store/IndexOutput.java	(working copy)
@@ -21,6 +21,7 @@
 import java.io.Closeable;
 import java.util.Map;
 import org.apache.lucene.util.UnicodeUtil;
+import org.apache.lucene.util.BytesRef;
 
 /** Abstract base class for output to a file in a Directory.  A random-access
  * output stream.  Used for all Lucene index output operations.
Index: src/java/org/apache/lucene/util/CodecUtil.java
===================================================================
--- src/java/org/apache/lucene/util/CodecUtil.java	(revision 0)
+++ src/java/org/apache/lucene/util/CodecUtil.java	(revision 0)
@@ -0,0 +1,72 @@
+package org.apache.lucene.util;
+
+/**
+ * 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.
+ */
+
+
+/**
+ * <p>NOTE: this class is meant only to be used internally
+ * by Lucene; it's only public so it can be shared across
+ * packages.  This means the API is freely subject to
+ * change, and, the class could be removed entirely, in any
+ * Lucene release.  Use directly at your own risk!
+ */
+
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.index.CorruptIndexException;
+
+import java.io.IOException;
+
+public final class CodecUtil {
+  private final static int CODEC_MAGIC = 0x3fd76c17;
+
+  public static void writeHeader(IndexOutput out, String codec, int version)
+    throws IOException {
+    final long start = out.getFilePointer();
+    out.writeInt(CODEC_MAGIC);
+    out.writeString(codec);
+    out.writeInt(version);
+
+    // We require this so we can easily pre-compute header length
+    if (out.getFilePointer()-start != codec.length()+9) {
+      throw new IllegalArgumentException("codec must be simple ASCII, less than 128 characters in length [got " + codec + "]");
+    }
+  }
+
+  public static int headerLength(String codec) {
+    return 9+codec.length();
+  }
+
+  public static int checkHeader(IndexInput in, String codec, int maxVersion)
+    throws IOException {
+    final int actualHeader = in.readInt();
+    if (actualHeader != CODEC_MAGIC) {
+      throw new CorruptIndexException("codec header mismatch: actual header=" + actualHeader + " vs expected header=" + CODEC_MAGIC);
+    }
+    final String actualCodec = in.readString();
+    if (!actualCodec.equals(codec)) {
+      throw new CorruptIndexException("codec mismatch: actual codec=" + actualCodec + " vs expected codec=" + codec);
+    }
+    final int actualVersion = in.readInt();
+    if (actualVersion > maxVersion) {
+      throw new CorruptIndexException("version " + actualVersion + " is too new (expected <= version " + maxVersion + ")");
+    }
+
+    return actualVersion;
+  }
+}

Property changes on: src/java/org/apache/lucene/util/CodecUtil.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/util/PackedInts.java
===================================================================
--- src/java/org/apache/lucene/util/PackedInts.java	(revision 0)
+++ src/java/org/apache/lucene/util/PackedInts.java	(revision 0)
@@ -0,0 +1,464 @@
+package org.apache.lucene.util;
+
+/**
+ * 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.
+ */
+
+// nocommit -- rename to UnsignedPackedInts?  or pull
+// minValue down
+
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.IndexInput;
+
+import java.io.IOException;
+
+/**
+ * Simplistic compression for array of long values, where
+ * each value is >= 0 and <= a specified maximum value.  The
+ * values are stored as packed ints, with each value
+ * consuming a fixed number of bits.
+ *
+ * <p>NOTE: this class is meant only to be used internally
+ * by Lucene; it's only public so it can be shared across
+ * packages.  This means the API is freely subject to
+ * change, and, the class could be removed entirely, in any
+ * Lucene release.  Use directly at your own risk!
+ */
+
+// nocommit
+//   - do we need int/long variants (for perf)?  or long
+//     only suffices?
+//   - what native type is best perf?  long/int/short/byte?
+
+public class PackedInts {
+
+  private final static String CODEC_NAME = "PackedInts";
+  private final static int VERSION_START = 0;
+  private final static int VERSION_CURRENT = 0;
+
+  private static int size(int bitsPerValue, int valueCount) {
+    final long totBitCount = (long) valueCount * bitsPerValue;
+    return (int) (totBitCount/64 + ((totBitCount % 64 == 0 ) ? 0:1));
+  }
+
+  /** Returns how many bits are required to hold values up
+   *  to and including maxValue */
+  public static int bitsRequired(long maxValue) {
+    return (int) Math.ceil(Math.log(1+maxValue)/Math.log(2.0));
+  }
+
+  public static int getNextFixedSize(int bits) {
+    if (bits <= 8) {
+      return 8;
+    } else if (bits <= 16) {
+      return 16;
+    } else if (bits <= 32) {
+      return 32;
+    } else {
+      return 64;
+    }
+  }
+
+  /** Write-once */
+  public static abstract class Writer {
+    protected final IndexOutput out;
+    protected final int bitsPerValue;
+    protected final long maxValue;
+    protected final int valueCount;
+
+    protected Writer(IndexOutput out, long maxValue, int valueCount, int bitsPerValue) throws IOException {
+      assert bitsPerValue <= 64;
+
+      this.out = out;
+      this.maxValue = maxValue;
+      this.valueCount = valueCount;
+      this.bitsPerValue = bitsPerValue;
+
+      CodecUtil.writeHeader(out, CODEC_NAME, VERSION_START);
+      out.writeVInt(bitsPerValue);
+      out.writeVInt(valueCount);
+      out.writeVLong(maxValue);
+    }
+
+    public abstract void add(long v) throws IOException;
+    public abstract void finish() throws IOException;
+  }
+
+  public static Writer getWriter(IndexOutput out, long maxValue, int valueCount, int forceBits) throws IOException {
+    final int bitsPerValue;
+    if (forceBits != -1) {
+      bitsPerValue = forceBits;
+    } else {
+      if (maxValue == 0) {
+        maxValue = 1;
+      }
+      bitsPerValue = bitsRequired(maxValue);
+    }
+    assert bitsPerValue <= 64;
+    return new PackedWriter(out, maxValue, valueCount, bitsPerValue);
+  }
+
+  // Packs high order byte first, to match
+  // IndexOutput.writeInt/Long/Short byte order
+
+  // nocommit: bulk add(int[]) api?
+  final static class PackedWriter extends Writer {
+    private long pending;
+    private int pendingBitPos;
+
+    // masks[n-1] masks for bottom n bits
+    private final long[] masks;
+
+    // nocommit -- allow minValue too?  ie not just minValue==0
+    public PackedWriter(IndexOutput out, long maxValue, int valueCount, int bitsPerValue)
+      throws IOException {
+
+      super(out, maxValue, valueCount, bitsPerValue);
+
+      pendingBitPos = 64;
+      masks = new long[bitsPerValue-1];
+
+      int v = 1;
+      for(int i=0;i<bitsPerValue-1;i++) {
+        v *= 2;
+        masks[i] = v-1;
+      }
+    }
+
+    /** Do not call this after finish */
+    public void add(long v) throws IOException {
+      assert v <= maxValue: "v=" + v+ " maxValue=" + maxValue;
+      assert v >= 0;
+
+      // TODO
+      if (pendingBitPos >= bitsPerValue) {
+        // not split
+
+        // write-once, so we can |= w/o first masking to 0s
+        pending |= v << (pendingBitPos - bitsPerValue);
+        if (pendingBitPos == bitsPerValue) {
+          // flush
+          out.writeLong(pending);
+          pending = 0;
+          pendingBitPos = 64;
+        } else {
+          pendingBitPos -= bitsPerValue;
+        }
+
+      } else {
+        // split
+
+        // write top pendingBitPos bits of value into bottom bits of pending
+        pending |= (v >> (bitsPerValue - pendingBitPos)) & masks[pendingBitPos-1];
+
+        // flush
+        out.writeLong(pending);
+
+        // write bottom (bitsPerValue - pendingBitPos) bits of value into top bits of pending
+        pendingBitPos = 64 - bitsPerValue + pendingBitPos;
+        pending = (v << pendingBitPos);
+      }
+    }
+
+    public void finish() throws IOException {
+      if (pendingBitPos != 64) {
+        out.writeLong(pending);
+      }
+    }
+  }
+
+  public static abstract class Reader implements ConsumesRAM {
+    private final long maxValue;
+
+    protected Reader(long maxValue) {
+      this.maxValue = maxValue;
+    }
+
+    public long getMaxValue() {
+      return maxValue;
+    }
+
+    abstract public long get(int index);
+
+    abstract public long ramBytesUsed();
+  }
+
+  static final class ByteReader extends Reader {
+    private final byte[] data;
+    private final int valueCount;
+
+    public ByteReader(IndexInput in, int valueCount, long maxValue) throws IOException {
+      super(maxValue);
+      data = new byte[valueCount];
+      this.valueCount = valueCount;
+      for(int i=0;i<valueCount;i++) {
+        data[i] = in.readByte();
+      }
+      final int mod = valueCount % 8;
+      if (mod != 0) {
+        final int pad = 8-mod;
+        // round out long
+        for(int i=0;i<pad;i++) {
+          in.readByte();
+        }
+      }
+    }
+
+    public long get(int index) {
+      return data[index]&0xffL;
+    }
+
+    public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + valueCount;
+    }
+  }
+
+  static final class ShortReader extends Reader {
+    private final short[] data;
+    private final int valueCount;
+
+    public ShortReader(IndexInput in, int valueCount, long maxValue) throws IOException {
+      super(maxValue);
+      data = new short[valueCount];
+      this.valueCount = valueCount;
+      for(int i=0;i<valueCount;i++) {
+        data[i] = in.readShort();
+      }
+      final int mod = valueCount % 4;
+      if (mod != 0) {
+        final int pad = 4-mod;
+        // round out long
+        for(int i=0;i<pad;i++) {
+          in.readShort();
+        }
+      }
+    }
+
+    public long get(int index) {
+      return data[index] & 0xffffL;
+    }
+
+    public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + valueCount * RamUsageEstimator.NUM_BYTES_SHORT;
+    }
+  }
+
+  static final class IntReader extends Reader {
+    private final int[] data;
+    private final int valueCount;
+
+    public IntReader(IndexInput in, int valueCount, long maxValue) throws IOException {
+      super(maxValue);
+      data = new int[valueCount];
+      this.valueCount = valueCount;
+      for(int i=0;i<valueCount;i++) {
+        data[i] = in.readInt();
+      }
+
+      final int mod = valueCount % 2;
+      if (mod != 0) {
+        // round out long
+        in.readInt();
+      }
+    }
+
+    public long get(int index) {
+      return data[index]& 0xffffffffL;
+    }
+
+    public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + valueCount * RamUsageEstimator.NUM_BYTES_INT;
+    }
+  }
+
+  static final class LongReader extends Reader {
+    private final long[] data;
+    private final int valueCount;
+
+    public LongReader(IndexInput in, int valueCount, long maxValue) throws IOException {
+      super(maxValue);
+      data = new long[valueCount];
+      this.valueCount = valueCount;
+      for(int i=0;i<valueCount;i++) {
+        data[i] = in.readLong();
+      }
+    }
+
+    public long get(int index) {
+      return data[index];
+    }
+
+    public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + valueCount * RamUsageEstimator.NUM_BYTES_LONG;
+    }
+  }
+
+  public static Reader getReader(IndexInput in) throws IOException {
+    CodecUtil.checkHeader(in, CODEC_NAME, VERSION_START);
+    final int bitsPerValue = in.readVInt();
+    final int valueCount = in.readVInt();
+    final long maxValue = in.readVLong();
+    // TODO an mmap reader as well?
+
+    // dedicated fixed array based readers for bit sizes matching java native types
+    switch(bitsPerValue) {
+    case 8:
+      return new ByteReader(in, valueCount, maxValue);
+    case 16:
+      return new ShortReader(in, valueCount, maxValue);
+    case 32:
+      return new IntReader(in, valueCount, maxValue);
+    case 64:
+      return new LongReader(in, valueCount, maxValue);
+    }
+
+
+    // else, read all data into long[] and instantiate
+    // dedicated bit packed reader
+    final int size = size(bitsPerValue, valueCount);
+    final long[] data = new long[size];
+    // TODO: switch to ByteBuffer
+    for(int i=0;i<size;i++) {
+      data[i] = in.readLong();
+    }
+
+    switch(bitsPerValue) {
+    case 1:
+      return new GenBitReaders.Reader1(data, maxValue);
+    case 2:
+      return new GenBitReaders.Reader2(data, maxValue);
+    case 3:
+      return new GenBitReaders.Reader3(data, maxValue);
+    case 4:
+      return new GenBitReaders.Reader4(data, maxValue);
+    case 5:
+      return new GenBitReaders.Reader5(data, maxValue);
+    case 6:
+      return new GenBitReaders.Reader6(data, maxValue);
+    case 7:
+      return new GenBitReaders.Reader7(data, maxValue);
+    case 9:
+      return new GenBitReaders.Reader9(data, maxValue);
+    case 10:
+      return new GenBitReaders.Reader10(data, maxValue);
+    case 11:
+      return new GenBitReaders.Reader11(data, maxValue);
+    case 12:
+      return new GenBitReaders.Reader12(data, maxValue);
+    case 13:
+      return new GenBitReaders.Reader13(data, maxValue);
+    case 14:
+      return new GenBitReaders.Reader14(data, maxValue);
+    case 15:
+      return new GenBitReaders.Reader15(data, maxValue);
+    case 17:
+      return new GenBitReaders.Reader17(data, maxValue);
+    case 18:
+      return new GenBitReaders.Reader18(data, maxValue);
+    case 19:
+      return new GenBitReaders.Reader19(data, maxValue);
+    case 20:
+      return new GenBitReaders.Reader20(data, maxValue);
+    case 21:
+      return new GenBitReaders.Reader21(data, maxValue);
+    case 22:
+      return new GenBitReaders.Reader22(data, maxValue);
+    case 23:
+      return new GenBitReaders.Reader23(data, maxValue);
+    case 24:
+      return new GenBitReaders.Reader24(data, maxValue);
+    case 25:
+      return new GenBitReaders.Reader25(data, maxValue);
+    case 26:
+      return new GenBitReaders.Reader26(data, maxValue);
+    case 27:
+      return new GenBitReaders.Reader27(data, maxValue);
+    case 28:
+      return new GenBitReaders.Reader28(data, maxValue);
+    case 29:
+      return new GenBitReaders.Reader29(data, maxValue);
+    case 30:
+      return new GenBitReaders.Reader30(data, maxValue);
+    case 31:
+      return new GenBitReaders.Reader31(data, maxValue);
+    case 33:
+      return new GenBitReaders.Reader33(data, maxValue);
+    case 34:
+      return new GenBitReaders.Reader34(data, maxValue);
+    case 35:
+      return new GenBitReaders.Reader35(data, maxValue);
+    case 36:
+      return new GenBitReaders.Reader36(data, maxValue);
+    case 37:
+      return new GenBitReaders.Reader37(data, maxValue);
+    case 38:
+      return new GenBitReaders.Reader38(data, maxValue);
+    case 39:
+      return new GenBitReaders.Reader39(data, maxValue);
+    case 40:
+      return new GenBitReaders.Reader40(data, maxValue);
+    case 41:
+      return new GenBitReaders.Reader41(data, maxValue);
+    case 42:
+      return new GenBitReaders.Reader42(data, maxValue);
+    case 43:
+      return new GenBitReaders.Reader43(data, maxValue);
+    case 44:
+      return new GenBitReaders.Reader44(data, maxValue);
+    case 45:
+      return new GenBitReaders.Reader45(data, maxValue);
+    case 46:
+      return new GenBitReaders.Reader46(data, maxValue);
+    case 47:
+      return new GenBitReaders.Reader47(data, maxValue);
+    case 48:
+      return new GenBitReaders.Reader48(data, maxValue);
+    case 49:
+      return new GenBitReaders.Reader49(data, maxValue);
+    case 50:
+      return new GenBitReaders.Reader50(data, maxValue);
+    case 51:
+      return new GenBitReaders.Reader51(data, maxValue);
+    case 52:
+      return new GenBitReaders.Reader52(data, maxValue);
+    case 53:
+      return new GenBitReaders.Reader53(data, maxValue);
+    case 54:
+      return new GenBitReaders.Reader54(data, maxValue);
+    case 55:
+      return new GenBitReaders.Reader55(data, maxValue);
+    case 56:
+      return new GenBitReaders.Reader56(data, maxValue);
+    case 57:
+      return new GenBitReaders.Reader57(data, maxValue);
+    case 58:
+      return new GenBitReaders.Reader58(data, maxValue);
+    case 59:
+      return new GenBitReaders.Reader59(data, maxValue);
+    case 60:
+      return new GenBitReaders.Reader60(data, maxValue);
+    case 61:
+      return new GenBitReaders.Reader61(data, maxValue);
+    case 62:
+      return new GenBitReaders.Reader62(data, maxValue);
+    case 63:
+      return new GenBitReaders.Reader63(data, maxValue);
+    }
+
+    // unreachable, but compiler disagrees
+    return null;
+  }
+}

Property changes on: src/java/org/apache/lucene/util/PackedInts.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/util/BytesHash.java
===================================================================
--- src/java/org/apache/lucene/util/BytesHash.java	(revision 0)
+++ src/java/org/apache/lucene/util/BytesHash.java	(revision 0)
@@ -0,0 +1,374 @@
+package org.apache.lucene.util;
+
+/**
+ * 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.
+ */
+
+// nocommit -- move to util?
+import org.apache.lucene.index.ByteBlockPool;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+/**
+ * Hash's BytesRefs.  BytesRef must be no longer than XXX in
+ * length.
+ *
+ * <p>NOTE: this class is meant only to be used internally
+ * by Lucene; it's only public so it can be shared across
+ * packages.  This means the API is freely subject to
+ * change, and, the class could be removed entirely, in any
+ * Lucene release.  Use directly at your own risk!
+ */
+
+// nocommit -- reuse Entry instances?
+public abstract class BytesHash<T extends BytesHash.Entry> {
+
+  // nocommit -- factor properly so the byte pool uses this
+  // NOT DW's
+  public final static int BYTES_BLOCK_SHIFT = 15;
+  public final static int BYTES_BLOCK_SIZE = 1 << BYTES_BLOCK_SHIFT;
+  public final static int BYTES_BLOCK_MASK = BYTES_BLOCK_SIZE - 1;
+
+  // nocommit -- reuse?
+  private static class ByteBlockAllocator extends ByteBlockPool.Allocator {
+    int blockUsedCount;
+
+    @Override
+    public byte[] getByteBlock(boolean trackAllocations) {
+      blockUsedCount++;
+      return new byte[BYTES_BLOCK_SIZE];
+    }
+
+    @Override
+    public void recycleByteBlocks(byte[][] blocks, int start, int end) {
+      blockUsedCount -= end-start;
+    }
+
+    @Override
+    public long ramBytesUsed() {
+      return blockUsedCount * BYTES_BLOCK_SIZE;
+    }
+  }
+
+  public static class Entry {
+    public int bytesStart;
+  }
+
+  private final Class<T> cl;
+  public final ByteBlockPool pool;
+  private int hashSize = 4;
+  private int hashHalfSize = hashSize/2;
+  private int hashMask = hashSize-1;
+  private int count;
+  private int lastCount = -1;
+  private final ByteBlockAllocator allocator;
+  private T[] hash;
+
+  @SuppressWarnings("unchecked")
+  public BytesHash(Class<T> cl) {
+    this.cl = cl;
+    allocator = new ByteBlockAllocator();
+    pool = new ByteBlockPool(allocator, false);
+    hash = (T[]) Array.newInstance(cl, hashSize);
+  }
+
+  private void compactPostings() {
+  }
+
+  public int size() {
+    return count;
+  }
+
+  public BytesRef getBytes(T e) {
+    return deref(e.bytesStart, scratch1);
+  }
+
+  /** Destructive operation -- returns all Entry instances,
+   *  in arbitrary order */
+  public T[] compact() {
+    int upto = 0;
+    for(int i=0;i<hashSize;i++) {
+      if (hash[i] != null) {
+        if (upto < i) {
+          hash[upto] = hash[i];
+          hash[i] = null;
+        }
+        upto++;
+      }
+    }
+
+    assert upto == count;
+    lastCount = count;
+
+    return hash;
+  }
+
+  /** Destructive operation -- returns all Entry instances sorted */
+  public T[] sort(BytesRef.Comparator comp) {
+    compact();
+    quickSort(comp, hash, 0, count-1);
+    return hash;
+  }
+
+  void quickSort(BytesRef.Comparator comp, T[] entries, int lo, int hi) {
+    if (lo >= hi)
+      return;
+    else if (hi == 1+lo) {
+      if (compare(comp, entries[lo], entries[hi]) > 0) {
+        final T tmp = entries[lo];
+        entries[lo] = entries[hi];
+        entries[hi] = tmp;
+      }
+      return;
+    }
+
+    int mid = (lo + hi) >>> 1;
+
+    if (compare(comp, entries[lo], entries[mid]) > 0) {
+      T tmp = entries[lo];
+      entries[lo] = entries[mid];
+      entries[mid] = tmp;
+    }
+
+    if (compare(comp, entries[mid], entries[hi]) > 0) {
+      T tmp = entries[mid];
+      entries[mid] = entries[hi];
+      entries[hi] = tmp;
+
+      if (compare(comp, entries[lo], entries[mid]) > 0) {
+        T tmp2 = entries[lo];
+        entries[lo] = entries[mid];
+        entries[mid] = tmp2;
+      }
+    }
+
+    int left = lo + 1;
+    int right = hi - 1;
+
+    if (left >= right)
+      return;
+
+    T partition = entries[mid];
+
+    for (; ;) {
+      while (compare(comp, entries[right], partition) > 0)
+        --right;
+
+      while (left < right && compare(comp, entries[left], partition) <= 0)
+        ++left;
+
+      if (left < right) {
+        T tmp = entries[left];
+        entries[left] = entries[right];
+        entries[right] = tmp;
+        --right;
+      } else {
+        break;
+      }
+    }
+
+    quickSort(comp, entries, lo, left);
+    quickSort(comp, entries, left + 1, hi);
+  }
+
+  private final BytesRef scratch1 = new BytesRef();
+  private final BytesRef scratch2 = new BytesRef();
+
+  private final BytesRef deref(int bytesStart, BytesRef b) {
+    b.bytes = pool.buffers[bytesStart >> BYTES_BLOCK_SHIFT];
+    int pos = bytesStart & BYTES_BLOCK_MASK;
+
+    if ((b.bytes[pos] & 0x80) == 0) {
+      // length is 1 byte
+      b.length = b.bytes[pos];
+      pos += 1;
+    } else {
+      // length is 2 bytes
+      b.length = (b.bytes[pos]&0x7f) + ((b.bytes[pos+1]&0xff)<<7);
+      pos += 2;
+    }
+    b.offset = pos;
+    return b;
+  }
+
+  private boolean equals(T e, BytesRef b) {
+    return deref(e.bytesStart, scratch1).bytesEquals(b);
+  }
+
+  private int compare(BytesRef.Comparator comp, T e1, T e2) {
+    return comp.compare(deref(e1.bytesStart, scratch1),
+                        deref(e2.bytesStart, scratch2));
+  }
+
+  @SuppressWarnings("unchecked")
+  private boolean shrink(int targetSize) {
+
+    // Cannot use ArrayUtil.shrink because we require power
+    // of 2:
+    int newSize = hashSize;
+    while(newSize >= 8 && newSize/4 > targetSize) {
+      newSize /= 2;
+    }
+
+    if (newSize != hashSize) {
+      hashSize = newSize;
+      hash = (T[]) Array.newInstance(cl, hashSize);
+      hashHalfSize = newSize/2;
+      hashMask = newSize-1;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public void clear() {
+    lastCount = count;
+    count = 0;
+    if (lastCount != -1) {
+      if (shrink(lastCount)) {
+        // shrink clears the hash entries
+        return;
+      }
+    }
+    Arrays.fill(hash, null);
+  }
+
+  public T add(BytesRef bytes) {
+    int code = 0;
+    final int end = bytes.offset + bytes.length;
+    for(int i=bytes.offset;i<end;i++) {
+      code = 31*code + bytes.bytes[i];
+    }
+
+    int hashPos = code & hashMask;
+    T e = hash[hashPos];
+
+    if (e != null && !equals(e, bytes)) {
+      // Conflict: keep searching different locations in
+      // the hash table.
+      final int inc = ((code>>8)+code)|1;
+      do {
+        code += inc;
+        hashPos = code & hashMask;
+        e = hash[hashPos];
+      } while (e != null && !equals(e, bytes));
+    }
+
+    if (e == null) {
+      // new entry
+
+      final int len2 = 2+bytes.length;
+      if (len2 + pool.byteUpto > BYTES_BLOCK_SIZE) {
+        if (len2 > BYTES_BLOCK_SIZE) {
+          throw new IllegalArgumentException("bytes can be at most " + (BYTES_BLOCK_SIZE-2) + " in length; got " + bytes.length);
+        }
+        pool.nextBuffer();
+      }
+
+      e = newEntry();
+
+      final byte[] buffer = pool.buffer;
+      final int bufferUpto = pool.byteUpto;
+      e.bytesStart = bufferUpto + pool.byteOffset;
+
+      // We first encode the length, followed by the
+      // bytes.  Length is encoded as vInt, but will consume
+      // 1 or 2 bytes at most (we reject too-long terms,
+      // above).
+      if (bytes.length < 128) {
+        // 1 byte to store length
+        buffer[bufferUpto] = (byte) bytes.length;
+        pool.byteUpto += bytes.length + 1;
+        System.arraycopy(bytes.bytes, bytes.offset, buffer, bufferUpto+1, bytes.length);
+      } else {
+        // 2 byte to store length
+        buffer[bufferUpto] = (byte) (0x80 | (bytes.length & 0x7f));
+        buffer[bufferUpto+1] = (byte) ((bytes.length>>7) & 0xff);
+        pool.byteUpto += bytes.length + 2;
+        System.arraycopy(bytes.bytes, bytes.offset, buffer, bufferUpto+2, bytes.length);
+      }
+      assert hash[hashPos] == null;
+      hash[hashPos] = e;
+      count++;
+
+      if (count == hashHalfSize) {
+        rehash(2*hashSize);
+      }
+    }
+    return e;
+  }
+
+  /** Called when postings hash is too small (> 50%
+   *  occupied) or too large (< 20% occupied). */
+  void rehash(final int newSize) {
+
+    final int newMask = newSize-1;
+
+    @SuppressWarnings("unchecked")
+    T[] newHash = (T[]) Array.newInstance(cl, newSize);
+    for(int i=0;i<hashSize;i++) {
+      T e0 = hash[i];
+      if (e0 != null) {
+        int code;
+        final int start = e0.bytesStart & BYTES_BLOCK_MASK;
+        final byte[] bytes = pool.buffers[e0.bytesStart >> BYTES_BLOCK_SHIFT];
+        code = 0;
+
+        final int len;
+        int pos;
+        if ((bytes[start] & 0x80) == 0) {
+          // length is 1 byte
+          len = bytes[start];
+          pos = start+1;
+        } else {
+          len = (bytes[start]&0x7f) + ((bytes[start+1]&0xff)<<7);
+          pos = start+2;
+        }
+
+        final int endPos = pos+len;
+        while(pos < endPos) {
+          code = (code*31) + bytes[pos++];
+        }
+
+        int hashPos = code & newMask;
+        assert hashPos >= 0;
+        if (newHash[hashPos] != null) {
+          final int inc = ((code>>8)+code)|1;
+          do {
+            code += inc;
+            hashPos = code & newMask;
+          } while (newHash[hashPos] != null);
+        }
+        newHash[hashPos] = e0;
+      }
+    }
+
+    hashMask = newMask;
+    hash = newHash;
+    hashSize = newSize;
+    hashHalfSize = newSize >> 1;
+  }
+
+  protected abstract T newEntry();
+
+  public long ramBytesUsed() {
+    return allocator.ramBytesUsed() + RamUsageEstimator.NUM_BYTES_OBJ_REF * hashSize + count * bytesPerEntry();
+  }
+
+  protected long bytesPerEntry() {
+    return RamUsageEstimator.NUM_BYTES_OBJ_HEADER + RamUsageEstimator.NUM_BYTES_INT;
+  }
+}

Property changes on: src/java/org/apache/lucene/util/BytesHash.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/util/GenBitReaders.java
===================================================================
--- src/java/org/apache/lucene/util/GenBitReaders.java	(revision 0)
+++ src/java/org/apache/lucene/util/GenBitReaders.java	(revision 0)
@@ -0,0 +1,6305 @@
+package org.apache.lucene.util;
+
+/**
+ * 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.
+ */
+
+// Autogenerated by gen.py DO NOT EDIT!
+class GenBitReaders {
+  static abstract class Base extends PackedInts.Reader {
+    protected final long[] data;
+    protected Base(long[] data, long maxValue) {
+      super(maxValue);
+      this.data = data;
+    }
+    public long ramBytesUsed() {
+      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + data.length * RamUsageEstimator.NUM_BYTES_LONG;
+    }
+  }
+
+  final static class Reader1 extends Base {
+    public Reader1(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*1;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 63;
+      case 1:
+        return (data[idx] >>> 62) & 1L;
+      case 2:
+        return (data[idx] >>> 61) & 1L;
+      case 3:
+        return (data[idx] >>> 60) & 1L;
+      case 4:
+        return (data[idx] >>> 59) & 1L;
+      case 5:
+        return (data[idx] >>> 58) & 1L;
+      case 6:
+        return (data[idx] >>> 57) & 1L;
+      case 7:
+        return (data[idx] >>> 56) & 1L;
+      case 8:
+        return (data[idx] >>> 55) & 1L;
+      case 9:
+        return (data[idx] >>> 54) & 1L;
+      case 10:
+        return (data[idx] >>> 53) & 1L;
+      case 11:
+        return (data[idx] >>> 52) & 1L;
+      case 12:
+        return (data[idx] >>> 51) & 1L;
+      case 13:
+        return (data[idx] >>> 50) & 1L;
+      case 14:
+        return (data[idx] >>> 49) & 1L;
+      case 15:
+        return (data[idx] >>> 48) & 1L;
+      case 16:
+        return (data[idx] >>> 47) & 1L;
+      case 17:
+        return (data[idx] >>> 46) & 1L;
+      case 18:
+        return (data[idx] >>> 45) & 1L;
+      case 19:
+        return (data[idx] >>> 44) & 1L;
+      case 20:
+        return (data[idx] >>> 43) & 1L;
+      case 21:
+        return (data[idx] >>> 42) & 1L;
+      case 22:
+        return (data[idx] >>> 41) & 1L;
+      case 23:
+        return (data[idx] >>> 40) & 1L;
+      case 24:
+        return (data[idx] >>> 39) & 1L;
+      case 25:
+        return (data[idx] >>> 38) & 1L;
+      case 26:
+        return (data[idx] >>> 37) & 1L;
+      case 27:
+        return (data[idx] >>> 36) & 1L;
+      case 28:
+        return (data[idx] >>> 35) & 1L;
+      case 29:
+        return (data[idx] >>> 34) & 1L;
+      case 30:
+        return (data[idx] >>> 33) & 1L;
+      case 31:
+        return (data[idx] >>> 32) & 1L;
+      case 32:
+        return (data[idx] >>> 31) & 1L;
+      case 33:
+        return (data[idx] >>> 30) & 1L;
+      case 34:
+        return (data[idx] >>> 29) & 1L;
+      case 35:
+        return (data[idx] >>> 28) & 1L;
+      case 36:
+        return (data[idx] >>> 27) & 1L;
+      case 37:
+        return (data[idx] >>> 26) & 1L;
+      case 38:
+        return (data[idx] >>> 25) & 1L;
+      case 39:
+        return (data[idx] >>> 24) & 1L;
+      case 40:
+        return (data[idx] >>> 23) & 1L;
+      case 41:
+        return (data[idx] >>> 22) & 1L;
+      case 42:
+        return (data[idx] >>> 21) & 1L;
+      case 43:
+        return (data[idx] >>> 20) & 1L;
+      case 44:
+        return (data[idx] >>> 19) & 1L;
+      case 45:
+        return (data[idx] >>> 18) & 1L;
+      case 46:
+        return (data[idx] >>> 17) & 1L;
+      case 47:
+        return (data[idx] >>> 16) & 1L;
+      case 48:
+        return (data[idx] >>> 15) & 1L;
+      case 49:
+        return (data[idx] >>> 14) & 1L;
+      case 50:
+        return (data[idx] >>> 13) & 1L;
+      case 51:
+        return (data[idx] >>> 12) & 1L;
+      case 52:
+        return (data[idx] >>> 11) & 1L;
+      case 53:
+        return (data[idx] >>> 10) & 1L;
+      case 54:
+        return (data[idx] >>> 9) & 1L;
+      case 55:
+        return (data[idx] >>> 8) & 1L;
+      case 56:
+        return (data[idx] >>> 7) & 1L;
+      case 57:
+        return (data[idx] >>> 6) & 1L;
+      case 58:
+        return (data[idx] >>> 5) & 1L;
+      case 59:
+        return (data[idx] >>> 4) & 1L;
+      case 60:
+        return (data[idx] >>> 3) & 1L;
+      case 61:
+        return (data[idx] >>> 2) & 1L;
+      case 62:
+        return (data[idx] >>> 1) & 1L;
+      case 63:
+        return data[idx] & 1L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader2 extends Base {
+    public Reader2(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*2;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 62;
+      case 2:
+        return (data[idx] >>> 60) & 3L;
+      case 4:
+        return (data[idx] >>> 58) & 3L;
+      case 6:
+        return (data[idx] >>> 56) & 3L;
+      case 8:
+        return (data[idx] >>> 54) & 3L;
+      case 10:
+        return (data[idx] >>> 52) & 3L;
+      case 12:
+        return (data[idx] >>> 50) & 3L;
+      case 14:
+        return (data[idx] >>> 48) & 3L;
+      case 16:
+        return (data[idx] >>> 46) & 3L;
+      case 18:
+        return (data[idx] >>> 44) & 3L;
+      case 20:
+        return (data[idx] >>> 42) & 3L;
+      case 22:
+        return (data[idx] >>> 40) & 3L;
+      case 24:
+        return (data[idx] >>> 38) & 3L;
+      case 26:
+        return (data[idx] >>> 36) & 3L;
+      case 28:
+        return (data[idx] >>> 34) & 3L;
+      case 30:
+        return (data[idx] >>> 32) & 3L;
+      case 32:
+        return (data[idx] >>> 30) & 3L;
+      case 34:
+        return (data[idx] >>> 28) & 3L;
+      case 36:
+        return (data[idx] >>> 26) & 3L;
+      case 38:
+        return (data[idx] >>> 24) & 3L;
+      case 40:
+        return (data[idx] >>> 22) & 3L;
+      case 42:
+        return (data[idx] >>> 20) & 3L;
+      case 44:
+        return (data[idx] >>> 18) & 3L;
+      case 46:
+        return (data[idx] >>> 16) & 3L;
+      case 48:
+        return (data[idx] >>> 14) & 3L;
+      case 50:
+        return (data[idx] >>> 12) & 3L;
+      case 52:
+        return (data[idx] >>> 10) & 3L;
+      case 54:
+        return (data[idx] >>> 8) & 3L;
+      case 56:
+        return (data[idx] >>> 6) & 3L;
+      case 58:
+        return (data[idx] >>> 4) & 3L;
+      case 60:
+        return (data[idx] >>> 2) & 3L;
+      case 62:
+        return data[idx] & 3L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader3 extends Base {
+    public Reader3(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*3;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 61;
+      case 3:
+        return (data[idx] >>> 58) & 7L;
+      case 6:
+        return (data[idx] >>> 55) & 7L;
+      case 9:
+        return (data[idx] >>> 52) & 7L;
+      case 12:
+        return (data[idx] >>> 49) & 7L;
+      case 15:
+        return (data[idx] >>> 46) & 7L;
+      case 18:
+        return (data[idx] >>> 43) & 7L;
+      case 21:
+        return (data[idx] >>> 40) & 7L;
+      case 24:
+        return (data[idx] >>> 37) & 7L;
+      case 27:
+        return (data[idx] >>> 34) & 7L;
+      case 30:
+        return (data[idx] >>> 31) & 7L;
+      case 33:
+        return (data[idx] >>> 28) & 7L;
+      case 36:
+        return (data[idx] >>> 25) & 7L;
+      case 39:
+        return (data[idx] >>> 22) & 7L;
+      case 42:
+        return (data[idx] >>> 19) & 7L;
+      case 45:
+        return (data[idx] >>> 16) & 7L;
+      case 48:
+        return (data[idx] >>> 13) & 7L;
+      case 51:
+        return (data[idx] >>> 10) & 7L;
+      case 54:
+        return (data[idx] >>> 7) & 7L;
+      case 57:
+        return (data[idx] >>> 4) & 7L;
+      case 60:
+        return (data[idx] >>> 1) & 7L;
+      case 63:
+        return ((data[idx] & 1L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 59) & 7L;
+      case 5:
+        return (data[idx] >>> 56) & 7L;
+      case 8:
+        return (data[idx] >>> 53) & 7L;
+      case 11:
+        return (data[idx] >>> 50) & 7L;
+      case 14:
+        return (data[idx] >>> 47) & 7L;
+      case 17:
+        return (data[idx] >>> 44) & 7L;
+      case 20:
+        return (data[idx] >>> 41) & 7L;
+      case 23:
+        return (data[idx] >>> 38) & 7L;
+      case 26:
+        return (data[idx] >>> 35) & 7L;
+      case 29:
+        return (data[idx] >>> 32) & 7L;
+      case 32:
+        return (data[idx] >>> 29) & 7L;
+      case 35:
+        return (data[idx] >>> 26) & 7L;
+      case 38:
+        return (data[idx] >>> 23) & 7L;
+      case 41:
+        return (data[idx] >>> 20) & 7L;
+      case 44:
+        return (data[idx] >>> 17) & 7L;
+      case 47:
+        return (data[idx] >>> 14) & 7L;
+      case 50:
+        return (data[idx] >>> 11) & 7L;
+      case 53:
+        return (data[idx] >>> 8) & 7L;
+      case 56:
+        return (data[idx] >>> 5) & 7L;
+      case 59:
+        return (data[idx] >>> 2) & 7L;
+      case 62:
+        return ((data[idx] & 3L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 60) & 7L;
+      case 4:
+        return (data[idx] >>> 57) & 7L;
+      case 7:
+        return (data[idx] >>> 54) & 7L;
+      case 10:
+        return (data[idx] >>> 51) & 7L;
+      case 13:
+        return (data[idx] >>> 48) & 7L;
+      case 16:
+        return (data[idx] >>> 45) & 7L;
+      case 19:
+        return (data[idx] >>> 42) & 7L;
+      case 22:
+        return (data[idx] >>> 39) & 7L;
+      case 25:
+        return (data[idx] >>> 36) & 7L;
+      case 28:
+        return (data[idx] >>> 33) & 7L;
+      case 31:
+        return (data[idx] >>> 30) & 7L;
+      case 34:
+        return (data[idx] >>> 27) & 7L;
+      case 37:
+        return (data[idx] >>> 24) & 7L;
+      case 40:
+        return (data[idx] >>> 21) & 7L;
+      case 43:
+        return (data[idx] >>> 18) & 7L;
+      case 46:
+        return (data[idx] >>> 15) & 7L;
+      case 49:
+        return (data[idx] >>> 12) & 7L;
+      case 52:
+        return (data[idx] >>> 9) & 7L;
+      case 55:
+        return (data[idx] >>> 6) & 7L;
+      case 58:
+        return (data[idx] >>> 3) & 7L;
+      case 61:
+        return data[idx] & 7L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader4 extends Base {
+    public Reader4(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*4;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 60;
+      case 4:
+        return (data[idx] >>> 56) & 15L;
+      case 8:
+        return (data[idx] >>> 52) & 15L;
+      case 12:
+        return (data[idx] >>> 48) & 15L;
+      case 16:
+        return (data[idx] >>> 44) & 15L;
+      case 20:
+        return (data[idx] >>> 40) & 15L;
+      case 24:
+        return (data[idx] >>> 36) & 15L;
+      case 28:
+        return (data[idx] >>> 32) & 15L;
+      case 32:
+        return (data[idx] >>> 28) & 15L;
+      case 36:
+        return (data[idx] >>> 24) & 15L;
+      case 40:
+        return (data[idx] >>> 20) & 15L;
+      case 44:
+        return (data[idx] >>> 16) & 15L;
+      case 48:
+        return (data[idx] >>> 12) & 15L;
+      case 52:
+        return (data[idx] >>> 8) & 15L;
+      case 56:
+        return (data[idx] >>> 4) & 15L;
+      case 60:
+        return data[idx] & 15L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader5 extends Base {
+    public Reader5(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*5;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 59;
+      case 5:
+        return (data[idx] >>> 54) & 31L;
+      case 10:
+        return (data[idx] >>> 49) & 31L;
+      case 15:
+        return (data[idx] >>> 44) & 31L;
+      case 20:
+        return (data[idx] >>> 39) & 31L;
+      case 25:
+        return (data[idx] >>> 34) & 31L;
+      case 30:
+        return (data[idx] >>> 29) & 31L;
+      case 35:
+        return (data[idx] >>> 24) & 31L;
+      case 40:
+        return (data[idx] >>> 19) & 31L;
+      case 45:
+        return (data[idx] >>> 14) & 31L;
+      case 50:
+        return (data[idx] >>> 9) & 31L;
+      case 55:
+        return (data[idx] >>> 4) & 31L;
+      case 60:
+        return ((data[idx] & 15L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 58) & 31L;
+      case 6:
+        return (data[idx] >>> 53) & 31L;
+      case 11:
+        return (data[idx] >>> 48) & 31L;
+      case 16:
+        return (data[idx] >>> 43) & 31L;
+      case 21:
+        return (data[idx] >>> 38) & 31L;
+      case 26:
+        return (data[idx] >>> 33) & 31L;
+      case 31:
+        return (data[idx] >>> 28) & 31L;
+      case 36:
+        return (data[idx] >>> 23) & 31L;
+      case 41:
+        return (data[idx] >>> 18) & 31L;
+      case 46:
+        return (data[idx] >>> 13) & 31L;
+      case 51:
+        return (data[idx] >>> 8) & 31L;
+      case 56:
+        return (data[idx] >>> 3) & 31L;
+      case 61:
+        return ((data[idx] & 7L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 57) & 31L;
+      case 7:
+        return (data[idx] >>> 52) & 31L;
+      case 12:
+        return (data[idx] >>> 47) & 31L;
+      case 17:
+        return (data[idx] >>> 42) & 31L;
+      case 22:
+        return (data[idx] >>> 37) & 31L;
+      case 27:
+        return (data[idx] >>> 32) & 31L;
+      case 32:
+        return (data[idx] >>> 27) & 31L;
+      case 37:
+        return (data[idx] >>> 22) & 31L;
+      case 42:
+        return (data[idx] >>> 17) & 31L;
+      case 47:
+        return (data[idx] >>> 12) & 31L;
+      case 52:
+        return (data[idx] >>> 7) & 31L;
+      case 57:
+        return (data[idx] >>> 2) & 31L;
+      case 62:
+        return ((data[idx] & 3L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 56) & 31L;
+      case 8:
+        return (data[idx] >>> 51) & 31L;
+      case 13:
+        return (data[idx] >>> 46) & 31L;
+      case 18:
+        return (data[idx] >>> 41) & 31L;
+      case 23:
+        return (data[idx] >>> 36) & 31L;
+      case 28:
+        return (data[idx] >>> 31) & 31L;
+      case 33:
+        return (data[idx] >>> 26) & 31L;
+      case 38:
+        return (data[idx] >>> 21) & 31L;
+      case 43:
+        return (data[idx] >>> 16) & 31L;
+      case 48:
+        return (data[idx] >>> 11) & 31L;
+      case 53:
+        return (data[idx] >>> 6) & 31L;
+      case 58:
+        return (data[idx] >>> 1) & 31L;
+      case 63:
+        return ((data[idx] & 1L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 55) & 31L;
+      case 9:
+        return (data[idx] >>> 50) & 31L;
+      case 14:
+        return (data[idx] >>> 45) & 31L;
+      case 19:
+        return (data[idx] >>> 40) & 31L;
+      case 24:
+        return (data[idx] >>> 35) & 31L;
+      case 29:
+        return (data[idx] >>> 30) & 31L;
+      case 34:
+        return (data[idx] >>> 25) & 31L;
+      case 39:
+        return (data[idx] >>> 20) & 31L;
+      case 44:
+        return (data[idx] >>> 15) & 31L;
+      case 49:
+        return (data[idx] >>> 10) & 31L;
+      case 54:
+        return (data[idx] >>> 5) & 31L;
+      case 59:
+        return data[idx] & 31L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader6 extends Base {
+    public Reader6(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*6;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 58;
+      case 6:
+        return (data[idx] >>> 52) & 63L;
+      case 12:
+        return (data[idx] >>> 46) & 63L;
+      case 18:
+        return (data[idx] >>> 40) & 63L;
+      case 24:
+        return (data[idx] >>> 34) & 63L;
+      case 30:
+        return (data[idx] >>> 28) & 63L;
+      case 36:
+        return (data[idx] >>> 22) & 63L;
+      case 42:
+        return (data[idx] >>> 16) & 63L;
+      case 48:
+        return (data[idx] >>> 10) & 63L;
+      case 54:
+        return (data[idx] >>> 4) & 63L;
+      case 60:
+        return ((data[idx] & 15L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 56) & 63L;
+      case 8:
+        return (data[idx] >>> 50) & 63L;
+      case 14:
+        return (data[idx] >>> 44) & 63L;
+      case 20:
+        return (data[idx] >>> 38) & 63L;
+      case 26:
+        return (data[idx] >>> 32) & 63L;
+      case 32:
+        return (data[idx] >>> 26) & 63L;
+      case 38:
+        return (data[idx] >>> 20) & 63L;
+      case 44:
+        return (data[idx] >>> 14) & 63L;
+      case 50:
+        return (data[idx] >>> 8) & 63L;
+      case 56:
+        return (data[idx] >>> 2) & 63L;
+      case 62:
+        return ((data[idx] & 3L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 54) & 63L;
+      case 10:
+        return (data[idx] >>> 48) & 63L;
+      case 16:
+        return (data[idx] >>> 42) & 63L;
+      case 22:
+        return (data[idx] >>> 36) & 63L;
+      case 28:
+        return (data[idx] >>> 30) & 63L;
+      case 34:
+        return (data[idx] >>> 24) & 63L;
+      case 40:
+        return (data[idx] >>> 18) & 63L;
+      case 46:
+        return (data[idx] >>> 12) & 63L;
+      case 52:
+        return (data[idx] >>> 6) & 63L;
+      case 58:
+        return data[idx] & 63L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader7 extends Base {
+    public Reader7(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*7;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 57;
+      case 7:
+        return (data[idx] >>> 50) & 127L;
+      case 14:
+        return (data[idx] >>> 43) & 127L;
+      case 21:
+        return (data[idx] >>> 36) & 127L;
+      case 28:
+        return (data[idx] >>> 29) & 127L;
+      case 35:
+        return (data[idx] >>> 22) & 127L;
+      case 42:
+        return (data[idx] >>> 15) & 127L;
+      case 49:
+        return (data[idx] >>> 8) & 127L;
+      case 56:
+        return (data[idx] >>> 1) & 127L;
+      case 63:
+        return ((data[idx] & 1L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 51) & 127L;
+      case 13:
+        return (data[idx] >>> 44) & 127L;
+      case 20:
+        return (data[idx] >>> 37) & 127L;
+      case 27:
+        return (data[idx] >>> 30) & 127L;
+      case 34:
+        return (data[idx] >>> 23) & 127L;
+      case 41:
+        return (data[idx] >>> 16) & 127L;
+      case 48:
+        return (data[idx] >>> 9) & 127L;
+      case 55:
+        return (data[idx] >>> 2) & 127L;
+      case 62:
+        return ((data[idx] & 3L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 52) & 127L;
+      case 12:
+        return (data[idx] >>> 45) & 127L;
+      case 19:
+        return (data[idx] >>> 38) & 127L;
+      case 26:
+        return (data[idx] >>> 31) & 127L;
+      case 33:
+        return (data[idx] >>> 24) & 127L;
+      case 40:
+        return (data[idx] >>> 17) & 127L;
+      case 47:
+        return (data[idx] >>> 10) & 127L;
+      case 54:
+        return (data[idx] >>> 3) & 127L;
+      case 61:
+        return ((data[idx] & 7L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 53) & 127L;
+      case 11:
+        return (data[idx] >>> 46) & 127L;
+      case 18:
+        return (data[idx] >>> 39) & 127L;
+      case 25:
+        return (data[idx] >>> 32) & 127L;
+      case 32:
+        return (data[idx] >>> 25) & 127L;
+      case 39:
+        return (data[idx] >>> 18) & 127L;
+      case 46:
+        return (data[idx] >>> 11) & 127L;
+      case 53:
+        return (data[idx] >>> 4) & 127L;
+      case 60:
+        return ((data[idx] & 15L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 54) & 127L;
+      case 10:
+        return (data[idx] >>> 47) & 127L;
+      case 17:
+        return (data[idx] >>> 40) & 127L;
+      case 24:
+        return (data[idx] >>> 33) & 127L;
+      case 31:
+        return (data[idx] >>> 26) & 127L;
+      case 38:
+        return (data[idx] >>> 19) & 127L;
+      case 45:
+        return (data[idx] >>> 12) & 127L;
+      case 52:
+        return (data[idx] >>> 5) & 127L;
+      case 59:
+        return ((data[idx] & 31L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 55) & 127L;
+      case 9:
+        return (data[idx] >>> 48) & 127L;
+      case 16:
+        return (data[idx] >>> 41) & 127L;
+      case 23:
+        return (data[idx] >>> 34) & 127L;
+      case 30:
+        return (data[idx] >>> 27) & 127L;
+      case 37:
+        return (data[idx] >>> 20) & 127L;
+      case 44:
+        return (data[idx] >>> 13) & 127L;
+      case 51:
+        return (data[idx] >>> 6) & 127L;
+      case 58:
+        return ((data[idx] & 63L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 56) & 127L;
+      case 8:
+        return (data[idx] >>> 49) & 127L;
+      case 15:
+        return (data[idx] >>> 42) & 127L;
+      case 22:
+        return (data[idx] >>> 35) & 127L;
+      case 29:
+        return (data[idx] >>> 28) & 127L;
+      case 36:
+        return (data[idx] >>> 21) & 127L;
+      case 43:
+        return (data[idx] >>> 14) & 127L;
+      case 50:
+        return (data[idx] >>> 7) & 127L;
+      case 57:
+        return data[idx] & 127L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader9 extends Base {
+    public Reader9(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*9;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 55;
+      case 9:
+        return (data[idx] >>> 46) & 511L;
+      case 18:
+        return (data[idx] >>> 37) & 511L;
+      case 27:
+        return (data[idx] >>> 28) & 511L;
+      case 36:
+        return (data[idx] >>> 19) & 511L;
+      case 45:
+        return (data[idx] >>> 10) & 511L;
+      case 54:
+        return (data[idx] >>> 1) & 511L;
+      case 63:
+        return ((data[idx] & 1L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 47) & 511L;
+      case 17:
+        return (data[idx] >>> 38) & 511L;
+      case 26:
+        return (data[idx] >>> 29) & 511L;
+      case 35:
+        return (data[idx] >>> 20) & 511L;
+      case 44:
+        return (data[idx] >>> 11) & 511L;
+      case 53:
+        return (data[idx] >>> 2) & 511L;
+      case 62:
+        return ((data[idx] & 3L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 48) & 511L;
+      case 16:
+        return (data[idx] >>> 39) & 511L;
+      case 25:
+        return (data[idx] >>> 30) & 511L;
+      case 34:
+        return (data[idx] >>> 21) & 511L;
+      case 43:
+        return (data[idx] >>> 12) & 511L;
+      case 52:
+        return (data[idx] >>> 3) & 511L;
+      case 61:
+        return ((data[idx] & 7L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 49) & 511L;
+      case 15:
+        return (data[idx] >>> 40) & 511L;
+      case 24:
+        return (data[idx] >>> 31) & 511L;
+      case 33:
+        return (data[idx] >>> 22) & 511L;
+      case 42:
+        return (data[idx] >>> 13) & 511L;
+      case 51:
+        return (data[idx] >>> 4) & 511L;
+      case 60:
+        return ((data[idx] & 15L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 50) & 511L;
+      case 14:
+        return (data[idx] >>> 41) & 511L;
+      case 23:
+        return (data[idx] >>> 32) & 511L;
+      case 32:
+        return (data[idx] >>> 23) & 511L;
+      case 41:
+        return (data[idx] >>> 14) & 511L;
+      case 50:
+        return (data[idx] >>> 5) & 511L;
+      case 59:
+        return ((data[idx] & 31L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 51) & 511L;
+      case 13:
+        return (data[idx] >>> 42) & 511L;
+      case 22:
+        return (data[idx] >>> 33) & 511L;
+      case 31:
+        return (data[idx] >>> 24) & 511L;
+      case 40:
+        return (data[idx] >>> 15) & 511L;
+      case 49:
+        return (data[idx] >>> 6) & 511L;
+      case 58:
+        return ((data[idx] & 63L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 52) & 511L;
+      case 12:
+        return (data[idx] >>> 43) & 511L;
+      case 21:
+        return (data[idx] >>> 34) & 511L;
+      case 30:
+        return (data[idx] >>> 25) & 511L;
+      case 39:
+        return (data[idx] >>> 16) & 511L;
+      case 48:
+        return (data[idx] >>> 7) & 511L;
+      case 57:
+        return ((data[idx] & 127L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 53) & 511L;
+      case 11:
+        return (data[idx] >>> 44) & 511L;
+      case 20:
+        return (data[idx] >>> 35) & 511L;
+      case 29:
+        return (data[idx] >>> 26) & 511L;
+      case 38:
+        return (data[idx] >>> 17) & 511L;
+      case 47:
+        return (data[idx] >>> 8) & 511L;
+      case 56:
+        return ((data[idx] & 255L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 54) & 511L;
+      case 10:
+        return (data[idx] >>> 45) & 511L;
+      case 19:
+        return (data[idx] >>> 36) & 511L;
+      case 28:
+        return (data[idx] >>> 27) & 511L;
+      case 37:
+        return (data[idx] >>> 18) & 511L;
+      case 46:
+        return (data[idx] >>> 9) & 511L;
+      case 55:
+        return data[idx] & 511L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader10 extends Base {
+    public Reader10(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*10;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 54;
+      case 10:
+        return (data[idx] >>> 44) & 1023L;
+      case 20:
+        return (data[idx] >>> 34) & 1023L;
+      case 30:
+        return (data[idx] >>> 24) & 1023L;
+      case 40:
+        return (data[idx] >>> 14) & 1023L;
+      case 50:
+        return (data[idx] >>> 4) & 1023L;
+      case 60:
+        return ((data[idx] & 15L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 48) & 1023L;
+      case 16:
+        return (data[idx] >>> 38) & 1023L;
+      case 26:
+        return (data[idx] >>> 28) & 1023L;
+      case 36:
+        return (data[idx] >>> 18) & 1023L;
+      case 46:
+        return (data[idx] >>> 8) & 1023L;
+      case 56:
+        return ((data[idx] & 255L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 52) & 1023L;
+      case 12:
+        return (data[idx] >>> 42) & 1023L;
+      case 22:
+        return (data[idx] >>> 32) & 1023L;
+      case 32:
+        return (data[idx] >>> 22) & 1023L;
+      case 42:
+        return (data[idx] >>> 12) & 1023L;
+      case 52:
+        return (data[idx] >>> 2) & 1023L;
+      case 62:
+        return ((data[idx] & 3L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 46) & 1023L;
+      case 18:
+        return (data[idx] >>> 36) & 1023L;
+      case 28:
+        return (data[idx] >>> 26) & 1023L;
+      case 38:
+        return (data[idx] >>> 16) & 1023L;
+      case 48:
+        return (data[idx] >>> 6) & 1023L;
+      case 58:
+        return ((data[idx] & 63L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 50) & 1023L;
+      case 14:
+        return (data[idx] >>> 40) & 1023L;
+      case 24:
+        return (data[idx] >>> 30) & 1023L;
+      case 34:
+        return (data[idx] >>> 20) & 1023L;
+      case 44:
+        return (data[idx] >>> 10) & 1023L;
+      case 54:
+        return data[idx] & 1023L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader11 extends Base {
+    public Reader11(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*11;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 53;
+      case 11:
+        return (data[idx] >>> 42) & 2047L;
+      case 22:
+        return (data[idx] >>> 31) & 2047L;
+      case 33:
+        return (data[idx] >>> 20) & 2047L;
+      case 44:
+        return (data[idx] >>> 9) & 2047L;
+      case 55:
+        return ((data[idx] & 511L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 51) & 2047L;
+      case 13:
+        return (data[idx] >>> 40) & 2047L;
+      case 24:
+        return (data[idx] >>> 29) & 2047L;
+      case 35:
+        return (data[idx] >>> 18) & 2047L;
+      case 46:
+        return (data[idx] >>> 7) & 2047L;
+      case 57:
+        return ((data[idx] & 127L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 49) & 2047L;
+      case 15:
+        return (data[idx] >>> 38) & 2047L;
+      case 26:
+        return (data[idx] >>> 27) & 2047L;
+      case 37:
+        return (data[idx] >>> 16) & 2047L;
+      case 48:
+        return (data[idx] >>> 5) & 2047L;
+      case 59:
+        return ((data[idx] & 31L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 47) & 2047L;
+      case 17:
+        return (data[idx] >>> 36) & 2047L;
+      case 28:
+        return (data[idx] >>> 25) & 2047L;
+      case 39:
+        return (data[idx] >>> 14) & 2047L;
+      case 50:
+        return (data[idx] >>> 3) & 2047L;
+      case 61:
+        return ((data[idx] & 7L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 45) & 2047L;
+      case 19:
+        return (data[idx] >>> 34) & 2047L;
+      case 30:
+        return (data[idx] >>> 23) & 2047L;
+      case 41:
+        return (data[idx] >>> 12) & 2047L;
+      case 52:
+        return (data[idx] >>> 1) & 2047L;
+      case 63:
+        return ((data[idx] & 1L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 43) & 2047L;
+      case 21:
+        return (data[idx] >>> 32) & 2047L;
+      case 32:
+        return (data[idx] >>> 21) & 2047L;
+      case 43:
+        return (data[idx] >>> 10) & 2047L;
+      case 54:
+        return ((data[idx] & 1023L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 52) & 2047L;
+      case 12:
+        return (data[idx] >>> 41) & 2047L;
+      case 23:
+        return (data[idx] >>> 30) & 2047L;
+      case 34:
+        return (data[idx] >>> 19) & 2047L;
+      case 45:
+        return (data[idx] >>> 8) & 2047L;
+      case 56:
+        return ((data[idx] & 255L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 50) & 2047L;
+      case 14:
+        return (data[idx] >>> 39) & 2047L;
+      case 25:
+        return (data[idx] >>> 28) & 2047L;
+      case 36:
+        return (data[idx] >>> 17) & 2047L;
+      case 47:
+        return (data[idx] >>> 6) & 2047L;
+      case 58:
+        return ((data[idx] & 63L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 48) & 2047L;
+      case 16:
+        return (data[idx] >>> 37) & 2047L;
+      case 27:
+        return (data[idx] >>> 26) & 2047L;
+      case 38:
+        return (data[idx] >>> 15) & 2047L;
+      case 49:
+        return (data[idx] >>> 4) & 2047L;
+      case 60:
+        return ((data[idx] & 15L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 46) & 2047L;
+      case 18:
+        return (data[idx] >>> 35) & 2047L;
+      case 29:
+        return (data[idx] >>> 24) & 2047L;
+      case 40:
+        return (data[idx] >>> 13) & 2047L;
+      case 51:
+        return (data[idx] >>> 2) & 2047L;
+      case 62:
+        return ((data[idx] & 3L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 44) & 2047L;
+      case 20:
+        return (data[idx] >>> 33) & 2047L;
+      case 31:
+        return (data[idx] >>> 22) & 2047L;
+      case 42:
+        return (data[idx] >>> 11) & 2047L;
+      case 53:
+        return data[idx] & 2047L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader12 extends Base {
+    public Reader12(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*12;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 52;
+      case 12:
+        return (data[idx] >>> 40) & 4095L;
+      case 24:
+        return (data[idx] >>> 28) & 4095L;
+      case 36:
+        return (data[idx] >>> 16) & 4095L;
+      case 48:
+        return (data[idx] >>> 4) & 4095L;
+      case 60:
+        return ((data[idx] & 15L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 44) & 4095L;
+      case 20:
+        return (data[idx] >>> 32) & 4095L;
+      case 32:
+        return (data[idx] >>> 20) & 4095L;
+      case 44:
+        return (data[idx] >>> 8) & 4095L;
+      case 56:
+        return ((data[idx] & 255L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 48) & 4095L;
+      case 16:
+        return (data[idx] >>> 36) & 4095L;
+      case 28:
+        return (data[idx] >>> 24) & 4095L;
+      case 40:
+        return (data[idx] >>> 12) & 4095L;
+      case 52:
+        return data[idx] & 4095L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader13 extends Base {
+    public Reader13(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*13;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 51;
+      case 13:
+        return (data[idx] >>> 38) & 8191L;
+      case 26:
+        return (data[idx] >>> 25) & 8191L;
+      case 39:
+        return (data[idx] >>> 12) & 8191L;
+      case 52:
+        return ((data[idx] & 4095L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 50) & 8191L;
+      case 14:
+        return (data[idx] >>> 37) & 8191L;
+      case 27:
+        return (data[idx] >>> 24) & 8191L;
+      case 40:
+        return (data[idx] >>> 11) & 8191L;
+      case 53:
+        return ((data[idx] & 2047L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 49) & 8191L;
+      case 15:
+        return (data[idx] >>> 36) & 8191L;
+      case 28:
+        return (data[idx] >>> 23) & 8191L;
+      case 41:
+        return (data[idx] >>> 10) & 8191L;
+      case 54:
+        return ((data[idx] & 1023L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 48) & 8191L;
+      case 16:
+        return (data[idx] >>> 35) & 8191L;
+      case 29:
+        return (data[idx] >>> 22) & 8191L;
+      case 42:
+        return (data[idx] >>> 9) & 8191L;
+      case 55:
+        return ((data[idx] & 511L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 47) & 8191L;
+      case 17:
+        return (data[idx] >>> 34) & 8191L;
+      case 30:
+        return (data[idx] >>> 21) & 8191L;
+      case 43:
+        return (data[idx] >>> 8) & 8191L;
+      case 56:
+        return ((data[idx] & 255L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 46) & 8191L;
+      case 18:
+        return (data[idx] >>> 33) & 8191L;
+      case 31:
+        return (data[idx] >>> 20) & 8191L;
+      case 44:
+        return (data[idx] >>> 7) & 8191L;
+      case 57:
+        return ((data[idx] & 127L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 45) & 8191L;
+      case 19:
+        return (data[idx] >>> 32) & 8191L;
+      case 32:
+        return (data[idx] >>> 19) & 8191L;
+      case 45:
+        return (data[idx] >>> 6) & 8191L;
+      case 58:
+        return ((data[idx] & 63L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 44) & 8191L;
+      case 20:
+        return (data[idx] >>> 31) & 8191L;
+      case 33:
+        return (data[idx] >>> 18) & 8191L;
+      case 46:
+        return (data[idx] >>> 5) & 8191L;
+      case 59:
+        return ((data[idx] & 31L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 43) & 8191L;
+      case 21:
+        return (data[idx] >>> 30) & 8191L;
+      case 34:
+        return (data[idx] >>> 17) & 8191L;
+      case 47:
+        return (data[idx] >>> 4) & 8191L;
+      case 60:
+        return ((data[idx] & 15L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 42) & 8191L;
+      case 22:
+        return (data[idx] >>> 29) & 8191L;
+      case 35:
+        return (data[idx] >>> 16) & 8191L;
+      case 48:
+        return (data[idx] >>> 3) & 8191L;
+      case 61:
+        return ((data[idx] & 7L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 41) & 8191L;
+      case 23:
+        return (data[idx] >>> 28) & 8191L;
+      case 36:
+        return (data[idx] >>> 15) & 8191L;
+      case 49:
+        return (data[idx] >>> 2) & 8191L;
+      case 62:
+        return ((data[idx] & 3L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 40) & 8191L;
+      case 24:
+        return (data[idx] >>> 27) & 8191L;
+      case 37:
+        return (data[idx] >>> 14) & 8191L;
+      case 50:
+        return (data[idx] >>> 1) & 8191L;
+      case 63:
+        return ((data[idx] & 1L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 39) & 8191L;
+      case 25:
+        return (data[idx] >>> 26) & 8191L;
+      case 38:
+        return (data[idx] >>> 13) & 8191L;
+      case 51:
+        return data[idx] & 8191L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader14 extends Base {
+    public Reader14(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*14;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 50;
+      case 14:
+        return (data[idx] >>> 36) & 16383L;
+      case 28:
+        return (data[idx] >>> 22) & 16383L;
+      case 42:
+        return (data[idx] >>> 8) & 16383L;
+      case 56:
+        return ((data[idx] & 255L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 44) & 16383L;
+      case 20:
+        return (data[idx] >>> 30) & 16383L;
+      case 34:
+        return (data[idx] >>> 16) & 16383L;
+      case 48:
+        return (data[idx] >>> 2) & 16383L;
+      case 62:
+        return ((data[idx] & 3L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 38) & 16383L;
+      case 26:
+        return (data[idx] >>> 24) & 16383L;
+      case 40:
+        return (data[idx] >>> 10) & 16383L;
+      case 54:
+        return ((data[idx] & 1023L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 46) & 16383L;
+      case 18:
+        return (data[idx] >>> 32) & 16383L;
+      case 32:
+        return (data[idx] >>> 18) & 16383L;
+      case 46:
+        return (data[idx] >>> 4) & 16383L;
+      case 60:
+        return ((data[idx] & 15L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 40) & 16383L;
+      case 24:
+        return (data[idx] >>> 26) & 16383L;
+      case 38:
+        return (data[idx] >>> 12) & 16383L;
+      case 52:
+        return ((data[idx] & 4095L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 48) & 16383L;
+      case 16:
+        return (data[idx] >>> 34) & 16383L;
+      case 30:
+        return (data[idx] >>> 20) & 16383L;
+      case 44:
+        return (data[idx] >>> 6) & 16383L;
+      case 58:
+        return ((data[idx] & 63L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 42) & 16383L;
+      case 22:
+        return (data[idx] >>> 28) & 16383L;
+      case 36:
+        return (data[idx] >>> 14) & 16383L;
+      case 50:
+        return data[idx] & 16383L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader15 extends Base {
+    public Reader15(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*15;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 49;
+      case 15:
+        return (data[idx] >>> 34) & 32767L;
+      case 30:
+        return (data[idx] >>> 19) & 32767L;
+      case 45:
+        return (data[idx] >>> 4) & 32767L;
+      case 60:
+        return ((data[idx] & 15L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 38) & 32767L;
+      case 26:
+        return (data[idx] >>> 23) & 32767L;
+      case 41:
+        return (data[idx] >>> 8) & 32767L;
+      case 56:
+        return ((data[idx] & 255L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 42) & 32767L;
+      case 22:
+        return (data[idx] >>> 27) & 32767L;
+      case 37:
+        return (data[idx] >>> 12) & 32767L;
+      case 52:
+        return ((data[idx] & 4095L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 46) & 32767L;
+      case 18:
+        return (data[idx] >>> 31) & 32767L;
+      case 33:
+        return (data[idx] >>> 16) & 32767L;
+      case 48:
+        return (data[idx] >>> 1) & 32767L;
+      case 63:
+        return ((data[idx] & 1L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 35) & 32767L;
+      case 29:
+        return (data[idx] >>> 20) & 32767L;
+      case 44:
+        return (data[idx] >>> 5) & 32767L;
+      case 59:
+        return ((data[idx] & 31L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 39) & 32767L;
+      case 25:
+        return (data[idx] >>> 24) & 32767L;
+      case 40:
+        return (data[idx] >>> 9) & 32767L;
+      case 55:
+        return ((data[idx] & 511L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 43) & 32767L;
+      case 21:
+        return (data[idx] >>> 28) & 32767L;
+      case 36:
+        return (data[idx] >>> 13) & 32767L;
+      case 51:
+        return ((data[idx] & 8191L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 47) & 32767L;
+      case 17:
+        return (data[idx] >>> 32) & 32767L;
+      case 32:
+        return (data[idx] >>> 17) & 32767L;
+      case 47:
+        return (data[idx] >>> 2) & 32767L;
+      case 62:
+        return ((data[idx] & 3L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 36) & 32767L;
+      case 28:
+        return (data[idx] >>> 21) & 32767L;
+      case 43:
+        return (data[idx] >>> 6) & 32767L;
+      case 58:
+        return ((data[idx] & 63L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 40) & 32767L;
+      case 24:
+        return (data[idx] >>> 25) & 32767L;
+      case 39:
+        return (data[idx] >>> 10) & 32767L;
+      case 54:
+        return ((data[idx] & 1023L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 44) & 32767L;
+      case 20:
+        return (data[idx] >>> 29) & 32767L;
+      case 35:
+        return (data[idx] >>> 14) & 32767L;
+      case 50:
+        return ((data[idx] & 16383L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 48) & 32767L;
+      case 16:
+        return (data[idx] >>> 33) & 32767L;
+      case 31:
+        return (data[idx] >>> 18) & 32767L;
+      case 46:
+        return (data[idx] >>> 3) & 32767L;
+      case 61:
+        return ((data[idx] & 7L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 37) & 32767L;
+      case 27:
+        return (data[idx] >>> 22) & 32767L;
+      case 42:
+        return (data[idx] >>> 7) & 32767L;
+      case 57:
+        return ((data[idx] & 127L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 41) & 32767L;
+      case 23:
+        return (data[idx] >>> 26) & 32767L;
+      case 38:
+        return (data[idx] >>> 11) & 32767L;
+      case 53:
+        return ((data[idx] & 2047L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 45) & 32767L;
+      case 19:
+        return (data[idx] >>> 30) & 32767L;
+      case 34:
+        return (data[idx] >>> 15) & 32767L;
+      case 49:
+        return data[idx] & 32767L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader17 extends Base {
+    public Reader17(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*17;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 47;
+      case 17:
+        return (data[idx] >>> 30) & 131071L;
+      case 34:
+        return (data[idx] >>> 13) & 131071L;
+      case 51:
+        return ((data[idx] & 8191L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 43) & 131071L;
+      case 21:
+        return (data[idx] >>> 26) & 131071L;
+      case 38:
+        return (data[idx] >>> 9) & 131071L;
+      case 55:
+        return ((data[idx] & 511L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 39) & 131071L;
+      case 25:
+        return (data[idx] >>> 22) & 131071L;
+      case 42:
+        return (data[idx] >>> 5) & 131071L;
+      case 59:
+        return ((data[idx] & 31L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 35) & 131071L;
+      case 29:
+        return (data[idx] >>> 18) & 131071L;
+      case 46:
+        return (data[idx] >>> 1) & 131071L;
+      case 63:
+        return ((data[idx] & 1L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 31) & 131071L;
+      case 33:
+        return (data[idx] >>> 14) & 131071L;
+      case 50:
+        return ((data[idx] & 16383L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 44) & 131071L;
+      case 20:
+        return (data[idx] >>> 27) & 131071L;
+      case 37:
+        return (data[idx] >>> 10) & 131071L;
+      case 54:
+        return ((data[idx] & 1023L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 40) & 131071L;
+      case 24:
+        return (data[idx] >>> 23) & 131071L;
+      case 41:
+        return (data[idx] >>> 6) & 131071L;
+      case 58:
+        return ((data[idx] & 63L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 36) & 131071L;
+      case 28:
+        return (data[idx] >>> 19) & 131071L;
+      case 45:
+        return (data[idx] >>> 2) & 131071L;
+      case 62:
+        return ((data[idx] & 3L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 32) & 131071L;
+      case 32:
+        return (data[idx] >>> 15) & 131071L;
+      case 49:
+        return ((data[idx] & 32767L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 45) & 131071L;
+      case 19:
+        return (data[idx] >>> 28) & 131071L;
+      case 36:
+        return (data[idx] >>> 11) & 131071L;
+      case 53:
+        return ((data[idx] & 2047L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 41) & 131071L;
+      case 23:
+        return (data[idx] >>> 24) & 131071L;
+      case 40:
+        return (data[idx] >>> 7) & 131071L;
+      case 57:
+        return ((data[idx] & 127L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 37) & 131071L;
+      case 27:
+        return (data[idx] >>> 20) & 131071L;
+      case 44:
+        return (data[idx] >>> 3) & 131071L;
+      case 61:
+        return ((data[idx] & 7L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 33) & 131071L;
+      case 31:
+        return (data[idx] >>> 16) & 131071L;
+      case 48:
+        return ((data[idx] & 65535L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 46) & 131071L;
+      case 18:
+        return (data[idx] >>> 29) & 131071L;
+      case 35:
+        return (data[idx] >>> 12) & 131071L;
+      case 52:
+        return ((data[idx] & 4095L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 42) & 131071L;
+      case 22:
+        return (data[idx] >>> 25) & 131071L;
+      case 39:
+        return (data[idx] >>> 8) & 131071L;
+      case 56:
+        return ((data[idx] & 255L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 38) & 131071L;
+      case 26:
+        return (data[idx] >>> 21) & 131071L;
+      case 43:
+        return (data[idx] >>> 4) & 131071L;
+      case 60:
+        return ((data[idx] & 15L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 34) & 131071L;
+      case 30:
+        return (data[idx] >>> 17) & 131071L;
+      case 47:
+        return data[idx] & 131071L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader18 extends Base {
+    public Reader18(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*18;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 46;
+      case 18:
+        return (data[idx] >>> 28) & 262143L;
+      case 36:
+        return (data[idx] >>> 10) & 262143L;
+      case 54:
+        return ((data[idx] & 1023L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 38) & 262143L;
+      case 26:
+        return (data[idx] >>> 20) & 262143L;
+      case 44:
+        return (data[idx] >>> 2) & 262143L;
+      case 62:
+        return ((data[idx] & 3L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 30) & 262143L;
+      case 34:
+        return (data[idx] >>> 12) & 262143L;
+      case 52:
+        return ((data[idx] & 4095L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 40) & 262143L;
+      case 24:
+        return (data[idx] >>> 22) & 262143L;
+      case 42:
+        return (data[idx] >>> 4) & 262143L;
+      case 60:
+        return ((data[idx] & 15L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 32) & 262143L;
+      case 32:
+        return (data[idx] >>> 14) & 262143L;
+      case 50:
+        return ((data[idx] & 16383L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 42) & 262143L;
+      case 22:
+        return (data[idx] >>> 24) & 262143L;
+      case 40:
+        return (data[idx] >>> 6) & 262143L;
+      case 58:
+        return ((data[idx] & 63L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 34) & 262143L;
+      case 30:
+        return (data[idx] >>> 16) & 262143L;
+      case 48:
+        return ((data[idx] & 65535L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 44) & 262143L;
+      case 20:
+        return (data[idx] >>> 26) & 262143L;
+      case 38:
+        return (data[idx] >>> 8) & 262143L;
+      case 56:
+        return ((data[idx] & 255L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 36) & 262143L;
+      case 28:
+        return (data[idx] >>> 18) & 262143L;
+      case 46:
+        return data[idx] & 262143L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader19 extends Base {
+    public Reader19(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*19;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 45;
+      case 19:
+        return (data[idx] >>> 26) & 524287L;
+      case 38:
+        return (data[idx] >>> 7) & 524287L;
+      case 57:
+        return ((data[idx] & 127L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 33) & 524287L;
+      case 31:
+        return (data[idx] >>> 14) & 524287L;
+      case 50:
+        return ((data[idx] & 16383L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 40) & 524287L;
+      case 24:
+        return (data[idx] >>> 21) & 524287L;
+      case 43:
+        return (data[idx] >>> 2) & 524287L;
+      case 62:
+        return ((data[idx] & 3L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 28) & 524287L;
+      case 36:
+        return (data[idx] >>> 9) & 524287L;
+      case 55:
+        return ((data[idx] & 511L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 35) & 524287L;
+      case 29:
+        return (data[idx] >>> 16) & 524287L;
+      case 48:
+        return ((data[idx] & 65535L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 42) & 524287L;
+      case 22:
+        return (data[idx] >>> 23) & 524287L;
+      case 41:
+        return (data[idx] >>> 4) & 524287L;
+      case 60:
+        return ((data[idx] & 15L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 30) & 524287L;
+      case 34:
+        return (data[idx] >>> 11) & 524287L;
+      case 53:
+        return ((data[idx] & 2047L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 37) & 524287L;
+      case 27:
+        return (data[idx] >>> 18) & 524287L;
+      case 46:
+        return ((data[idx] & 262143L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 44) & 524287L;
+      case 20:
+        return (data[idx] >>> 25) & 524287L;
+      case 39:
+        return (data[idx] >>> 6) & 524287L;
+      case 58:
+        return ((data[idx] & 63L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 32) & 524287L;
+      case 32:
+        return (data[idx] >>> 13) & 524287L;
+      case 51:
+        return ((data[idx] & 8191L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 39) & 524287L;
+      case 25:
+        return (data[idx] >>> 20) & 524287L;
+      case 44:
+        return (data[idx] >>> 1) & 524287L;
+      case 63:
+        return ((data[idx] & 1L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 27) & 524287L;
+      case 37:
+        return (data[idx] >>> 8) & 524287L;
+      case 56:
+        return ((data[idx] & 255L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 34) & 524287L;
+      case 30:
+        return (data[idx] >>> 15) & 524287L;
+      case 49:
+        return ((data[idx] & 32767L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 41) & 524287L;
+      case 23:
+        return (data[idx] >>> 22) & 524287L;
+      case 42:
+        return (data[idx] >>> 3) & 524287L;
+      case 61:
+        return ((data[idx] & 7L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 29) & 524287L;
+      case 35:
+        return (data[idx] >>> 10) & 524287L;
+      case 54:
+        return ((data[idx] & 1023L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 36) & 524287L;
+      case 28:
+        return (data[idx] >>> 17) & 524287L;
+      case 47:
+        return ((data[idx] & 131071L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 43) & 524287L;
+      case 21:
+        return (data[idx] >>> 24) & 524287L;
+      case 40:
+        return (data[idx] >>> 5) & 524287L;
+      case 59:
+        return ((data[idx] & 31L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 31) & 524287L;
+      case 33:
+        return (data[idx] >>> 12) & 524287L;
+      case 52:
+        return ((data[idx] & 4095L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 38) & 524287L;
+      case 26:
+        return (data[idx] >>> 19) & 524287L;
+      case 45:
+        return data[idx] & 524287L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader20 extends Base {
+    public Reader20(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*20;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 44;
+      case 20:
+        return (data[idx] >>> 24) & 1048575L;
+      case 40:
+        return (data[idx] >>> 4) & 1048575L;
+      case 60:
+        return ((data[idx] & 15L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 28) & 1048575L;
+      case 36:
+        return (data[idx] >>> 8) & 1048575L;
+      case 56:
+        return ((data[idx] & 255L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 32) & 1048575L;
+      case 32:
+        return (data[idx] >>> 12) & 1048575L;
+      case 52:
+        return ((data[idx] & 4095L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 36) & 1048575L;
+      case 28:
+        return (data[idx] >>> 16) & 1048575L;
+      case 48:
+        return ((data[idx] & 65535L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 40) & 1048575L;
+      case 24:
+        return (data[idx] >>> 20) & 1048575L;
+      case 44:
+        return data[idx] & 1048575L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader21 extends Base {
+    public Reader21(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*21;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 43;
+      case 21:
+        return (data[idx] >>> 22) & 2097151L;
+      case 42:
+        return (data[idx] >>> 1) & 2097151L;
+      case 63:
+        return ((data[idx] & 1L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 23) & 2097151L;
+      case 41:
+        return (data[idx] >>> 2) & 2097151L;
+      case 62:
+        return ((data[idx] & 3L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 24) & 2097151L;
+      case 40:
+        return (data[idx] >>> 3) & 2097151L;
+      case 61:
+        return ((data[idx] & 7L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 25) & 2097151L;
+      case 39:
+        return (data[idx] >>> 4) & 2097151L;
+      case 60:
+        return ((data[idx] & 15L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 26) & 2097151L;
+      case 38:
+        return (data[idx] >>> 5) & 2097151L;
+      case 59:
+        return ((data[idx] & 31L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 27) & 2097151L;
+      case 37:
+        return (data[idx] >>> 6) & 2097151L;
+      case 58:
+        return ((data[idx] & 63L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 28) & 2097151L;
+      case 36:
+        return (data[idx] >>> 7) & 2097151L;
+      case 57:
+        return ((data[idx] & 127L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 29) & 2097151L;
+      case 35:
+        return (data[idx] >>> 8) & 2097151L;
+      case 56:
+        return ((data[idx] & 255L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 30) & 2097151L;
+      case 34:
+        return (data[idx] >>> 9) & 2097151L;
+      case 55:
+        return ((data[idx] & 511L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 31) & 2097151L;
+      case 33:
+        return (data[idx] >>> 10) & 2097151L;
+      case 54:
+        return ((data[idx] & 1023L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 32) & 2097151L;
+      case 32:
+        return (data[idx] >>> 11) & 2097151L;
+      case 53:
+        return ((data[idx] & 2047L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 33) & 2097151L;
+      case 31:
+        return (data[idx] >>> 12) & 2097151L;
+      case 52:
+        return ((data[idx] & 4095L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 34) & 2097151L;
+      case 30:
+        return (data[idx] >>> 13) & 2097151L;
+      case 51:
+        return ((data[idx] & 8191L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 35) & 2097151L;
+      case 29:
+        return (data[idx] >>> 14) & 2097151L;
+      case 50:
+        return ((data[idx] & 16383L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 36) & 2097151L;
+      case 28:
+        return (data[idx] >>> 15) & 2097151L;
+      case 49:
+        return ((data[idx] & 32767L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 37) & 2097151L;
+      case 27:
+        return (data[idx] >>> 16) & 2097151L;
+      case 48:
+        return ((data[idx] & 65535L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 38) & 2097151L;
+      case 26:
+        return (data[idx] >>> 17) & 2097151L;
+      case 47:
+        return ((data[idx] & 131071L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 39) & 2097151L;
+      case 25:
+        return (data[idx] >>> 18) & 2097151L;
+      case 46:
+        return ((data[idx] & 262143L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 40) & 2097151L;
+      case 24:
+        return (data[idx] >>> 19) & 2097151L;
+      case 45:
+        return ((data[idx] & 524287L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 41) & 2097151L;
+      case 23:
+        return (data[idx] >>> 20) & 2097151L;
+      case 44:
+        return ((data[idx] & 1048575L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 42) & 2097151L;
+      case 22:
+        return (data[idx] >>> 21) & 2097151L;
+      case 43:
+        return data[idx] & 2097151L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader22 extends Base {
+    public Reader22(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*22;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 42;
+      case 22:
+        return (data[idx] >>> 20) & 4194303L;
+      case 44:
+        return ((data[idx] & 1048575L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 40) & 4194303L;
+      case 24:
+        return (data[idx] >>> 18) & 4194303L;
+      case 46:
+        return ((data[idx] & 262143L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 38) & 4194303L;
+      case 26:
+        return (data[idx] >>> 16) & 4194303L;
+      case 48:
+        return ((data[idx] & 65535L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 36) & 4194303L;
+      case 28:
+        return (data[idx] >>> 14) & 4194303L;
+      case 50:
+        return ((data[idx] & 16383L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 34) & 4194303L;
+      case 30:
+        return (data[idx] >>> 12) & 4194303L;
+      case 52:
+        return ((data[idx] & 4095L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 32) & 4194303L;
+      case 32:
+        return (data[idx] >>> 10) & 4194303L;
+      case 54:
+        return ((data[idx] & 1023L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 30) & 4194303L;
+      case 34:
+        return (data[idx] >>> 8) & 4194303L;
+      case 56:
+        return ((data[idx] & 255L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 28) & 4194303L;
+      case 36:
+        return (data[idx] >>> 6) & 4194303L;
+      case 58:
+        return ((data[idx] & 63L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 26) & 4194303L;
+      case 38:
+        return (data[idx] >>> 4) & 4194303L;
+      case 60:
+        return ((data[idx] & 15L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 24) & 4194303L;
+      case 40:
+        return (data[idx] >>> 2) & 4194303L;
+      case 62:
+        return ((data[idx] & 3L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 22) & 4194303L;
+      case 42:
+        return data[idx] & 4194303L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader23 extends Base {
+    public Reader23(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*23;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 41;
+      case 23:
+        return (data[idx] >>> 18) & 8388607L;
+      case 46:
+        return ((data[idx] & 262143L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 36) & 8388607L;
+      case 28:
+        return (data[idx] >>> 13) & 8388607L;
+      case 51:
+        return ((data[idx] & 8191L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 31) & 8388607L;
+      case 33:
+        return (data[idx] >>> 8) & 8388607L;
+      case 56:
+        return ((data[idx] & 255L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 26) & 8388607L;
+      case 38:
+        return (data[idx] >>> 3) & 8388607L;
+      case 61:
+        return ((data[idx] & 7L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 21) & 8388607L;
+      case 43:
+        return ((data[idx] & 2097151L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 39) & 8388607L;
+      case 25:
+        return (data[idx] >>> 16) & 8388607L;
+      case 48:
+        return ((data[idx] & 65535L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 34) & 8388607L;
+      case 30:
+        return (data[idx] >>> 11) & 8388607L;
+      case 53:
+        return ((data[idx] & 2047L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 29) & 8388607L;
+      case 35:
+        return (data[idx] >>> 6) & 8388607L;
+      case 58:
+        return ((data[idx] & 63L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 24) & 8388607L;
+      case 40:
+        return (data[idx] >>> 1) & 8388607L;
+      case 63:
+        return ((data[idx] & 1L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 19) & 8388607L;
+      case 45:
+        return ((data[idx] & 524287L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 37) & 8388607L;
+      case 27:
+        return (data[idx] >>> 14) & 8388607L;
+      case 50:
+        return ((data[idx] & 16383L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 32) & 8388607L;
+      case 32:
+        return (data[idx] >>> 9) & 8388607L;
+      case 55:
+        return ((data[idx] & 511L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 27) & 8388607L;
+      case 37:
+        return (data[idx] >>> 4) & 8388607L;
+      case 60:
+        return ((data[idx] & 15L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 22) & 8388607L;
+      case 42:
+        return ((data[idx] & 4194303L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 40) & 8388607L;
+      case 24:
+        return (data[idx] >>> 17) & 8388607L;
+      case 47:
+        return ((data[idx] & 131071L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 35) & 8388607L;
+      case 29:
+        return (data[idx] >>> 12) & 8388607L;
+      case 52:
+        return ((data[idx] & 4095L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 30) & 8388607L;
+      case 34:
+        return (data[idx] >>> 7) & 8388607L;
+      case 57:
+        return ((data[idx] & 127L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 25) & 8388607L;
+      case 39:
+        return (data[idx] >>> 2) & 8388607L;
+      case 62:
+        return ((data[idx] & 3L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 20) & 8388607L;
+      case 44:
+        return ((data[idx] & 1048575L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 38) & 8388607L;
+      case 26:
+        return (data[idx] >>> 15) & 8388607L;
+      case 49:
+        return ((data[idx] & 32767L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 33) & 8388607L;
+      case 31:
+        return (data[idx] >>> 10) & 8388607L;
+      case 54:
+        return ((data[idx] & 1023L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 28) & 8388607L;
+      case 36:
+        return (data[idx] >>> 5) & 8388607L;
+      case 59:
+        return ((data[idx] & 31L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 23) & 8388607L;
+      case 41:
+        return data[idx] & 8388607L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader24 extends Base {
+    public Reader24(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*24;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 40;
+      case 24:
+        return (data[idx] >>> 16) & 16777215L;
+      case 48:
+        return ((data[idx] & 65535L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 32) & 16777215L;
+      case 32:
+        return (data[idx] >>> 8) & 16777215L;
+      case 56:
+        return ((data[idx] & 255L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 24) & 16777215L;
+      case 40:
+        return data[idx] & 16777215L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader25 extends Base {
+    public Reader25(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*25;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 39;
+      case 25:
+        return (data[idx] >>> 14) & 33554431L;
+      case 50:
+        return ((data[idx] & 16383L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 28) & 33554431L;
+      case 36:
+        return (data[idx] >>> 3) & 33554431L;
+      case 61:
+        return ((data[idx] & 7L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 17) & 33554431L;
+      case 47:
+        return ((data[idx] & 131071L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 31) & 33554431L;
+      case 33:
+        return (data[idx] >>> 6) & 33554431L;
+      case 58:
+        return ((data[idx] & 63L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 20) & 33554431L;
+      case 44:
+        return ((data[idx] & 1048575L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 34) & 33554431L;
+      case 30:
+        return (data[idx] >>> 9) & 33554431L;
+      case 55:
+        return ((data[idx] & 511L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 23) & 33554431L;
+      case 41:
+        return ((data[idx] & 8388607L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 37) & 33554431L;
+      case 27:
+        return (data[idx] >>> 12) & 33554431L;
+      case 52:
+        return ((data[idx] & 4095L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 26) & 33554431L;
+      case 38:
+        return (data[idx] >>> 1) & 33554431L;
+      case 63:
+        return ((data[idx] & 1L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 15) & 33554431L;
+      case 49:
+        return ((data[idx] & 32767L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 29) & 33554431L;
+      case 35:
+        return (data[idx] >>> 4) & 33554431L;
+      case 60:
+        return ((data[idx] & 15L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 18) & 33554431L;
+      case 46:
+        return ((data[idx] & 262143L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 32) & 33554431L;
+      case 32:
+        return (data[idx] >>> 7) & 33554431L;
+      case 57:
+        return ((data[idx] & 127L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 21) & 33554431L;
+      case 43:
+        return ((data[idx] & 2097151L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 35) & 33554431L;
+      case 29:
+        return (data[idx] >>> 10) & 33554431L;
+      case 54:
+        return ((data[idx] & 1023L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 24) & 33554431L;
+      case 40:
+        return ((data[idx] & 16777215L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 38) & 33554431L;
+      case 26:
+        return (data[idx] >>> 13) & 33554431L;
+      case 51:
+        return ((data[idx] & 8191L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 27) & 33554431L;
+      case 37:
+        return (data[idx] >>> 2) & 33554431L;
+      case 62:
+        return ((data[idx] & 3L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return (data[idx] >>> 16) & 33554431L;
+      case 48:
+        return ((data[idx] & 65535L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 30) & 33554431L;
+      case 34:
+        return (data[idx] >>> 5) & 33554431L;
+      case 59:
+        return ((data[idx] & 31L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 19) & 33554431L;
+      case 45:
+        return ((data[idx] & 524287L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 33) & 33554431L;
+      case 31:
+        return (data[idx] >>> 8) & 33554431L;
+      case 56:
+        return ((data[idx] & 255L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 22) & 33554431L;
+      case 42:
+        return ((data[idx] & 4194303L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 36) & 33554431L;
+      case 28:
+        return (data[idx] >>> 11) & 33554431L;
+      case 53:
+        return ((data[idx] & 2047L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 25) & 33554431L;
+      case 39:
+        return data[idx] & 33554431L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader26 extends Base {
+    public Reader26(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*26;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 38;
+      case 26:
+        return (data[idx] >>> 12) & 67108863L;
+      case 52:
+        return ((data[idx] & 4095L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 24) & 67108863L;
+      case 40:
+        return ((data[idx] & 16777215L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 36) & 67108863L;
+      case 28:
+        return (data[idx] >>> 10) & 67108863L;
+      case 54:
+        return ((data[idx] & 1023L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 22) & 67108863L;
+      case 42:
+        return ((data[idx] & 4194303L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 34) & 67108863L;
+      case 30:
+        return (data[idx] >>> 8) & 67108863L;
+      case 56:
+        return ((data[idx] & 255L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 20) & 67108863L;
+      case 44:
+        return ((data[idx] & 1048575L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 32) & 67108863L;
+      case 32:
+        return (data[idx] >>> 6) & 67108863L;
+      case 58:
+        return ((data[idx] & 63L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 18) & 67108863L;
+      case 46:
+        return ((data[idx] & 262143L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 30) & 67108863L;
+      case 34:
+        return (data[idx] >>> 4) & 67108863L;
+      case 60:
+        return ((data[idx] & 15L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 16) & 67108863L;
+      case 48:
+        return ((data[idx] & 65535L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 28) & 67108863L;
+      case 36:
+        return (data[idx] >>> 2) & 67108863L;
+      case 62:
+        return ((data[idx] & 3L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 14) & 67108863L;
+      case 50:
+        return ((data[idx] & 16383L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 26) & 67108863L;
+      case 38:
+        return data[idx] & 67108863L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader27 extends Base {
+    public Reader27(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*27;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 37;
+      case 27:
+        return (data[idx] >>> 10) & 134217727L;
+      case 54:
+        return ((data[idx] & 1023L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 20) & 134217727L;
+      case 44:
+        return ((data[idx] & 1048575L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 30) & 134217727L;
+      case 34:
+        return (data[idx] >>> 3) & 134217727L;
+      case 61:
+        return ((data[idx] & 7L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 13) & 134217727L;
+      case 51:
+        return ((data[idx] & 8191L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 23) & 134217727L;
+      case 41:
+        return ((data[idx] & 8388607L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 33) & 134217727L;
+      case 31:
+        return (data[idx] >>> 6) & 134217727L;
+      case 58:
+        return ((data[idx] & 63L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 16) & 134217727L;
+      case 48:
+        return ((data[idx] & 65535L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 26) & 134217727L;
+      case 38:
+        return ((data[idx] & 67108863L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 36) & 134217727L;
+      case 28:
+        return (data[idx] >>> 9) & 134217727L;
+      case 55:
+        return ((data[idx] & 511L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 19) & 134217727L;
+      case 45:
+        return ((data[idx] & 524287L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 29) & 134217727L;
+      case 35:
+        return (data[idx] >>> 2) & 134217727L;
+      case 62:
+        return ((data[idx] & 3L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return (data[idx] >>> 12) & 134217727L;
+      case 52:
+        return ((data[idx] & 4095L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 22) & 134217727L;
+      case 42:
+        return ((data[idx] & 4194303L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 32) & 134217727L;
+      case 32:
+        return (data[idx] >>> 5) & 134217727L;
+      case 59:
+        return ((data[idx] & 31L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 15) & 134217727L;
+      case 49:
+        return ((data[idx] & 32767L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 25) & 134217727L;
+      case 39:
+        return ((data[idx] & 33554431L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 35) & 134217727L;
+      case 29:
+        return (data[idx] >>> 8) & 134217727L;
+      case 56:
+        return ((data[idx] & 255L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 18) & 134217727L;
+      case 46:
+        return ((data[idx] & 262143L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 28) & 134217727L;
+      case 36:
+        return (data[idx] >>> 1) & 134217727L;
+      case 63:
+        return ((data[idx] & 1L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return (data[idx] >>> 11) & 134217727L;
+      case 53:
+        return ((data[idx] & 2047L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 21) & 134217727L;
+      case 43:
+        return ((data[idx] & 2097151L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 31) & 134217727L;
+      case 33:
+        return (data[idx] >>> 4) & 134217727L;
+      case 60:
+        return ((data[idx] & 15L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return (data[idx] >>> 14) & 134217727L;
+      case 50:
+        return ((data[idx] & 16383L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 24) & 134217727L;
+      case 40:
+        return ((data[idx] & 16777215L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 34) & 134217727L;
+      case 30:
+        return (data[idx] >>> 7) & 134217727L;
+      case 57:
+        return ((data[idx] & 127L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 17) & 134217727L;
+      case 47:
+        return ((data[idx] & 131071L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 27) & 134217727L;
+      case 37:
+        return data[idx] & 134217727L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader28 extends Base {
+    public Reader28(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*28;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 36;
+      case 28:
+        return (data[idx] >>> 8) & 268435455L;
+      case 56:
+        return ((data[idx] & 255L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 16) & 268435455L;
+      case 48:
+        return ((data[idx] & 65535L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 24) & 268435455L;
+      case 40:
+        return ((data[idx] & 16777215L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 32) & 268435455L;
+      case 32:
+        return (data[idx] >>> 4) & 268435455L;
+      case 60:
+        return ((data[idx] & 15L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 12) & 268435455L;
+      case 52:
+        return ((data[idx] & 4095L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 20) & 268435455L;
+      case 44:
+        return ((data[idx] & 1048575L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 28) & 268435455L;
+      case 36:
+        return data[idx] & 268435455L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader29 extends Base {
+    public Reader29(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*29;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 35;
+      case 29:
+        return (data[idx] >>> 6) & 536870911L;
+      case 58:
+        return ((data[idx] & 63L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return (data[idx] >>> 12) & 536870911L;
+      case 52:
+        return ((data[idx] & 4095L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 18) & 536870911L;
+      case 46:
+        return ((data[idx] & 262143L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 24) & 536870911L;
+      case 40:
+        return ((data[idx] & 16777215L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 30) & 536870911L;
+      case 34:
+        return (data[idx] >>> 1) & 536870911L;
+      case 63:
+        return ((data[idx] & 1L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return (data[idx] >>> 7) & 536870911L;
+      case 57:
+        return ((data[idx] & 127L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 13) & 536870911L;
+      case 51:
+        return ((data[idx] & 8191L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 19) & 536870911L;
+      case 45:
+        return ((data[idx] & 524287L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 25) & 536870911L;
+      case 39:
+        return ((data[idx] & 33554431L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 31) & 536870911L;
+      case 33:
+        return (data[idx] >>> 2) & 536870911L;
+      case 62:
+        return ((data[idx] & 3L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return (data[idx] >>> 8) & 536870911L;
+      case 56:
+        return ((data[idx] & 255L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 14) & 536870911L;
+      case 50:
+        return ((data[idx] & 16383L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 20) & 536870911L;
+      case 44:
+        return ((data[idx] & 1048575L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 26) & 536870911L;
+      case 38:
+        return ((data[idx] & 67108863L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 32) & 536870911L;
+      case 32:
+        return (data[idx] >>> 3) & 536870911L;
+      case 61:
+        return ((data[idx] & 7L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return (data[idx] >>> 9) & 536870911L;
+      case 55:
+        return ((data[idx] & 511L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 15) & 536870911L;
+      case 49:
+        return ((data[idx] & 32767L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 21) & 536870911L;
+      case 43:
+        return ((data[idx] & 2097151L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 27) & 536870911L;
+      case 37:
+        return ((data[idx] & 134217727L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 33) & 536870911L;
+      case 31:
+        return (data[idx] >>> 4) & 536870911L;
+      case 60:
+        return ((data[idx] & 15L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return (data[idx] >>> 10) & 536870911L;
+      case 54:
+        return ((data[idx] & 1023L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 16) & 536870911L;
+      case 48:
+        return ((data[idx] & 65535L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 22) & 536870911L;
+      case 42:
+        return ((data[idx] & 4194303L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 28) & 536870911L;
+      case 36:
+        return ((data[idx] & 268435455L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 34) & 536870911L;
+      case 30:
+        return (data[idx] >>> 5) & 536870911L;
+      case 59:
+        return ((data[idx] & 31L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 11) & 536870911L;
+      case 53:
+        return ((data[idx] & 2047L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 17) & 536870911L;
+      case 47:
+        return ((data[idx] & 131071L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 23) & 536870911L;
+      case 41:
+        return ((data[idx] & 8388607L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 29) & 536870911L;
+      case 35:
+        return data[idx] & 536870911L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader30 extends Base {
+    public Reader30(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*30;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 34;
+      case 30:
+        return (data[idx] >>> 4) & 1073741823L;
+      case 60:
+        return ((data[idx] & 15L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return (data[idx] >>> 8) & 1073741823L;
+      case 56:
+        return ((data[idx] & 255L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 12) & 1073741823L;
+      case 52:
+        return ((data[idx] & 4095L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 16) & 1073741823L;
+      case 48:
+        return ((data[idx] & 65535L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 20) & 1073741823L;
+      case 44:
+        return ((data[idx] & 1048575L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 24) & 1073741823L;
+      case 40:
+        return ((data[idx] & 16777215L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 28) & 1073741823L;
+      case 36:
+        return ((data[idx] & 268435455L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 32) & 1073741823L;
+      case 32:
+        return (data[idx] >>> 2) & 1073741823L;
+      case 62:
+        return ((data[idx] & 3L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return (data[idx] >>> 6) & 1073741823L;
+      case 58:
+        return ((data[idx] & 63L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 10) & 1073741823L;
+      case 54:
+        return ((data[idx] & 1023L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 14) & 1073741823L;
+      case 50:
+        return ((data[idx] & 16383L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 18) & 1073741823L;
+      case 46:
+        return ((data[idx] & 262143L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 22) & 1073741823L;
+      case 42:
+        return ((data[idx] & 4194303L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 26) & 1073741823L;
+      case 38:
+        return ((data[idx] & 67108863L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 30) & 1073741823L;
+      case 34:
+        return data[idx] & 1073741823L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader31 extends Base {
+    public Reader31(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*31;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 33;
+      case 31:
+        return (data[idx] >>> 2) & 2147483647L;
+      case 62:
+        return ((data[idx] & 3L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return (data[idx] >>> 4) & 2147483647L;
+      case 60:
+        return ((data[idx] & 15L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return (data[idx] >>> 6) & 2147483647L;
+      case 58:
+        return ((data[idx] & 63L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return (data[idx] >>> 8) & 2147483647L;
+      case 56:
+        return ((data[idx] & 255L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return (data[idx] >>> 10) & 2147483647L;
+      case 54:
+        return ((data[idx] & 1023L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 12) & 2147483647L;
+      case 52:
+        return ((data[idx] & 4095L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 14) & 2147483647L;
+      case 50:
+        return ((data[idx] & 16383L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 16) & 2147483647L;
+      case 48:
+        return ((data[idx] & 65535L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 18) & 2147483647L;
+      case 46:
+        return ((data[idx] & 262143L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 20) & 2147483647L;
+      case 44:
+        return ((data[idx] & 1048575L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 22) & 2147483647L;
+      case 42:
+        return ((data[idx] & 4194303L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 24) & 2147483647L;
+      case 40:
+        return ((data[idx] & 16777215L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 26) & 2147483647L;
+      case 38:
+        return ((data[idx] & 67108863L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 28) & 2147483647L;
+      case 36:
+        return ((data[idx] & 268435455L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 30) & 2147483647L;
+      case 34:
+        return ((data[idx] & 1073741823L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 32) & 2147483647L;
+      case 32:
+        return (data[idx] >>> 1) & 2147483647L;
+      case 63:
+        return ((data[idx] & 1L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return (data[idx] >>> 3) & 2147483647L;
+      case 61:
+        return ((data[idx] & 7L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return (data[idx] >>> 5) & 2147483647L;
+      case 59:
+        return ((data[idx] & 31L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return (data[idx] >>> 7) & 2147483647L;
+      case 57:
+        return ((data[idx] & 127L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 9) & 2147483647L;
+      case 55:
+        return ((data[idx] & 511L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 11) & 2147483647L;
+      case 53:
+        return ((data[idx] & 2047L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 13) & 2147483647L;
+      case 51:
+        return ((data[idx] & 8191L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 15) & 2147483647L;
+      case 49:
+        return ((data[idx] & 32767L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 17) & 2147483647L;
+      case 47:
+        return ((data[idx] & 131071L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 19) & 2147483647L;
+      case 45:
+        return ((data[idx] & 524287L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 21) & 2147483647L;
+      case 43:
+        return ((data[idx] & 2097151L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 23) & 2147483647L;
+      case 41:
+        return ((data[idx] & 8388607L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 25) & 2147483647L;
+      case 39:
+        return ((data[idx] & 33554431L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 27) & 2147483647L;
+      case 37:
+        return ((data[idx] & 134217727L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 29) & 2147483647L;
+      case 35:
+        return ((data[idx] & 536870911L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 31) & 2147483647L;
+      case 33:
+        return data[idx] & 2147483647L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader33 extends Base {
+    public Reader33(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*33;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 31;
+      case 33:
+        return ((data[idx] & 2147483647L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 29) & 8589934591L;
+      case 35:
+        return ((data[idx] & 536870911L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 27) & 8589934591L;
+      case 37:
+        return ((data[idx] & 134217727L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 25) & 8589934591L;
+      case 39:
+        return ((data[idx] & 33554431L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 23) & 8589934591L;
+      case 41:
+        return ((data[idx] & 8388607L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 21) & 8589934591L;
+      case 43:
+        return ((data[idx] & 2097151L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 19) & 8589934591L;
+      case 45:
+        return ((data[idx] & 524287L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 17) & 8589934591L;
+      case 47:
+        return ((data[idx] & 131071L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 15) & 8589934591L;
+      case 49:
+        return ((data[idx] & 32767L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 13) & 8589934591L;
+      case 51:
+        return ((data[idx] & 8191L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 11) & 8589934591L;
+      case 53:
+        return ((data[idx] & 2047L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 9) & 8589934591L;
+      case 55:
+        return ((data[idx] & 511L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 7) & 8589934591L;
+      case 57:
+        return ((data[idx] & 127L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return (data[idx] >>> 5) & 8589934591L;
+      case 59:
+        return ((data[idx] & 31L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return (data[idx] >>> 3) & 8589934591L;
+      case 61:
+        return ((data[idx] & 7L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return (data[idx] >>> 1) & 8589934591L;
+      case 63:
+        return ((data[idx] & 1L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 30) & 8589934591L;
+      case 34:
+        return ((data[idx] & 1073741823L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 28) & 8589934591L;
+      case 36:
+        return ((data[idx] & 268435455L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 26) & 8589934591L;
+      case 38:
+        return ((data[idx] & 67108863L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 24) & 8589934591L;
+      case 40:
+        return ((data[idx] & 16777215L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 22) & 8589934591L;
+      case 42:
+        return ((data[idx] & 4194303L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 20) & 8589934591L;
+      case 44:
+        return ((data[idx] & 1048575L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 18) & 8589934591L;
+      case 46:
+        return ((data[idx] & 262143L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 16) & 8589934591L;
+      case 48:
+        return ((data[idx] & 65535L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 14) & 8589934591L;
+      case 50:
+        return ((data[idx] & 16383L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 12) & 8589934591L;
+      case 52:
+        return ((data[idx] & 4095L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 10) & 8589934591L;
+      case 54:
+        return ((data[idx] & 1023L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return (data[idx] >>> 8) & 8589934591L;
+      case 56:
+        return ((data[idx] & 255L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return (data[idx] >>> 6) & 8589934591L;
+      case 58:
+        return ((data[idx] & 63L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return (data[idx] >>> 4) & 8589934591L;
+      case 60:
+        return ((data[idx] & 15L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return (data[idx] >>> 2) & 8589934591L;
+      case 62:
+        return ((data[idx] & 3L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return data[idx] & 8589934591L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader34 extends Base {
+    public Reader34(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*34;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 30;
+      case 34:
+        return ((data[idx] & 1073741823L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 26) & 17179869183L;
+      case 38:
+        return ((data[idx] & 67108863L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 22) & 17179869183L;
+      case 42:
+        return ((data[idx] & 4194303L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 18) & 17179869183L;
+      case 46:
+        return ((data[idx] & 262143L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 14) & 17179869183L;
+      case 50:
+        return ((data[idx] & 16383L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 10) & 17179869183L;
+      case 54:
+        return ((data[idx] & 1023L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 6) & 17179869183L;
+      case 58:
+        return ((data[idx] & 63L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return (data[idx] >>> 2) & 17179869183L;
+      case 62:
+        return ((data[idx] & 3L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 28) & 17179869183L;
+      case 36:
+        return ((data[idx] & 268435455L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 24) & 17179869183L;
+      case 40:
+        return ((data[idx] & 16777215L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 20) & 17179869183L;
+      case 44:
+        return ((data[idx] & 1048575L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 16) & 17179869183L;
+      case 48:
+        return ((data[idx] & 65535L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 12) & 17179869183L;
+      case 52:
+        return ((data[idx] & 4095L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 8) & 17179869183L;
+      case 56:
+        return ((data[idx] & 255L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return (data[idx] >>> 4) & 17179869183L;
+      case 60:
+        return ((data[idx] & 15L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return data[idx] & 17179869183L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader35 extends Base {
+    public Reader35(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*35;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 29;
+      case 35:
+        return ((data[idx] & 536870911L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 23) & 34359738367L;
+      case 41:
+        return ((data[idx] & 8388607L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 17) & 34359738367L;
+      case 47:
+        return ((data[idx] & 131071L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 11) & 34359738367L;
+      case 53:
+        return ((data[idx] & 2047L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 5) & 34359738367L;
+      case 59:
+        return ((data[idx] & 31L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 28) & 34359738367L;
+      case 36:
+        return ((data[idx] & 268435455L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 22) & 34359738367L;
+      case 42:
+        return ((data[idx] & 4194303L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 16) & 34359738367L;
+      case 48:
+        return ((data[idx] & 65535L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 10) & 34359738367L;
+      case 54:
+        return ((data[idx] & 1023L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return (data[idx] >>> 4) & 34359738367L;
+      case 60:
+        return ((data[idx] & 15L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 27) & 34359738367L;
+      case 37:
+        return ((data[idx] & 134217727L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 21) & 34359738367L;
+      case 43:
+        return ((data[idx] & 2097151L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 15) & 34359738367L;
+      case 49:
+        return ((data[idx] & 32767L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 9) & 34359738367L;
+      case 55:
+        return ((data[idx] & 511L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return (data[idx] >>> 3) & 34359738367L;
+      case 61:
+        return ((data[idx] & 7L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 26) & 34359738367L;
+      case 38:
+        return ((data[idx] & 67108863L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 20) & 34359738367L;
+      case 44:
+        return ((data[idx] & 1048575L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 14) & 34359738367L;
+      case 50:
+        return ((data[idx] & 16383L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 8) & 34359738367L;
+      case 56:
+        return ((data[idx] & 255L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return (data[idx] >>> 2) & 34359738367L;
+      case 62:
+        return ((data[idx] & 3L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 25) & 34359738367L;
+      case 39:
+        return ((data[idx] & 33554431L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 19) & 34359738367L;
+      case 45:
+        return ((data[idx] & 524287L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 13) & 34359738367L;
+      case 51:
+        return ((data[idx] & 8191L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 7) & 34359738367L;
+      case 57:
+        return ((data[idx] & 127L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return (data[idx] >>> 1) & 34359738367L;
+      case 63:
+        return ((data[idx] & 1L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 24) & 34359738367L;
+      case 40:
+        return ((data[idx] & 16777215L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 18) & 34359738367L;
+      case 46:
+        return ((data[idx] & 262143L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 12) & 34359738367L;
+      case 52:
+        return ((data[idx] & 4095L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return (data[idx] >>> 6) & 34359738367L;
+      case 58:
+        return ((data[idx] & 63L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return data[idx] & 34359738367L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader36 extends Base {
+    public Reader36(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*36;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 28;
+      case 36:
+        return ((data[idx] & 268435455L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 20) & 68719476735L;
+      case 44:
+        return ((data[idx] & 1048575L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 12) & 68719476735L;
+      case 52:
+        return ((data[idx] & 4095L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 4) & 68719476735L;
+      case 60:
+        return ((data[idx] & 15L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 24) & 68719476735L;
+      case 40:
+        return ((data[idx] & 16777215L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 16) & 68719476735L;
+      case 48:
+        return ((data[idx] & 65535L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 8) & 68719476735L;
+      case 56:
+        return ((data[idx] & 255L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return data[idx] & 68719476735L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader37 extends Base {
+    public Reader37(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*37;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 27;
+      case 37:
+        return ((data[idx] & 134217727L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 17) & 137438953471L;
+      case 47:
+        return ((data[idx] & 131071L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 7) & 137438953471L;
+      case 57:
+        return ((data[idx] & 127L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 24) & 137438953471L;
+      case 40:
+        return ((data[idx] & 16777215L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 14) & 137438953471L;
+      case 50:
+        return ((data[idx] & 16383L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return (data[idx] >>> 4) & 137438953471L;
+      case 60:
+        return ((data[idx] & 15L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 21) & 137438953471L;
+      case 43:
+        return ((data[idx] & 2097151L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 11) & 137438953471L;
+      case 53:
+        return ((data[idx] & 2047L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return (data[idx] >>> 1) & 137438953471L;
+      case 63:
+        return ((data[idx] & 1L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 18) & 137438953471L;
+      case 46:
+        return ((data[idx] & 262143L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 8) & 137438953471L;
+      case 56:
+        return ((data[idx] & 255L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 25) & 137438953471L;
+      case 39:
+        return ((data[idx] & 33554431L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 15) & 137438953471L;
+      case 49:
+        return ((data[idx] & 32767L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 5) & 137438953471L;
+      case 59:
+        return ((data[idx] & 31L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 22) & 137438953471L;
+      case 42:
+        return ((data[idx] & 4194303L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 12) & 137438953471L;
+      case 52:
+        return ((data[idx] & 4095L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return (data[idx] >>> 2) & 137438953471L;
+      case 62:
+        return ((data[idx] & 3L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 19) & 137438953471L;
+      case 45:
+        return ((data[idx] & 524287L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 9) & 137438953471L;
+      case 55:
+        return ((data[idx] & 511L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 26) & 137438953471L;
+      case 38:
+        return ((data[idx] & 67108863L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 16) & 137438953471L;
+      case 48:
+        return ((data[idx] & 65535L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 6) & 137438953471L;
+      case 58:
+        return ((data[idx] & 63L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 23) & 137438953471L;
+      case 41:
+        return ((data[idx] & 8388607L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 13) & 137438953471L;
+      case 51:
+        return ((data[idx] & 8191L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 3) & 137438953471L;
+      case 61:
+        return ((data[idx] & 7L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 20) & 137438953471L;
+      case 44:
+        return ((data[idx] & 1048575L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 10) & 137438953471L;
+      case 54:
+        return ((data[idx] & 1023L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return data[idx] & 137438953471L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader38 extends Base {
+    public Reader38(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*38;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 26;
+      case 38:
+        return ((data[idx] & 67108863L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 14) & 274877906943L;
+      case 50:
+        return ((data[idx] & 16383L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 2) & 274877906943L;
+      case 62:
+        return ((data[idx] & 3L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 16) & 274877906943L;
+      case 48:
+        return ((data[idx] & 65535L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 4) & 274877906943L;
+      case 60:
+        return ((data[idx] & 15L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 18) & 274877906943L;
+      case 46:
+        return ((data[idx] & 262143L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 6) & 274877906943L;
+      case 58:
+        return ((data[idx] & 63L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 20) & 274877906943L;
+      case 44:
+        return ((data[idx] & 1048575L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 8) & 274877906943L;
+      case 56:
+        return ((data[idx] & 255L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 22) & 274877906943L;
+      case 42:
+        return ((data[idx] & 4194303L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 10) & 274877906943L;
+      case 54:
+        return ((data[idx] & 1023L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 24) & 274877906943L;
+      case 40:
+        return ((data[idx] & 16777215L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 12) & 274877906943L;
+      case 52:
+        return ((data[idx] & 4095L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return data[idx] & 274877906943L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader39 extends Base {
+    public Reader39(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*39;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 25;
+      case 39:
+        return ((data[idx] & 33554431L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 11) & 549755813887L;
+      case 53:
+        return ((data[idx] & 2047L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 22) & 549755813887L;
+      case 42:
+        return ((data[idx] & 4194303L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 8) & 549755813887L;
+      case 56:
+        return ((data[idx] & 255L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 19) & 549755813887L;
+      case 45:
+        return ((data[idx] & 524287L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 5) & 549755813887L;
+      case 59:
+        return ((data[idx] & 31L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 16) & 549755813887L;
+      case 48:
+        return ((data[idx] & 65535L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return (data[idx] >>> 2) & 549755813887L;
+      case 62:
+        return ((data[idx] & 3L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 13) & 549755813887L;
+      case 51:
+        return ((data[idx] & 8191L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 24) & 549755813887L;
+      case 40:
+        return ((data[idx] & 16777215L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 10) & 549755813887L;
+      case 54:
+        return ((data[idx] & 1023L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 21) & 549755813887L;
+      case 43:
+        return ((data[idx] & 2097151L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 7) & 549755813887L;
+      case 57:
+        return ((data[idx] & 127L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 18) & 549755813887L;
+      case 46:
+        return ((data[idx] & 262143L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 4) & 549755813887L;
+      case 60:
+        return ((data[idx] & 15L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 15) & 549755813887L;
+      case 49:
+        return ((data[idx] & 32767L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return (data[idx] >>> 1) & 549755813887L;
+      case 63:
+        return ((data[idx] & 1L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 12) & 549755813887L;
+      case 52:
+        return ((data[idx] & 4095L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 23) & 549755813887L;
+      case 41:
+        return ((data[idx] & 8388607L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 9) & 549755813887L;
+      case 55:
+        return ((data[idx] & 511L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 20) & 549755813887L;
+      case 44:
+        return ((data[idx] & 1048575L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 6) & 549755813887L;
+      case 58:
+        return ((data[idx] & 63L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 17) & 549755813887L;
+      case 47:
+        return ((data[idx] & 131071L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 3) & 549755813887L;
+      case 61:
+        return ((data[idx] & 7L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 14) & 549755813887L;
+      case 50:
+        return ((data[idx] & 16383L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return data[idx] & 549755813887L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader40 extends Base {
+    public Reader40(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*40;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 24;
+      case 40:
+        return ((data[idx] & 16777215L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 8) & 1099511627775L;
+      case 56:
+        return ((data[idx] & 255L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 16) & 1099511627775L;
+      case 48:
+        return ((data[idx] & 65535L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return data[idx] & 1099511627775L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader41 extends Base {
+    public Reader41(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*41;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 23;
+      case 41:
+        return ((data[idx] & 8388607L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 5) & 2199023255551L;
+      case 59:
+        return ((data[idx] & 31L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 10) & 2199023255551L;
+      case 54:
+        return ((data[idx] & 1023L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 15) & 2199023255551L;
+      case 49:
+        return ((data[idx] & 32767L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 20) & 2199023255551L;
+      case 44:
+        return ((data[idx] & 1048575L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return (data[idx] >>> 2) & 2199023255551L;
+      case 62:
+        return ((data[idx] & 3L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 7) & 2199023255551L;
+      case 57:
+        return ((data[idx] & 127L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 12) & 2199023255551L;
+      case 52:
+        return ((data[idx] & 4095L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 17) & 2199023255551L;
+      case 47:
+        return ((data[idx] & 131071L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 22) & 2199023255551L;
+      case 42:
+        return ((data[idx] & 4194303L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 4) & 2199023255551L;
+      case 60:
+        return ((data[idx] & 15L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 9) & 2199023255551L;
+      case 55:
+        return ((data[idx] & 511L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 14) & 2199023255551L;
+      case 50:
+        return ((data[idx] & 16383L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 19) & 2199023255551L;
+      case 45:
+        return ((data[idx] & 524287L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return (data[idx] >>> 1) & 2199023255551L;
+      case 63:
+        return ((data[idx] & 1L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 6) & 2199023255551L;
+      case 58:
+        return ((data[idx] & 63L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 11) & 2199023255551L;
+      case 53:
+        return ((data[idx] & 2047L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 16) & 2199023255551L;
+      case 48:
+        return ((data[idx] & 65535L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 21) & 2199023255551L;
+      case 43:
+        return ((data[idx] & 2097151L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 3) & 2199023255551L;
+      case 61:
+        return ((data[idx] & 7L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 8) & 2199023255551L;
+      case 56:
+        return ((data[idx] & 255L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 13) & 2199023255551L;
+      case 51:
+        return ((data[idx] & 8191L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 18) & 2199023255551L;
+      case 46:
+        return ((data[idx] & 262143L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return data[idx] & 2199023255551L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader42 extends Base {
+    public Reader42(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*42;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 22;
+      case 42:
+        return ((data[idx] & 4194303L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 2) & 4398046511103L;
+      case 62:
+        return ((data[idx] & 3L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 4) & 4398046511103L;
+      case 60:
+        return ((data[idx] & 15L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 6) & 4398046511103L;
+      case 58:
+        return ((data[idx] & 63L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 8) & 4398046511103L;
+      case 56:
+        return ((data[idx] & 255L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 10) & 4398046511103L;
+      case 54:
+        return ((data[idx] & 1023L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 12) & 4398046511103L;
+      case 52:
+        return ((data[idx] & 4095L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 14) & 4398046511103L;
+      case 50:
+        return ((data[idx] & 16383L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 16) & 4398046511103L;
+      case 48:
+        return ((data[idx] & 65535L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 18) & 4398046511103L;
+      case 46:
+        return ((data[idx] & 262143L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 20) & 4398046511103L;
+      case 44:
+        return ((data[idx] & 1048575L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return data[idx] & 4398046511103L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader43 extends Base {
+    public Reader43(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*43;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 21;
+      case 43:
+        return ((data[idx] & 2097151L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 20) & 8796093022207L;
+      case 44:
+        return ((data[idx] & 1048575L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 19) & 8796093022207L;
+      case 45:
+        return ((data[idx] & 524287L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 18) & 8796093022207L;
+      case 46:
+        return ((data[idx] & 262143L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 17) & 8796093022207L;
+      case 47:
+        return ((data[idx] & 131071L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 16) & 8796093022207L;
+      case 48:
+        return ((data[idx] & 65535L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 15) & 8796093022207L;
+      case 49:
+        return ((data[idx] & 32767L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 14) & 8796093022207L;
+      case 50:
+        return ((data[idx] & 16383L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 13) & 8796093022207L;
+      case 51:
+        return ((data[idx] & 8191L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 12) & 8796093022207L;
+      case 52:
+        return ((data[idx] & 4095L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 11) & 8796093022207L;
+      case 53:
+        return ((data[idx] & 2047L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 10) & 8796093022207L;
+      case 54:
+        return ((data[idx] & 1023L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 9) & 8796093022207L;
+      case 55:
+        return ((data[idx] & 511L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 8) & 8796093022207L;
+      case 56:
+        return ((data[idx] & 255L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 7) & 8796093022207L;
+      case 57:
+        return ((data[idx] & 127L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 6) & 8796093022207L;
+      case 58:
+        return ((data[idx] & 63L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 5) & 8796093022207L;
+      case 59:
+        return ((data[idx] & 31L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 4) & 8796093022207L;
+      case 60:
+        return ((data[idx] & 15L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 3) & 8796093022207L;
+      case 61:
+        return ((data[idx] & 7L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return (data[idx] >>> 2) & 8796093022207L;
+      case 62:
+        return ((data[idx] & 3L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return (data[idx] >>> 1) & 8796093022207L;
+      case 63:
+        return ((data[idx] & 1L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return data[idx] & 8796093022207L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader44 extends Base {
+    public Reader44(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*44;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 20;
+      case 44:
+        return ((data[idx] & 1048575L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 16) & 17592186044415L;
+      case 48:
+        return ((data[idx] & 65535L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 12) & 17592186044415L;
+      case 52:
+        return ((data[idx] & 4095L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 8) & 17592186044415L;
+      case 56:
+        return ((data[idx] & 255L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 4) & 17592186044415L;
+      case 60:
+        return ((data[idx] & 15L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return data[idx] & 17592186044415L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader45 extends Base {
+    public Reader45(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*45;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 19;
+      case 45:
+        return ((data[idx] & 524287L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 12) & 35184372088831L;
+      case 52:
+        return ((data[idx] & 4095L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 5) & 35184372088831L;
+      case 59:
+        return ((data[idx] & 31L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 17) & 35184372088831L;
+      case 47:
+        return ((data[idx] & 131071L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 10) & 35184372088831L;
+      case 54:
+        return ((data[idx] & 1023L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 3) & 35184372088831L;
+      case 61:
+        return ((data[idx] & 7L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 15) & 35184372088831L;
+      case 49:
+        return ((data[idx] & 32767L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 8) & 35184372088831L;
+      case 56:
+        return ((data[idx] & 255L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return (data[idx] >>> 1) & 35184372088831L;
+      case 63:
+        return ((data[idx] & 1L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 13) & 35184372088831L;
+      case 51:
+        return ((data[idx] & 8191L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 6) & 35184372088831L;
+      case 58:
+        return ((data[idx] & 63L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 18) & 35184372088831L;
+      case 46:
+        return ((data[idx] & 262143L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 11) & 35184372088831L;
+      case 53:
+        return ((data[idx] & 2047L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 4) & 35184372088831L;
+      case 60:
+        return ((data[idx] & 15L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 16) & 35184372088831L;
+      case 48:
+        return ((data[idx] & 65535L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 9) & 35184372088831L;
+      case 55:
+        return ((data[idx] & 511L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return (data[idx] >>> 2) & 35184372088831L;
+      case 62:
+        return ((data[idx] & 3L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 14) & 35184372088831L;
+      case 50:
+        return ((data[idx] & 16383L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 7) & 35184372088831L;
+      case 57:
+        return ((data[idx] & 127L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return data[idx] & 35184372088831L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader46 extends Base {
+    public Reader46(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*46;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 18;
+      case 46:
+        return ((data[idx] & 262143L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 8) & 70368744177663L;
+      case 56:
+        return ((data[idx] & 255L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 16) & 70368744177663L;
+      case 48:
+        return ((data[idx] & 65535L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 6) & 70368744177663L;
+      case 58:
+        return ((data[idx] & 63L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 14) & 70368744177663L;
+      case 50:
+        return ((data[idx] & 16383L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 4) & 70368744177663L;
+      case 60:
+        return ((data[idx] & 15L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 12) & 70368744177663L;
+      case 52:
+        return ((data[idx] & 4095L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 2) & 70368744177663L;
+      case 62:
+        return ((data[idx] & 3L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 10) & 70368744177663L;
+      case 54:
+        return ((data[idx] & 1023L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return data[idx] & 70368744177663L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader47 extends Base {
+    public Reader47(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*47;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 17;
+      case 47:
+        return ((data[idx] & 131071L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 4) & 140737488355327L;
+      case 60:
+        return ((data[idx] & 15L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 8) & 140737488355327L;
+      case 56:
+        return ((data[idx] & 255L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 12) & 140737488355327L;
+      case 52:
+        return ((data[idx] & 4095L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 16) & 140737488355327L;
+      case 48:
+        return ((data[idx] & 65535L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 3) & 140737488355327L;
+      case 61:
+        return ((data[idx] & 7L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 7) & 140737488355327L;
+      case 57:
+        return ((data[idx] & 127L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 11) & 140737488355327L;
+      case 53:
+        return ((data[idx] & 2047L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return ((data[idx] & 35184372088831L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 15) & 140737488355327L;
+      case 49:
+        return ((data[idx] & 32767L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return (data[idx] >>> 2) & 140737488355327L;
+      case 62:
+        return ((data[idx] & 3L) << 45) | (data[1+idx] >>> 19);
+      case 45:
+        return ((data[idx] & 524287L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 6) & 140737488355327L;
+      case 58:
+        return ((data[idx] & 63L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 10) & 140737488355327L;
+      case 54:
+        return ((data[idx] & 1023L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 14) & 140737488355327L;
+      case 50:
+        return ((data[idx] & 16383L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return (data[idx] >>> 1) & 140737488355327L;
+      case 63:
+        return ((data[idx] & 1L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 5) & 140737488355327L;
+      case 59:
+        return ((data[idx] & 31L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 9) & 140737488355327L;
+      case 55:
+        return ((data[idx] & 511L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 13) & 140737488355327L;
+      case 51:
+        return ((data[idx] & 8191L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return data[idx] & 140737488355327L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader48 extends Base {
+    public Reader48(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*48;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 16;
+      case 48:
+        return ((data[idx] & 65535L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return data[idx] & 281474976710655L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader49 extends Base {
+    public Reader49(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*49;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 15;
+      case 49:
+        return ((data[idx] & 32767L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return ((data[idx] & 35184372088831L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 11) & 562949953421311L;
+      case 53:
+        return ((data[idx] & 2047L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 7) & 562949953421311L;
+      case 57:
+        return ((data[idx] & 127L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 3) & 562949953421311L;
+      case 61:
+        return ((data[idx] & 7L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 14) & 562949953421311L;
+      case 50:
+        return ((data[idx] & 16383L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 10) & 562949953421311L;
+      case 54:
+        return ((data[idx] & 1023L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 6) & 562949953421311L;
+      case 58:
+        return ((data[idx] & 63L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return (data[idx] >>> 2) & 562949953421311L;
+      case 62:
+        return ((data[idx] & 3L) << 47) | (data[1+idx] >>> 17);
+      case 47:
+        return ((data[idx] & 131071L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return ((data[idx] & 140737488355327L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 13) & 562949953421311L;
+      case 51:
+        return ((data[idx] & 8191L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 9) & 562949953421311L;
+      case 55:
+        return ((data[idx] & 511L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 5) & 562949953421311L;
+      case 59:
+        return ((data[idx] & 31L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return (data[idx] >>> 1) & 562949953421311L;
+      case 63:
+        return ((data[idx] & 1L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 12) & 562949953421311L;
+      case 52:
+        return ((data[idx] & 4095L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 8) & 562949953421311L;
+      case 56:
+        return ((data[idx] & 255L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 4) & 562949953421311L;
+      case 60:
+        return ((data[idx] & 15L) << 45) | (data[1+idx] >>> 19);
+      case 45:
+        return ((data[idx] & 524287L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return data[idx] & 562949953421311L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader50 extends Base {
+    public Reader50(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*50;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 14;
+      case 50:
+        return ((data[idx] & 16383L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 6) & 1125899906842623L;
+      case 58:
+        return ((data[idx] & 63L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 12) & 1125899906842623L;
+      case 52:
+        return ((data[idx] & 4095L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 4) & 1125899906842623L;
+      case 60:
+        return ((data[idx] & 15L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 10) & 1125899906842623L;
+      case 54:
+        return ((data[idx] & 1023L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 2) & 1125899906842623L;
+      case 62:
+        return ((data[idx] & 3L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 8) & 1125899906842623L;
+      case 56:
+        return ((data[idx] & 255L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return data[idx] & 1125899906842623L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader51 extends Base {
+    public Reader51(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*51;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 13;
+      case 51:
+        return ((data[idx] & 8191L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return (data[idx] >>> 1) & 2251799813685247L;
+      case 63:
+        return ((data[idx] & 1L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return (data[idx] >>> 2) & 2251799813685247L;
+      case 62:
+        return ((data[idx] & 3L) << 49) | (data[1+idx] >>> 15);
+      case 49:
+        return ((data[idx] & 32767L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 3) & 2251799813685247L;
+      case 61:
+        return ((data[idx] & 7L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 4) & 2251799813685247L;
+      case 60:
+        return ((data[idx] & 15L) << 47) | (data[1+idx] >>> 17);
+      case 47:
+        return ((data[idx] & 131071L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 5) & 2251799813685247L;
+      case 59:
+        return ((data[idx] & 31L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 6) & 2251799813685247L;
+      case 58:
+        return ((data[idx] & 63L) << 45) | (data[1+idx] >>> 19);
+      case 45:
+        return ((data[idx] & 524287L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return ((data[idx] & 35184372088831L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 7) & 2251799813685247L;
+      case 57:
+        return ((data[idx] & 127L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 8) & 2251799813685247L;
+      case 56:
+        return ((data[idx] & 255L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return ((data[idx] & 140737488355327L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 9) & 2251799813685247L;
+      case 55:
+        return ((data[idx] & 511L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 10) & 2251799813685247L;
+      case 54:
+        return ((data[idx] & 1023L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return ((data[idx] & 562949953421311L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 11) & 2251799813685247L;
+      case 53:
+        return ((data[idx] & 2047L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 12) & 2251799813685247L;
+      case 52:
+        return ((data[idx] & 4095L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return data[idx] & 2251799813685247L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader52 extends Base {
+    public Reader52(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*52;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 12;
+      case 52:
+        return ((data[idx] & 4095L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 8) & 4503599627370495L;
+      case 56:
+        return ((data[idx] & 255L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 4) & 4503599627370495L;
+      case 60:
+        return ((data[idx] & 15L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return data[idx] & 4503599627370495L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader53 extends Base {
+    public Reader53(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*53;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 11;
+      case 53:
+        return ((data[idx] & 2047L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return (data[idx] >>> 2) & 9007199254740991L;
+      case 62:
+        return ((data[idx] & 3L) << 51) | (data[1+idx] >>> 13);
+      case 51:
+        return ((data[idx] & 8191L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 4) & 9007199254740991L;
+      case 60:
+        return ((data[idx] & 15L) << 49) | (data[1+idx] >>> 15);
+      case 49:
+        return ((data[idx] & 32767L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 6) & 9007199254740991L;
+      case 58:
+        return ((data[idx] & 63L) << 47) | (data[1+idx] >>> 17);
+      case 47:
+        return ((data[idx] & 131071L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 8) & 9007199254740991L;
+      case 56:
+        return ((data[idx] & 255L) << 45) | (data[1+idx] >>> 19);
+      case 45:
+        return ((data[idx] & 524287L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 10) & 9007199254740991L;
+      case 54:
+        return ((data[idx] & 1023L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return (data[idx] >>> 1) & 9007199254740991L;
+      case 63:
+        return ((data[idx] & 1L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return ((data[idx] & 35184372088831L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 3) & 9007199254740991L;
+      case 61:
+        return ((data[idx] & 7L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return ((data[idx] & 140737488355327L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 5) & 9007199254740991L;
+      case 59:
+        return ((data[idx] & 31L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return ((data[idx] & 562949953421311L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 7) & 9007199254740991L;
+      case 57:
+        return ((data[idx] & 127L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return ((data[idx] & 2251799813685247L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 9) & 9007199254740991L;
+      case 55:
+        return ((data[idx] & 511L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return data[idx] & 9007199254740991L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader54 extends Base {
+    public Reader54(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*54;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 10;
+      case 54:
+        return ((data[idx] & 1023L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 6) & 18014398509481983L;
+      case 58:
+        return ((data[idx] & 63L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 2) & 18014398509481983L;
+      case 62:
+        return ((data[idx] & 3L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 8) & 18014398509481983L;
+      case 56:
+        return ((data[idx] & 255L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 4) & 18014398509481983L;
+      case 60:
+        return ((data[idx] & 15L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return data[idx] & 18014398509481983L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader55 extends Base {
+    public Reader55(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*55;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 9;
+      case 55:
+        return ((data[idx] & 511L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return ((data[idx] & 35184372088831L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return ((data[idx] & 18014398509481983L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 8) & 36028797018963967L;
+      case 56:
+        return ((data[idx] & 255L) << 47) | (data[1+idx] >>> 17);
+      case 47:
+        return ((data[idx] & 131071L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return ((data[idx] & 9007199254740991L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 7) & 36028797018963967L;
+      case 57:
+        return ((data[idx] & 127L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 6) & 36028797018963967L;
+      case 58:
+        return ((data[idx] & 63L) << 49) | (data[1+idx] >>> 15);
+      case 49:
+        return ((data[idx] & 32767L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return ((data[idx] & 2251799813685247L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 5) & 36028797018963967L;
+      case 59:
+        return ((data[idx] & 31L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 4) & 36028797018963967L;
+      case 60:
+        return ((data[idx] & 15L) << 51) | (data[1+idx] >>> 13);
+      case 51:
+        return ((data[idx] & 8191L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return ((data[idx] & 562949953421311L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 3) & 36028797018963967L;
+      case 61:
+        return ((data[idx] & 7L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return (data[idx] >>> 2) & 36028797018963967L;
+      case 62:
+        return ((data[idx] & 3L) << 53) | (data[1+idx] >>> 11);
+      case 53:
+        return ((data[idx] & 2047L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return ((data[idx] & 140737488355327L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return (data[idx] >>> 1) & 36028797018963967L;
+      case 63:
+        return ((data[idx] & 1L) << 54) | (data[1+idx] >>> 10);
+      case 54:
+        return ((data[idx] & 1023L) << 45) | (data[1+idx] >>> 19);
+      case 45:
+        return ((data[idx] & 524287L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return data[idx] & 36028797018963967L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader56 extends Base {
+    public Reader56(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*56;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 8;
+      case 56:
+        return ((data[idx] & 255L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return data[idx] & 72057594037927935L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader57 extends Base {
+    public Reader57(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*57;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 7;
+      case 57:
+        return ((data[idx] & 127L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return ((data[idx] & 562949953421311L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return ((data[idx] & 72057594037927935L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 6) & 144115188075855871L;
+      case 58:
+        return ((data[idx] & 63L) << 51) | (data[1+idx] >>> 13);
+      case 51:
+        return ((data[idx] & 8191L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return ((data[idx] & 36028797018963967L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 5) & 144115188075855871L;
+      case 59:
+        return ((data[idx] & 31L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 45) | (data[1+idx] >>> 19);
+      case 45:
+        return ((data[idx] & 524287L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return ((data[idx] & 140737488355327L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return ((data[idx] & 18014398509481983L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 4) & 144115188075855871L;
+      case 60:
+        return ((data[idx] & 15L) << 53) | (data[1+idx] >>> 11);
+      case 53:
+        return ((data[idx] & 2047L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return ((data[idx] & 9007199254740991L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 3) & 144115188075855871L;
+      case 61:
+        return ((data[idx] & 7L) << 54) | (data[1+idx] >>> 10);
+      case 54:
+        return ((data[idx] & 1023L) << 47) | (data[1+idx] >>> 17);
+      case 47:
+        return ((data[idx] & 131071L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return ((data[idx] & 35184372088831L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return (data[idx] >>> 2) & 144115188075855871L;
+      case 62:
+        return ((data[idx] & 3L) << 55) | (data[1+idx] >>> 9);
+      case 55:
+        return ((data[idx] & 511L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return ((data[idx] & 2251799813685247L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return (data[idx] >>> 1) & 144115188075855871L;
+      case 63:
+        return ((data[idx] & 1L) << 56) | (data[1+idx] >>> 8);
+      case 56:
+        return ((data[idx] & 255L) << 49) | (data[1+idx] >>> 15);
+      case 49:
+        return ((data[idx] & 32767L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return data[idx] & 144115188075855871L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader58 extends Base {
+    public Reader58(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*58;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 6;
+      case 58:
+        return ((data[idx] & 63L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return ((data[idx] & 18014398509481983L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 2) & 288230376151711743L;
+      case 62:
+        return ((data[idx] & 3L) << 56) | (data[1+idx] >>> 8);
+      case 56:
+        return ((data[idx] & 255L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return ((data[idx] & 72057594037927935L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 4) & 288230376151711743L;
+      case 60:
+        return ((data[idx] & 15L) << 54) | (data[1+idx] >>> 10);
+      case 54:
+        return ((data[idx] & 1023L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return data[idx] & 288230376151711743L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader59 extends Base {
+    public Reader59(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*59;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 5;
+      case 59:
+        return ((data[idx] & 31L) << 54) | (data[1+idx] >>> 10);
+      case 54:
+        return ((data[idx] & 1023L) << 49) | (data[1+idx] >>> 15);
+      case 49:
+        return ((data[idx] & 32767L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return ((data[idx] & 35184372088831L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return ((data[idx] & 36028797018963967L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return (data[idx] >>> 1) & 576460752303423487L;
+      case 63:
+        return ((data[idx] & 1L) << 58) | (data[1+idx] >>> 6);
+      case 58:
+        return ((data[idx] & 63L) << 53) | (data[1+idx] >>> 11);
+      case 53:
+        return ((data[idx] & 2047L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return ((data[idx] & 2251799813685247L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return ((data[idx] & 72057594037927935L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return (data[idx] >>> 2) & 576460752303423487L;
+      case 62:
+        return ((data[idx] & 3L) << 57) | (data[1+idx] >>> 7);
+      case 57:
+        return ((data[idx] & 127L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 47) | (data[1+idx] >>> 17);
+      case 47:
+        return ((data[idx] & 131071L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return ((data[idx] & 140737488355327L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return ((data[idx] & 144115188075855871L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 3) & 576460752303423487L;
+      case 61:
+        return ((data[idx] & 7L) << 56) | (data[1+idx] >>> 8);
+      case 56:
+        return ((data[idx] & 255L) << 51) | (data[1+idx] >>> 13);
+      case 51:
+        return ((data[idx] & 8191L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return ((data[idx] & 9007199254740991L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return ((data[idx] & 288230376151711743L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 4) & 576460752303423487L;
+      case 60:
+        return ((data[idx] & 15L) << 55) | (data[1+idx] >>> 9);
+      case 55:
+        return ((data[idx] & 511L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 45) | (data[1+idx] >>> 19);
+      case 45:
+        return ((data[idx] & 524287L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return ((data[idx] & 562949953421311L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return ((data[idx] & 18014398509481983L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return data[idx] & 576460752303423487L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader60 extends Base {
+    public Reader60(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*60;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 4;
+      case 60:
+        return ((data[idx] & 15L) << 56) | (data[1+idx] >>> 8);
+      case 56:
+        return ((data[idx] & 255L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return ((data[idx] & 72057594037927935L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return data[idx] & 1152921504606846975L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader61 extends Base {
+    public Reader61(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*61;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 3;
+      case 61:
+        return ((data[idx] & 7L) << 58) | (data[1+idx] >>> 6);
+      case 58:
+        return ((data[idx] & 63L) << 55) | (data[1+idx] >>> 9);
+      case 55:
+        return ((data[idx] & 511L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 49) | (data[1+idx] >>> 15);
+      case 49:
+        return ((data[idx] & 32767L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return ((data[idx] & 35184372088831L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return ((data[idx] & 2251799813685247L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return ((data[idx] & 18014398509481983L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return ((data[idx] & 144115188075855871L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return ((data[idx] & 1152921504606846975L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return (data[idx] >>> 2) & 2305843009213693951L;
+      case 62:
+        return ((data[idx] & 3L) << 59) | (data[1+idx] >>> 5);
+      case 59:
+        return ((data[idx] & 31L) << 56) | (data[1+idx] >>> 8);
+      case 56:
+        return ((data[idx] & 255L) << 53) | (data[1+idx] >>> 11);
+      case 53:
+        return ((data[idx] & 2047L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 47) | (data[1+idx] >>> 17);
+      case 47:
+        return ((data[idx] & 131071L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return ((data[idx] & 140737488355327L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return ((data[idx] & 9007199254740991L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return ((data[idx] & 72057594037927935L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return ((data[idx] & 576460752303423487L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return (data[idx] >>> 1) & 2305843009213693951L;
+      case 63:
+        return ((data[idx] & 1L) << 60) | (data[1+idx] >>> 4);
+      case 60:
+        return ((data[idx] & 15L) << 57) | (data[1+idx] >>> 7);
+      case 57:
+        return ((data[idx] & 127L) << 54) | (data[1+idx] >>> 10);
+      case 54:
+        return ((data[idx] & 1023L) << 51) | (data[1+idx] >>> 13);
+      case 51:
+        return ((data[idx] & 8191L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 45) | (data[1+idx] >>> 19);
+      case 45:
+        return ((data[idx] & 524287L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return ((data[idx] & 562949953421311L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return ((data[idx] & 36028797018963967L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return ((data[idx] & 288230376151711743L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return data[idx] & 2305843009213693951L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader62 extends Base {
+    public Reader62(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*62;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 2;
+      case 62:
+        return ((data[idx] & 3L) << 60) | (data[1+idx] >>> 4);
+      case 60:
+        return ((data[idx] & 15L) << 58) | (data[1+idx] >>> 6);
+      case 58:
+        return ((data[idx] & 63L) << 56) | (data[1+idx] >>> 8);
+      case 56:
+        return ((data[idx] & 255L) << 54) | (data[1+idx] >>> 10);
+      case 54:
+        return ((data[idx] & 1023L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return ((data[idx] & 18014398509481983L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return ((data[idx] & 72057594037927935L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return ((data[idx] & 288230376151711743L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return ((data[idx] & 1152921504606846975L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return data[idx] & 4611686018427387903L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+  final static class Reader63 extends Base {
+    public Reader63(long[] data, long maxValue) {
+      super(data, maxValue);
+    }
+    public long get(int pos) {
+      final long bit = pos*63;
+      final int idx = (int) (bit>>6);
+      switch((int) (bit & 63)) {
+      case 0:
+        return data[idx] >>> 1;
+      case 63:
+        return ((data[idx] & 1L) << 62) | (data[1+idx] >>> 2);
+      case 62:
+        return ((data[idx] & 3L) << 61) | (data[1+idx] >>> 3);
+      case 61:
+        return ((data[idx] & 7L) << 60) | (data[1+idx] >>> 4);
+      case 60:
+        return ((data[idx] & 15L) << 59) | (data[1+idx] >>> 5);
+      case 59:
+        return ((data[idx] & 31L) << 58) | (data[1+idx] >>> 6);
+      case 58:
+        return ((data[idx] & 63L) << 57) | (data[1+idx] >>> 7);
+      case 57:
+        return ((data[idx] & 127L) << 56) | (data[1+idx] >>> 8);
+      case 56:
+        return ((data[idx] & 255L) << 55) | (data[1+idx] >>> 9);
+      case 55:
+        return ((data[idx] & 511L) << 54) | (data[1+idx] >>> 10);
+      case 54:
+        return ((data[idx] & 1023L) << 53) | (data[1+idx] >>> 11);
+      case 53:
+        return ((data[idx] & 2047L) << 52) | (data[1+idx] >>> 12);
+      case 52:
+        return ((data[idx] & 4095L) << 51) | (data[1+idx] >>> 13);
+      case 51:
+        return ((data[idx] & 8191L) << 50) | (data[1+idx] >>> 14);
+      case 50:
+        return ((data[idx] & 16383L) << 49) | (data[1+idx] >>> 15);
+      case 49:
+        return ((data[idx] & 32767L) << 48) | (data[1+idx] >>> 16);
+      case 48:
+        return ((data[idx] & 65535L) << 47) | (data[1+idx] >>> 17);
+      case 47:
+        return ((data[idx] & 131071L) << 46) | (data[1+idx] >>> 18);
+      case 46:
+        return ((data[idx] & 262143L) << 45) | (data[1+idx] >>> 19);
+      case 45:
+        return ((data[idx] & 524287L) << 44) | (data[1+idx] >>> 20);
+      case 44:
+        return ((data[idx] & 1048575L) << 43) | (data[1+idx] >>> 21);
+      case 43:
+        return ((data[idx] & 2097151L) << 42) | (data[1+idx] >>> 22);
+      case 42:
+        return ((data[idx] & 4194303L) << 41) | (data[1+idx] >>> 23);
+      case 41:
+        return ((data[idx] & 8388607L) << 40) | (data[1+idx] >>> 24);
+      case 40:
+        return ((data[idx] & 16777215L) << 39) | (data[1+idx] >>> 25);
+      case 39:
+        return ((data[idx] & 33554431L) << 38) | (data[1+idx] >>> 26);
+      case 38:
+        return ((data[idx] & 67108863L) << 37) | (data[1+idx] >>> 27);
+      case 37:
+        return ((data[idx] & 134217727L) << 36) | (data[1+idx] >>> 28);
+      case 36:
+        return ((data[idx] & 268435455L) << 35) | (data[1+idx] >>> 29);
+      case 35:
+        return ((data[idx] & 536870911L) << 34) | (data[1+idx] >>> 30);
+      case 34:
+        return ((data[idx] & 1073741823L) << 33) | (data[1+idx] >>> 31);
+      case 33:
+        return ((data[idx] & 2147483647L) << 32) | (data[1+idx] >>> 32);
+      case 32:
+        return ((data[idx] & 4294967295L) << 31) | (data[1+idx] >>> 33);
+      case 31:
+        return ((data[idx] & 8589934591L) << 30) | (data[1+idx] >>> 34);
+      case 30:
+        return ((data[idx] & 17179869183L) << 29) | (data[1+idx] >>> 35);
+      case 29:
+        return ((data[idx] & 34359738367L) << 28) | (data[1+idx] >>> 36);
+      case 28:
+        return ((data[idx] & 68719476735L) << 27) | (data[1+idx] >>> 37);
+      case 27:
+        return ((data[idx] & 137438953471L) << 26) | (data[1+idx] >>> 38);
+      case 26:
+        return ((data[idx] & 274877906943L) << 25) | (data[1+idx] >>> 39);
+      case 25:
+        return ((data[idx] & 549755813887L) << 24) | (data[1+idx] >>> 40);
+      case 24:
+        return ((data[idx] & 1099511627775L) << 23) | (data[1+idx] >>> 41);
+      case 23:
+        return ((data[idx] & 2199023255551L) << 22) | (data[1+idx] >>> 42);
+      case 22:
+        return ((data[idx] & 4398046511103L) << 21) | (data[1+idx] >>> 43);
+      case 21:
+        return ((data[idx] & 8796093022207L) << 20) | (data[1+idx] >>> 44);
+      case 20:
+        return ((data[idx] & 17592186044415L) << 19) | (data[1+idx] >>> 45);
+      case 19:
+        return ((data[idx] & 35184372088831L) << 18) | (data[1+idx] >>> 46);
+      case 18:
+        return ((data[idx] & 70368744177663L) << 17) | (data[1+idx] >>> 47);
+      case 17:
+        return ((data[idx] & 140737488355327L) << 16) | (data[1+idx] >>> 48);
+      case 16:
+        return ((data[idx] & 281474976710655L) << 15) | (data[1+idx] >>> 49);
+      case 15:
+        return ((data[idx] & 562949953421311L) << 14) | (data[1+idx] >>> 50);
+      case 14:
+        return ((data[idx] & 1125899906842623L) << 13) | (data[1+idx] >>> 51);
+      case 13:
+        return ((data[idx] & 2251799813685247L) << 12) | (data[1+idx] >>> 52);
+      case 12:
+        return ((data[idx] & 4503599627370495L) << 11) | (data[1+idx] >>> 53);
+      case 11:
+        return ((data[idx] & 9007199254740991L) << 10) | (data[1+idx] >>> 54);
+      case 10:
+        return ((data[idx] & 18014398509481983L) << 9) | (data[1+idx] >>> 55);
+      case 9:
+        return ((data[idx] & 36028797018963967L) << 8) | (data[1+idx] >>> 56);
+      case 8:
+        return ((data[idx] & 72057594037927935L) << 7) | (data[1+idx] >>> 57);
+      case 7:
+        return ((data[idx] & 144115188075855871L) << 6) | (data[1+idx] >>> 58);
+      case 6:
+        return ((data[idx] & 288230376151711743L) << 5) | (data[1+idx] >>> 59);
+      case 5:
+        return ((data[idx] & 576460752303423487L) << 4) | (data[1+idx] >>> 60);
+      case 4:
+        return ((data[idx] & 1152921504606846975L) << 3) | (data[1+idx] >>> 61);
+      case 3:
+        return ((data[idx] & 2305843009213693951L) << 2) | (data[1+idx] >>> 62);
+      case 2:
+        return ((data[idx] & 4611686018427387903L) << 1) | (data[1+idx] >>> 63);
+      case 1:
+        return data[idx] & 9223372036854775807L;
+      }
+
+      // unreachable, but compiler disagrees
+      return 0;
+    }
+  }
+}

Property changes on: src/java/org/apache/lucene/util/GenBitReaders.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/util/gen.py
===================================================================
--- src/java/org/apache/lucene/util/gen.py	(revision 0)
+++ src/java/org/apache/lucene/util/gen.py	(revision 0)
@@ -0,0 +1,116 @@
+import sys
+
+# usage: python gen.py > src/java/org/apache/lucene/util/GenBitReaders.java
+
+def gen():
+
+  print 'package org.apache.lucene.util;'
+
+  print '''
+/**
+ * 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.
+ */
+'''
+  print '// Autogenerated by gen.py DO NOT EDIT!'
+
+  print 'class GenBitReaders {'
+  print '  static abstract class Base extends PackedInts.Reader {'
+  print '    protected final long[] data;'
+  print '    protected Base(long[] data, long maxValue) {'
+  print '      super(maxValue);'
+  print '      this.data = data;'
+  print '    }'
+  print '    public long ramBytesUsed() {'
+  print '      return RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + data.length * RamUsageEstimator.NUM_BYTES_LONG;'
+  print '    }'
+  print '  }'
+  print
+
+  for nbits in range(1, 65):
+
+    if nbits in (8, 16, 32, 64):
+      # we have dedicated array readers for these cases
+      continue
+    
+    print '  final static class Reader%d extends Base {' % nbits
+    print '    public Reader%d(long[] data, long maxValue) {' % nbits
+    print '      super(data, maxValue);'
+    print '    }'
+    
+    print '    public long get(int pos) {'
+
+    print '      final long bit = pos*%s;' % nbits
+    print '      final int idx = (int) (bit>>6);'
+    print '      switch((int) (bit & 63)) {'
+
+    masks = []
+    v = 2
+    for j in range(nbits):
+      masks.append(v-1)
+      v *= 2
+
+    mask = (1<<nbits)-1;
+
+    d = set()
+    bit = 0
+    # enumerate all possible alignments
+    while True:
+      if bit in d:
+        break
+      d.add(bit)
+
+      print '      case %d:' % bit
+
+      # we pack high order bytes first
+      bitStart = 64 - bit
+
+      if bitStart >= nbits:
+        # not split
+        if bitStart == nbits:
+          # no shift needed, mask needed
+          print '        return data[idx] & %sL;' % mask
+        elif bitStart == 64:
+          # shift, but not mask, needed
+          print '        return data[idx] >>> %s;' % (bitStart-nbits)
+        else:
+          # shift & mask needed
+          print '        return (data[idx] >>> %s) & %sL;' % (bitStart-nbits, mask)
+      else:
+        # split
+        print '        return ((data[idx] & %sL) << %s) | (data[1+idx] >>> %d);' % \
+              (masks[bitStart-1], nbits-bitStart, 64-(nbits-bitStart))
+      bit = (bit + nbits) % 64
+      
+    print '      }'
+    print
+    print '      // unreachable, but compiler disagrees'
+    print '      return 0;'
+    print '    }'
+    print '  }'
+
+  print '}'
+
+  if False:
+    print
+    print
+    print
+    print '    switch(bitsPerValue) {'
+    for i in range(1, 65):
+      print '    case %d:' % i
+      print '      return new PackedBitReaders.Reader%d(data, maxValue);' % i
+    print '    }'
+
+gen()

Property changes on: src/java/org/apache/lucene/util/gen.py
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/util/BytesRef.java
===================================================================
--- src/java/org/apache/lucene/util/BytesRef.java	(revision 0)
+++ src/java/org/apache/lucene/util/BytesRef.java	(revision 0)
@@ -0,0 +1,170 @@
+package org.apache.lucene.util;
+
+/**
+ * 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.
+ */
+
+import java.io.UnsupportedEncodingException;
+
+// nocommit -- share w/ flex's TermRef
+public class BytesRef {
+
+  public byte[] bytes;
+  public int offset;
+  public int length;
+
+  public abstract static class Comparator {
+    abstract public int compare(BytesRef a, BytesRef b);
+  }
+
+  public BytesRef() {
+  }
+
+  /** Creates bytes ref, wrapping UTF8 bytes from the
+   *  provided string. */
+  public BytesRef(String s) {
+    try {
+      bytes = s.getBytes("UTF-8");
+    } catch (UnsupportedEncodingException uee) {
+      throw new RuntimeException(uee);
+    }
+    offset = 0;
+    length = bytes.length;
+  }
+
+  public BytesRef(BytesRef other) {
+    offset = 0;
+    length = other.length;
+    bytes = new byte[other.length];
+    System.arraycopy(other.bytes, other.offset, bytes, 0, length);
+  }
+
+  public boolean bytesEquals(BytesRef other) {
+    if (length == other.length) {
+      int upto = offset;
+      int otherUpto = other.offset;
+      final byte[] otherBytes = other.bytes;
+      for(int i=0;i<length;i++) {
+        if (bytes[upto++] != otherBytes[otherUpto++]) {
+          return false;
+        }
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public String utf8ToString() {
+    try {
+      return new String(bytes, offset, length, "UTF8");
+    } catch (java.io.UnsupportedEncodingException uee) {
+      throw new RuntimeException(uee);
+    }
+  }
+
+  private final static Comparator straightComparator = new StraightComparator();
+
+  public static Comparator getStraightComparator() {
+    return straightComparator;
+  }
+
+  public static class StraightComparator extends Comparator {
+    public int compare(BytesRef a, BytesRef b) {
+      int aUpto = a.offset;
+      int bUpto = b.offset;
+      final int aStop;
+      if (a.length <= b.length) {
+        aStop = aUpto + a.length;
+      } else {
+        aStop = aUpto + b.length;
+      }
+      while(aUpto < aStop) {
+        final int cmp = a.bytes[aUpto++] - b.bytes[bUpto++];
+        if (cmp != 0) {
+          return cmp;
+        }
+      }
+      return a.length - b.length;
+    }
+  }
+
+  private final static Comparator utf8SortedAsUTF16SortOrder = new UTF8SortedAsUTF16Comparator();
+
+  public static Comparator getUTF8SortedAsUTF16Comparator() {
+    return utf8SortedAsUTF16SortOrder;
+  }
+
+  public static class UTF8SortedAsUTF16Comparator extends Comparator {
+    public int compare(BytesRef a, BytesRef b) {
+
+      final byte[] aBytes = a.bytes;
+      int aUpto = a.offset;
+      final byte[] bBytes = b.bytes;
+      int bUpto = b.offset;
+
+      final int aStop;
+      if (a.length < b.length) {
+        aStop = aUpto + a.length;
+      } else {
+        aStop = aUpto + b.length;
+      }
+
+      while(aUpto < aStop) {
+        int aByte = aBytes[aUpto++] & 0xff;
+        int bByte = bBytes[bUpto++] & 0xff;
+
+        if (aByte != bByte) {
+          // See http://icu-project.org/docs/papers/utf16_code_point_order.html#utf-8-in-utf-16-order
+          // We know the terms are not equal, but, we may
+          // have to carefully fixup the bytes at the
+          // difference to match UTF16's sort order:
+          if (aByte >= 0xee && bByte >= 0xee) {
+            if ((aByte & 0xfe) == 0xee) {
+              aByte += 0x10;
+            }
+            if ((bByte&0xfe) == 0xee) {
+              bByte += 0x10;
+            }
+          }
+          return aByte - bByte;
+        }
+      }
+
+      // One is a prefix of the other, or, they are equal:
+      return a.length - b.length;
+    }
+  }
+
+  // nocommit -- kinda hackish?  needed only (so far) for FieldComparator
+  private static class ComparableBytesRef implements Comparable {
+    private final BytesRef b;
+    private final Comparator c;
+    public ComparableBytesRef(BytesRef b, Comparator c) {
+      this.b = b;
+      this.c = c;
+    }
+
+    public int compareTo(Object other) {
+      final ComparableBytesRef o = (ComparableBytesRef) other;
+      return c.compare(b, o.b);
+    }
+  }
+
+  public static Comparable getComparableBytesRef(BytesRef b, Comparator c) {
+    return new ComparableBytesRef(b, c);
+  }
+}

Property changes on: src/java/org/apache/lucene/util/BytesRef.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/util/RamUsageEstimator.java
===================================================================
--- src/java/org/apache/lucene/util/RamUsageEstimator.java	(revision 900008)
+++ src/java/org/apache/lucene/util/RamUsageEstimator.java	(working copy)
@@ -35,6 +35,16 @@
  * estimate is complete.
  */
 public final class RamUsageEstimator {
+
+  public static int NUM_BYTES_SHORT = 2;
+  public static int NUM_BYTES_INT = 4;
+  public static int NUM_BYTES_LONG = 8;
+  public static int NUM_BYTES_FLOAT = 4;
+  public static int NUM_BYTES_DOUBLE = 8;
+  public static int NUM_BYTES_OBJ_HEADER = 8;
+  public static int NUM_BYTES_OBJ_REF = Constants.JRE_IS_64BIT ? 8 : 4;
+  public static int NUM_BYTES_ARRAY_HEADER = NUM_BYTES_OBJ_HEADER + NUM_BYTES_INT + NUM_BYTES_OBJ_REF;
+
   private MemoryModel memoryModel;
 
   private final Map<Object,Object> seen;
Index: src/java/org/apache/lucene/util/ConsumesRAM.java
===================================================================
--- src/java/org/apache/lucene/util/ConsumesRAM.java	(revision 0)
+++ src/java/org/apache/lucene/util/ConsumesRAM.java	(revision 0)
@@ -0,0 +1,22 @@
+package org.apache.lucene.util;
+
+/**
+ * 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.
+ */
+
+public interface ConsumesRAM {
+  public long ramBytesUsed();
+}

Property changes on: src/java/org/apache/lucene/util/ConsumesRAM.java
___________________________________________________________________
Added: svn:eol-style
   + native

Index: src/java/org/apache/lucene/document/AbstractField.java
===================================================================
--- src/java/org/apache/lucene/document/AbstractField.java	(revision 900008)
+++ src/java/org/apache/lucene/document/AbstractField.java	(working copy)
@@ -19,6 +19,7 @@
 import org.apache.lucene.search.spans.SpanQuery; // for javadocs
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.util.StringHelper; // for javadocs
+import org.apache.lucene.util.BytesRef;
 
 
 /**
@@ -234,6 +235,57 @@
     return lazy;
   }
 
+
+  /** Controls whether per-field values are stored into
+   *  index.  This storage is non-sparse, so it's best to
+   *  use this when all docs have the field, and loads all
+   *  values into RAM, exposing a random access API, when
+   *  loaded.
+   *
+   * <p><b>NOTE</b>: This feature is experimental and the
+   * API is free to change in non-backwards-compatible ways.  */
+  public static enum Values {
+
+    /** Integral value is stored as packed ints.  The bit
+     *  precision is fixed across the segment, and
+     *  determined by the min/max values in the field. */
+    PACKED_INTS,
+    PACKED_INTS_FIXED,
+    SIMPLE_FLOAT_4BYTE,
+    SIMPLE_FLOAT_8BYTE,
+
+    // nocommit -- shouldn't lucene decide/detect straight vs
+    // deref, as well fixed vs var?
+    BYTES_FIXED_STRAIGHT,
+    BYTES_FIXED_DEREF,
+    BYTES_FIXED_SORTED,
+
+    BYTES_VAR_STRAIGHT,
+    BYTES_VAR_DEREF,
+    BYTES_VAR_SORTED
+
+    // nocommit -- need STRING variants as well
+  }
+
+  Values values;
+  public void setIndexValues(Values values) {
+    this.values = values;
+  }
+
+  public Values getIndexValues() {
+    return values;
+  }
+
+  private BytesRef.Comparator bytesComparator;
+
+  public void setBytesComparator(BytesRef.Comparator c) {
+    this.bytesComparator = c;
+  }
+    
+  public BytesRef.Comparator getBytesComparator() {
+    return bytesComparator;
+  }
+  
   /** Prints a Field for human consumption. */
   @Override
   public final String toString() {
@@ -280,6 +332,9 @@
     if (lazy){
       result.append(",lazy");
     }
+    if (values != null) {
+      result.append(",values=" + values);
+    }
     result.append('<');
     result.append(name);
     result.append(':');
Index: contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/SearchWithSortTask.java
===================================================================
--- contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/SearchWithSortTask.java	(revision 900008)
+++ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/SearchWithSortTask.java	(working copy)
@@ -19,6 +19,7 @@
 import org.apache.lucene.benchmark.byTask.PerfRunData;
 import org.apache.lucene.benchmark.byTask.feeds.QueryMaker;
 import org.apache.lucene.search.Sort;
+import org.apache.lucene.search.FieldComparatorSource;
 import org.apache.lucene.search.SortField;
 
 /**
@@ -75,8 +76,7 @@
         } else {
           throw new RuntimeException("You must specify the sort type ie page:int,subject:string");
         }
-        int type = getType(typeString);
-        sortField0 = new SortField(fieldName, type);
+        sortField0 = getSortField(fieldName, typeString);
       }
       sortFields[upto++] = sortField0;
     }
@@ -89,10 +89,24 @@
     this.sort = new Sort(sortFields);
   }
 
-  private int getType(String typeString) {
-    int type;
-    if (typeString.equals("float")) {
+  private SortField getSortField(String fieldName, String typeString) {
+    boolean useIndexValues = false;
+    int type = -1;
+
+    if (typeString.equals("intvalues")) {
+      useIndexValues = true;
+      type = SortField.INT;
+    } else if (typeString.equals("floatvalues")) {
+      useIndexValues = true;
       type = SortField.FLOAT;
+    } else if (typeString.equals("stringvalues")) {
+      useIndexValues = true;
+      type = SortField.STRING;
+    } else if (typeString.equals("bytesvalues")) {
+      useIndexValues = true;
+      type = SortField.BYTES;
+    } else if (typeString.equals("float")) {
+      type = SortField.FLOAT;
     } else if (typeString.equals("double")) {
       type = SortField.DOUBLE;
     } else if (typeString.equals("byte")) {
@@ -110,7 +124,10 @@
     } else {
       throw new RuntimeException("Unrecognized sort field type " + typeString);
     }
-    return type;
+
+    SortField f = new SortField(fieldName, type);
+    f.setUseIndexValues(useIndexValues);
+    return f;
   }
 
   @Override
Index: contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTask.java
===================================================================
--- contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTask.java	(revision 900008)
+++ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/tasks/ReadTask.java	(working copy)
@@ -131,7 +131,7 @@
           for(int i=0;i<hits.scoreDocs.length;i++) {
             final int docID = hits.scoreDocs[i].doc;
             final Document doc = reader.document(docID);
-            System.out.println("  " + i + ": doc=" + docID + " score=" + hits.scoreDocs[i].score + " " + printHitsField + " =" + doc.get(printHitsField));
+            System.out.println("  " + i + ": doc=" + docID + " score=" + hits.scoreDocs[i].score + " " + printHitsField + "=" + doc.get(printHitsField));
           }
         }
 
Index: contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/DocMaker.java
===================================================================
--- contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/DocMaker.java	(revision 900008)
+++ contrib/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/DocMaker.java	(working copy)
@@ -95,9 +95,19 @@
         
         // Initialize the map with the default fields.
         fields.put(BODY_FIELD, new Field(BODY_FIELD, "", bodyStore, bodyIndex, termVector));
-        fields.put(TITLE_FIELD, new Field(TITLE_FIELD, "", store, index, termVector));
+        final Field f = new Field(TITLE_FIELD, "", store, index, termVector);
+        // nocommit need explicit per-field control
+        if (store == Field.Store.YES) {
+          f.setIndexValues(Field.Values.BYTES_VAR_SORTED);
+        }
+        fields.put(TITLE_FIELD, f);
         fields.put(DATE_FIELD, new Field(DATE_FIELD, "", store, index, termVector));
-        fields.put(ID_FIELD, new Field(ID_FIELD, "", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS));
+        final Field f2 = new Field(ID_FIELD, "", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS);
+        // nocommit need explicit per-field control
+        if (store == Field.Store.YES) {
+          f2.setIndexValues(Field.Values.BYTES_VAR_SORTED);
+        }
+        fields.put(ID_FIELD, f2);
         fields.put(NAME_FIELD, new Field(NAME_FIELD, "", store, index, termVector));
         
         doc = new Document();
@@ -114,12 +124,29 @@
      */
     Field getField(String name, Store store, Index index, TermVector termVector) {
       if (!reuseFields) {
-        return new Field(name, "", store, index, termVector);
+        final Field f = new Field(name, "", store, index, termVector);
+        if (store == Field.Store.YES) {
+          // nocommit need explicit per-field control
+          if (name.equals("sort_field")) {
+            f.setIndexValues(Field.Values.PACKED_INTS_FIXED);
+          } else {
+            f.setIndexValues(Field.Values.BYTES_VAR_SORTED);
+          }
+        }
+        return f;
       }
       
       Field f = fields.get(name);
       if (f == null) {
         f = new Field(name, "", store, index, termVector);
+        if (store == Field.Store.YES) {
+          // nocommit need explicit per-field control
+          if (name.equals("sort_field")) {
+            f.setIndexValues(Field.Values.PACKED_INTS_FIXED);
+          } else {
+            f.setIndexValues(Field.Values.BYTES_VAR_SORTED);
+          }
+        }
         fields.put(name, f);
       }
       return f;
@@ -235,7 +262,7 @@
       }
     }
     
-    //System.out.println("============== Created doc "+numDocsCreated+" :\n"+doc+"\n==========");
+    // System.out.println("============== Created doc "+numDocsCreated+" :\n"+doc+"\n==========");
     return doc;
   }