lucene/core/src/java/org/apache/lucene/util/packed/Packed64SingleBlock.java - lucene-solr - Git at Google

 // This file has been automatically generated, DO NOT EDIT

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements. See the NOTICE file distributed with this
  * work for additional information regarding copyright ownership. The ASF
  * licenses this file to You under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  */
 package org.apache.lucene.util.packed;

 import java.io.IOException;
 import java.util.Arrays;

 import org.apache.lucene.store.DataInput;
 import org.apache.lucene.util.RamUsageEstimator;

 /**
  * This class is similar to {@link Packed64} except that it trades space for
  * speed by ensuring that a single block needs to be read/written in order to
  * read/write a value.
  */
 abstract class Packed64SingleBlock extends PackedInts.MutableImpl {

   public static final int MAX_SUPPORTED_BITS_PER_VALUE = 32;
   private static final int[] SUPPORTED_BITS_PER_VALUE = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16, 21, 32};

   public static boolean isSupported(int bitsPerValue) {
     return Arrays.binarySearch(SUPPORTED_BITS_PER_VALUE, bitsPerValue) >= 0;
   }

   private static int requiredCapacity(int valueCount, int valuesPerBlock) {
     return valueCount / valuesPerBlock
         + (valueCount % valuesPerBlock == 0 ? 0 : 1);
   }

   final long[] blocks;

   Packed64SingleBlock(int valueCount, int bitsPerValue) {
     super(valueCount, bitsPerValue);
     assert isSupported(bitsPerValue);
     final int valuesPerBlock = 64 / bitsPerValue;
     blocks = new long[requiredCapacity(valueCount, valuesPerBlock)];
   }

   @Override
   public void clear() {
     Arrays.fill(blocks, 0L);
   }

   @Override
   public long ramBytesUsed() {
     return RamUsageEstimator.alignObjectSize(
         RamUsageEstimator.NUM_BYTES_OBJECT_HEADER
         + 2 * Integer.BYTES                       // valueCount,bitsPerValue
         + RamUsageEstimator.NUM_BYTES_OBJECT_REF) // blocks ref
         + RamUsageEstimator.sizeOf(blocks);
   }

   @Override
   public int get(int index, long[] arr, int off, int len) {
     assert len > 0 : "len must be > 0 (got " + len + ")";
     assert index >= 0 && index < valueCount;
     len = Math.min(len, valueCount - index);
     assert off + len <= arr.length;

     final int originalIndex = index;

     // go to the next block boundary
     final int valuesPerBlock = 64 / bitsPerValue;
     final int offsetInBlock = index % valuesPerBlock;
     if (offsetInBlock != 0) {
       for (int i = offsetInBlock; i < valuesPerBlock && len > 0; ++i) {
         arr[off++] = get(index++);
         --len;
       }
       if (len == 0) {
         return index - originalIndex;
       }
     }

     // bulk get
     assert index % valuesPerBlock == 0;
     final PackedInts.Decoder decoder = BulkOperation.of(PackedInts.Format.PACKED_SINGLE_BLOCK, bitsPerValue);
     assert decoder.longBlockCount() == 1;
     assert decoder.longValueCount() == valuesPerBlock;
     final int blockIndex = index / valuesPerBlock;
     final int nblocks = (index + len) / valuesPerBlock - blockIndex;
     decoder.decode(blocks, blockIndex, arr, off, nblocks);
     final int diff = nblocks * valuesPerBlock;
     index += diff; len -= diff;

     if (index > originalIndex) {
       // stay at the block boundary
       return index - originalIndex;
     } else {
       // no progress so far => already at a block boundary but no full block to
       // get
       assert index == originalIndex;
       return super.get(index, arr, off, len);
     }
   }

   @Override
   public int set(int index, long[] arr, int off, int len) {
     assert len > 0 : "len must be > 0 (got " + len + ")";
     assert index >= 0 && index < valueCount;
     len = Math.min(len, valueCount - index);
     assert off + len <= arr.length;

     final int originalIndex = index;

     // go to the next block boundary
     final int valuesPerBlock = 64 / bitsPerValue;
     final int offsetInBlock = index % valuesPerBlock;
     if (offsetInBlock != 0) {
       for (int i = offsetInBlock; i < valuesPerBlock && len > 0; ++i) {
         set(index++, arr[off++]);
         --len;
       }
       if (len == 0) {
         return index - originalIndex;
       }
     }

     // bulk set
     assert index % valuesPerBlock == 0;
     final BulkOperation op = BulkOperation.of(PackedInts.Format.PACKED_SINGLE_BLOCK, bitsPerValue);
     assert op.longBlockCount() == 1;
     assert op.longValueCount() == valuesPerBlock;
     final int blockIndex = index / valuesPerBlock;
     final int nblocks = (index + len) / valuesPerBlock - blockIndex;
     op.encode(arr, off, blocks, blockIndex, nblocks);
     final int diff = nblocks * valuesPerBlock;
     index += diff; len -= diff;

     if (index > originalIndex) {
       // stay at the block boundary
       return index - originalIndex;
     } else {
       // no progress so far => already at a block boundary but no full block to
       // set
       assert index == originalIndex;
       return super.set(index, arr, off, len);
     }
   }

   @Override
   public void fill(int fromIndex, int toIndex, long val) {
     assert fromIndex >= 0;
     assert fromIndex <= toIndex;
     assert PackedInts.unsignedBitsRequired(val) <= bitsPerValue;

     final int valuesPerBlock = 64 / bitsPerValue;
     if (toIndex - fromIndex <= valuesPerBlock << 1) {
       // there needs to be at least one full block to set for the block
       // approach to be worth trying
       super.fill(fromIndex, toIndex, val);
       return;
     }

     // set values naively until the next block start
     int fromOffsetInBlock = fromIndex % valuesPerBlock;
     if (fromOffsetInBlock != 0) {
       for (int i = fromOffsetInBlock; i < valuesPerBlock; ++i) {
         set(fromIndex++, val);
       }
       assert fromIndex % valuesPerBlock == 0;
     }

     // bulk set of the inner blocks
     final int fromBlock = fromIndex / valuesPerBlock;
     final int toBlock = toIndex / valuesPerBlock;
     assert fromBlock * valuesPerBlock == fromIndex;

     long blockValue = 0L;
     for (int i = 0; i < valuesPerBlock; ++i) {
       blockValue = blockValue | (val << (i * bitsPerValue));
     }
     Arrays.fill(blocks, fromBlock, toBlock, blockValue);

     // fill the gap
     for (int i = valuesPerBlock * toBlock; i < toIndex; ++i) {
       set(i, val);
     }
   }

   @Override
   protected PackedInts.Format getFormat() {
     return PackedInts.Format.PACKED_SINGLE_BLOCK;
   }

   @Override
   public String toString() {
     return getClass().getSimpleName() + "(bitsPerValue=" + bitsPerValue
         + ",size=" + size() + ",blocks=" + blocks.length + ")";
   }

   public static Packed64SingleBlock create(DataInput in,
       int valueCount, int bitsPerValue) throws IOException {
     Packed64SingleBlock reader = create(valueCount, bitsPerValue);
     for (int i = 0; i < reader.blocks.length; ++i) {
       reader.blocks[i] = in.readLong();
     }
     return reader;
   }

   public static Packed64SingleBlock create(int valueCount, int bitsPerValue) {
     switch (bitsPerValue) {
       case 1:
         return new Packed64SingleBlock1(valueCount);
       case 2:
         return new Packed64SingleBlock2(valueCount);
       case 3:
         return new Packed64SingleBlock3(valueCount);
       case 4:
         return new Packed64SingleBlock4(valueCount);
       case 5:
         return new Packed64SingleBlock5(valueCount);
       case 6:
         return new Packed64SingleBlock6(valueCount);
       case 7:
         return new Packed64SingleBlock7(valueCount);
       case 8:
         return new Packed64SingleBlock8(valueCount);
       case 9:
         return new Packed64SingleBlock9(valueCount);
       case 10:
         return new Packed64SingleBlock10(valueCount);
       case 12:
         return new Packed64SingleBlock12(valueCount);
       case 16:
         return new Packed64SingleBlock16(valueCount);
       case 21:
         return new Packed64SingleBlock21(valueCount);
       case 32:
         return new Packed64SingleBlock32(valueCount);
       default:
         throw new IllegalArgumentException("Unsupported number of bits per value: " + 32);
     }
   }

   static class Packed64SingleBlock1 extends Packed64SingleBlock {

     Packed64SingleBlock1(int valueCount) {
       super(valueCount, 1);
     }

     @Override
     public long get(int index) {
       final int o = index >>> 6;
       final int b = index & 63;
       final int shift = b << 0;
       return (blocks[o] >>> shift) & 1L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index >>> 6;
       final int b = index & 63;
       final int shift = b << 0;
       blocks[o] = (blocks[o] & ~(1L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock2 extends Packed64SingleBlock {

     Packed64SingleBlock2(int valueCount) {
       super(valueCount, 2);
     }

     @Override
     public long get(int index) {
       final int o = index >>> 5;
       final int b = index & 31;
       final int shift = b << 1;
       return (blocks[o] >>> shift) & 3L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index >>> 5;
       final int b = index & 31;
       final int shift = b << 1;
       blocks[o] = (blocks[o] & ~(3L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock3 extends Packed64SingleBlock {

     Packed64SingleBlock3(int valueCount) {
       super(valueCount, 3);
     }

     @Override
     public long get(int index) {
       final int o = index / 21;
       final int b = index % 21;
       final int shift = b * 3;
       return (blocks[o] >>> shift) & 7L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index / 21;
       final int b = index % 21;
       final int shift = b * 3;
       blocks[o] = (blocks[o] & ~(7L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock4 extends Packed64SingleBlock {

     Packed64SingleBlock4(int valueCount) {
       super(valueCount, 4);
     }

     @Override
     public long get(int index) {
       final int o = index >>> 4;
       final int b = index & 15;
       final int shift = b << 2;
       return (blocks[o] >>> shift) & 15L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index >>> 4;
       final int b = index & 15;
       final int shift = b << 2;
       blocks[o] = (blocks[o] & ~(15L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock5 extends Packed64SingleBlock {

     Packed64SingleBlock5(int valueCount) {
       super(valueCount, 5);
     }

     @Override
     public long get(int index) {
       final int o = index / 12;
       final int b = index % 12;
       final int shift = b * 5;
       return (blocks[o] >>> shift) & 31L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index / 12;
       final int b = index % 12;
       final int shift = b * 5;
       blocks[o] = (blocks[o] & ~(31L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock6 extends Packed64SingleBlock {

     Packed64SingleBlock6(int valueCount) {
       super(valueCount, 6);
     }

     @Override
     public long get(int index) {
       final int o = index / 10;
       final int b = index % 10;
       final int shift = b * 6;
       return (blocks[o] >>> shift) & 63L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index / 10;
       final int b = index % 10;
       final int shift = b * 6;
       blocks[o] = (blocks[o] & ~(63L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock7 extends Packed64SingleBlock {

     Packed64SingleBlock7(int valueCount) {
       super(valueCount, 7);
     }

     @Override
     public long get(int index) {
       final int o = index / 9;
       final int b = index % 9;
       final int shift = b * 7;
       return (blocks[o] >>> shift) & 127L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index / 9;
       final int b = index % 9;
       final int shift = b * 7;
       blocks[o] = (blocks[o] & ~(127L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock8 extends Packed64SingleBlock {

     Packed64SingleBlock8(int valueCount) {
       super(valueCount, 8);
     }

     @Override
     public long get(int index) {
       final int o = index >>> 3;
       final int b = index & 7;
       final int shift = b << 3;
       return (blocks[o] >>> shift) & 255L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index >>> 3;
       final int b = index & 7;
       final int shift = b << 3;
       blocks[o] = (blocks[o] & ~(255L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock9 extends Packed64SingleBlock {

     Packed64SingleBlock9(int valueCount) {
       super(valueCount, 9);
     }

     @Override
     public long get(int index) {
       final int o = index / 7;
       final int b = index % 7;
       final int shift = b * 9;
       return (blocks[o] >>> shift) & 511L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index / 7;
       final int b = index % 7;
       final int shift = b * 9;
       blocks[o] = (blocks[o] & ~(511L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock10 extends Packed64SingleBlock {

     Packed64SingleBlock10(int valueCount) {
       super(valueCount, 10);
     }

     @Override
     public long get(int index) {
       final int o = index / 6;
       final int b = index % 6;
       final int shift = b * 10;
       return (blocks[o] >>> shift) & 1023L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index / 6;
       final int b = index % 6;
       final int shift = b * 10;
       blocks[o] = (blocks[o] & ~(1023L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock12 extends Packed64SingleBlock {

     Packed64SingleBlock12(int valueCount) {
       super(valueCount, 12);
     }

     @Override
     public long get(int index) {
       final int o = index / 5;
       final int b = index % 5;
       final int shift = b * 12;
       return (blocks[o] >>> shift) & 4095L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index / 5;
       final int b = index % 5;
       final int shift = b * 12;
       blocks[o] = (blocks[o] & ~(4095L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock16 extends Packed64SingleBlock {

     Packed64SingleBlock16(int valueCount) {
       super(valueCount, 16);
     }

     @Override
     public long get(int index) {
       final int o = index >>> 2;
       final int b = index & 3;
       final int shift = b << 4;
       return (blocks[o] >>> shift) & 65535L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index >>> 2;
       final int b = index & 3;
       final int shift = b << 4;
       blocks[o] = (blocks[o] & ~(65535L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock21 extends Packed64SingleBlock {

     Packed64SingleBlock21(int valueCount) {
       super(valueCount, 21);
     }

     @Override
     public long get(int index) {
       final int o = index / 3;
       final int b = index % 3;
       final int shift = b * 21;
       return (blocks[o] >>> shift) & 2097151L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index / 3;
       final int b = index % 3;
       final int shift = b * 21;
       blocks[o] = (blocks[o] & ~(2097151L << shift)) | (value << shift);
     }

   }

   static class Packed64SingleBlock32 extends Packed64SingleBlock {

     Packed64SingleBlock32(int valueCount) {
       super(valueCount, 32);
     }

     @Override
     public long get(int index) {
       final int o = index >>> 1;
       final int b = index & 1;
       final int shift = b << 5;
       return (blocks[o] >>> shift) & 4294967295L;
     }

     @Override
     public void set(int index, long value) {
       final int o = index >>> 1;
       final int b = index & 1;
       final int shift = b << 5;
       blocks[o] = (blocks[o] & ~(4294967295L << shift)) | (value << shift);
     }

   }

 }
	// This file has been automatically generated, DO NOT EDIT

	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with this
	* work for additional information regarding copyright ownership. The ASF
	* licenses this file to You under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	* License for the specific language governing permissions and limitations under
	* the License.
	*/
	package org.apache.lucene.util.packed;

	import java.io.IOException;
	import java.util.Arrays;

	import org.apache.lucene.store.DataInput;
	import org.apache.lucene.util.RamUsageEstimator;

	/**
	* This class is similar to {@link Packed64} except that it trades space for
	* speed by ensuring that a single block needs to be read/written in order to
	* read/write a value.
	*/
	abstract class Packed64SingleBlock extends PackedInts.MutableImpl {

	public static final int MAX_SUPPORTED_BITS_PER_VALUE = 32;
	private static final int[] SUPPORTED_BITS_PER_VALUE = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16, 21, 32};

	public static boolean isSupported(int bitsPerValue) {
	return Arrays.binarySearch(SUPPORTED_BITS_PER_VALUE, bitsPerValue) >= 0;
	}

	private static int requiredCapacity(int valueCount, int valuesPerBlock) {
	return valueCount / valuesPerBlock
	+ (valueCount % valuesPerBlock == 0 ? 0 : 1);
	}

	final long[] blocks;

	Packed64SingleBlock(int valueCount, int bitsPerValue) {
	super(valueCount, bitsPerValue);
	assert isSupported(bitsPerValue);
	final int valuesPerBlock = 64 / bitsPerValue;
	blocks = new long[requiredCapacity(valueCount, valuesPerBlock)];
	}

	@Override
	public void clear() {
	Arrays.fill(blocks, 0L);
	}

	@Override
	public long ramBytesUsed() {
	return RamUsageEstimator.alignObjectSize(
	RamUsageEstimator.NUM_BYTES_OBJECT_HEADER
	+ 2 * Integer.BYTES // valueCount,bitsPerValue
	+ RamUsageEstimator.NUM_BYTES_OBJECT_REF) // blocks ref
	+ RamUsageEstimator.sizeOf(blocks);
	}

	@Override
	public int get(int index, long[] arr, int off, int len) {
	assert len > 0 : "len must be > 0 (got " + len + ")";
	assert index >= 0 && index < valueCount;
	len = Math.min(len, valueCount - index);
	assert off + len <= arr.length;

	final int originalIndex = index;

	// go to the next block boundary
	final int valuesPerBlock = 64 / bitsPerValue;
	final int offsetInBlock = index % valuesPerBlock;
	if (offsetInBlock != 0) {
	for (int i = offsetInBlock; i < valuesPerBlock && len > 0; ++i) {
	arr[off++] = get(index++);
	--len;
	}
	if (len == 0) {
	return index - originalIndex;
	}
	}

	// bulk get
	assert index % valuesPerBlock == 0;
	final PackedInts.Decoder decoder = BulkOperation.of(PackedInts.Format.PACKED_SINGLE_BLOCK, bitsPerValue);
	assert decoder.longBlockCount() == 1;
	assert decoder.longValueCount() == valuesPerBlock;
	final int blockIndex = index / valuesPerBlock;
	final int nblocks = (index + len) / valuesPerBlock - blockIndex;
	decoder.decode(blocks, blockIndex, arr, off, nblocks);
	final int diff = nblocks * valuesPerBlock;
	index += diff; len -= diff;

	if (index > originalIndex) {
	// stay at the block boundary
	return index - originalIndex;
	} else {
	// no progress so far => already at a block boundary but no full block to
	// get
	assert index == originalIndex;
	return super.get(index, arr, off, len);
	}
	}

	@Override
	public int set(int index, long[] arr, int off, int len) {
	assert len > 0 : "len must be > 0 (got " + len + ")";
	assert index >= 0 && index < valueCount;
	len = Math.min(len, valueCount - index);
	assert off + len <= arr.length;

	final int originalIndex = index;

	// go to the next block boundary
	final int valuesPerBlock = 64 / bitsPerValue;
	final int offsetInBlock = index % valuesPerBlock;
	if (offsetInBlock != 0) {
	for (int i = offsetInBlock; i < valuesPerBlock && len > 0; ++i) {
	set(index++, arr[off++]);
	--len;
	}
	if (len == 0) {
	return index - originalIndex;
	}
	}

	// bulk set
	assert index % valuesPerBlock == 0;
	final BulkOperation op = BulkOperation.of(PackedInts.Format.PACKED_SINGLE_BLOCK, bitsPerValue);
	assert op.longBlockCount() == 1;
	assert op.longValueCount() == valuesPerBlock;
	final int blockIndex = index / valuesPerBlock;
	final int nblocks = (index + len) / valuesPerBlock - blockIndex;
	op.encode(arr, off, blocks, blockIndex, nblocks);
	final int diff = nblocks * valuesPerBlock;
	index += diff; len -= diff;

	if (index > originalIndex) {
	// stay at the block boundary
	return index - originalIndex;
	} else {
	// no progress so far => already at a block boundary but no full block to
	// set
	assert index == originalIndex;
	return super.set(index, arr, off, len);
	}
	}

	@Override
	public void fill(int fromIndex, int toIndex, long val) {
	assert fromIndex >= 0;
	assert fromIndex <= toIndex;
	assert PackedInts.unsignedBitsRequired(val) <= bitsPerValue;

	final int valuesPerBlock = 64 / bitsPerValue;
	if (toIndex - fromIndex <= valuesPerBlock << 1) {
	// there needs to be at least one full block to set for the block
	// approach to be worth trying
	super.fill(fromIndex, toIndex, val);
	return;
	}

	// set values naively until the next block start
	int fromOffsetInBlock = fromIndex % valuesPerBlock;
	if (fromOffsetInBlock != 0) {
	for (int i = fromOffsetInBlock; i < valuesPerBlock; ++i) {
	set(fromIndex++, val);
	}
	assert fromIndex % valuesPerBlock == 0;
	}

	// bulk set of the inner blocks
	final int fromBlock = fromIndex / valuesPerBlock;
	final int toBlock = toIndex / valuesPerBlock;
	assert fromBlock * valuesPerBlock == fromIndex;

	long blockValue = 0L;
	for (int i = 0; i < valuesPerBlock; ++i) {
	blockValue = blockValue \| (val << (i * bitsPerValue));
	}
	Arrays.fill(blocks, fromBlock, toBlock, blockValue);

	// fill the gap
	for (int i = valuesPerBlock * toBlock; i < toIndex; ++i) {
	set(i, val);
	}
	}

	@Override
	protected PackedInts.Format getFormat() {
	return PackedInts.Format.PACKED_SINGLE_BLOCK;
	}

	@Override
	public String toString() {
	return getClass().getSimpleName() + "(bitsPerValue=" + bitsPerValue
	+ ",size=" + size() + ",blocks=" + blocks.length + ")";
	}

	public static Packed64SingleBlock create(DataInput in,
	int valueCount, int bitsPerValue) throws IOException {
	Packed64SingleBlock reader = create(valueCount, bitsPerValue);
	for (int i = 0; i < reader.blocks.length; ++i) {
	reader.blocks[i] = in.readLong();
	}
	return reader;
	}

	public static Packed64SingleBlock create(int valueCount, int bitsPerValue) {
	switch (bitsPerValue) {
	case 1:
	return new Packed64SingleBlock1(valueCount);
	case 2:
	return new Packed64SingleBlock2(valueCount);
	case 3:
	return new Packed64SingleBlock3(valueCount);
	case 4:
	return new Packed64SingleBlock4(valueCount);
	case 5:
	return new Packed64SingleBlock5(valueCount);
	case 6:
	return new Packed64SingleBlock6(valueCount);
	case 7:
	return new Packed64SingleBlock7(valueCount);
	case 8:
	return new Packed64SingleBlock8(valueCount);
	case 9:
	return new Packed64SingleBlock9(valueCount);
	case 10:
	return new Packed64SingleBlock10(valueCount);
	case 12:
	return new Packed64SingleBlock12(valueCount);
	case 16:
	return new Packed64SingleBlock16(valueCount);
	case 21:
	return new Packed64SingleBlock21(valueCount);
	case 32:
	return new Packed64SingleBlock32(valueCount);
	default:
	throw new IllegalArgumentException("Unsupported number of bits per value: " + 32);
	}
	}

	static class Packed64SingleBlock1 extends Packed64SingleBlock {

	Packed64SingleBlock1(int valueCount) {
	super(valueCount, 1);
	}

	@Override
	public long get(int index) {
	final int o = index >>> 6;
	final int b = index & 63;
	final int shift = b << 0;
	return (blocks[o] >>> shift) & 1L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index >>> 6;
	final int b = index & 63;
	final int shift = b << 0;
	blocks[o] = (blocks[o] & ~(1L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock2 extends Packed64SingleBlock {

	Packed64SingleBlock2(int valueCount) {
	super(valueCount, 2);
	}

	@Override
	public long get(int index) {
	final int o = index >>> 5;
	final int b = index & 31;
	final int shift = b << 1;
	return (blocks[o] >>> shift) & 3L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index >>> 5;
	final int b = index & 31;
	final int shift = b << 1;
	blocks[o] = (blocks[o] & ~(3L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock3 extends Packed64SingleBlock {

	Packed64SingleBlock3(int valueCount) {
	super(valueCount, 3);
	}

	@Override
	public long get(int index) {
	final int o = index / 21;
	final int b = index % 21;
	final int shift = b * 3;
	return (blocks[o] >>> shift) & 7L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index / 21;
	final int b = index % 21;
	final int shift = b * 3;
	blocks[o] = (blocks[o] & ~(7L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock4 extends Packed64SingleBlock {

	Packed64SingleBlock4(int valueCount) {
	super(valueCount, 4);
	}

	@Override
	public long get(int index) {
	final int o = index >>> 4;
	final int b = index & 15;
	final int shift = b << 2;
	return (blocks[o] >>> shift) & 15L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index >>> 4;
	final int b = index & 15;
	final int shift = b << 2;
	blocks[o] = (blocks[o] & ~(15L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock5 extends Packed64SingleBlock {

	Packed64SingleBlock5(int valueCount) {
	super(valueCount, 5);
	}

	@Override
	public long get(int index) {
	final int o = index / 12;
	final int b = index % 12;
	final int shift = b * 5;
	return (blocks[o] >>> shift) & 31L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index / 12;
	final int b = index % 12;
	final int shift = b * 5;
	blocks[o] = (blocks[o] & ~(31L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock6 extends Packed64SingleBlock {

	Packed64SingleBlock6(int valueCount) {
	super(valueCount, 6);
	}

	@Override
	public long get(int index) {
	final int o = index / 10;
	final int b = index % 10;
	final int shift = b * 6;
	return (blocks[o] >>> shift) & 63L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index / 10;
	final int b = index % 10;
	final int shift = b * 6;
	blocks[o] = (blocks[o] & ~(63L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock7 extends Packed64SingleBlock {

	Packed64SingleBlock7(int valueCount) {
	super(valueCount, 7);
	}

	@Override
	public long get(int index) {
	final int o = index / 9;
	final int b = index % 9;
	final int shift = b * 7;
	return (blocks[o] >>> shift) & 127L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index / 9;
	final int b = index % 9;
	final int shift = b * 7;
	blocks[o] = (blocks[o] & ~(127L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock8 extends Packed64SingleBlock {

	Packed64SingleBlock8(int valueCount) {
	super(valueCount, 8);
	}

	@Override
	public long get(int index) {
	final int o = index >>> 3;
	final int b = index & 7;
	final int shift = b << 3;
	return (blocks[o] >>> shift) & 255L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index >>> 3;
	final int b = index & 7;
	final int shift = b << 3;
	blocks[o] = (blocks[o] & ~(255L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock9 extends Packed64SingleBlock {

	Packed64SingleBlock9(int valueCount) {
	super(valueCount, 9);
	}

	@Override
	public long get(int index) {
	final int o = index / 7;
	final int b = index % 7;
	final int shift = b * 9;
	return (blocks[o] >>> shift) & 511L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index / 7;
	final int b = index % 7;
	final int shift = b * 9;
	blocks[o] = (blocks[o] & ~(511L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock10 extends Packed64SingleBlock {

	Packed64SingleBlock10(int valueCount) {
	super(valueCount, 10);
	}

	@Override
	public long get(int index) {
	final int o = index / 6;
	final int b = index % 6;
	final int shift = b * 10;
	return (blocks[o] >>> shift) & 1023L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index / 6;
	final int b = index % 6;
	final int shift = b * 10;
	blocks[o] = (blocks[o] & ~(1023L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock12 extends Packed64SingleBlock {

	Packed64SingleBlock12(int valueCount) {
	super(valueCount, 12);
	}

	@Override
	public long get(int index) {
	final int o = index / 5;
	final int b = index % 5;
	final int shift = b * 12;
	return (blocks[o] >>> shift) & 4095L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index / 5;
	final int b = index % 5;
	final int shift = b * 12;
	blocks[o] = (blocks[o] & ~(4095L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock16 extends Packed64SingleBlock {

	Packed64SingleBlock16(int valueCount) {
	super(valueCount, 16);
	}

	@Override
	public long get(int index) {
	final int o = index >>> 2;
	final int b = index & 3;
	final int shift = b << 4;
	return (blocks[o] >>> shift) & 65535L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index >>> 2;
	final int b = index & 3;
	final int shift = b << 4;
	blocks[o] = (blocks[o] & ~(65535L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock21 extends Packed64SingleBlock {

	Packed64SingleBlock21(int valueCount) {
	super(valueCount, 21);
	}

	@Override
	public long get(int index) {
	final int o = index / 3;
	final int b = index % 3;
	final int shift = b * 21;
	return (blocks[o] >>> shift) & 2097151L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index / 3;
	final int b = index % 3;
	final int shift = b * 21;
	blocks[o] = (blocks[o] & ~(2097151L << shift)) \| (value << shift);
	}

	}

	static class Packed64SingleBlock32 extends Packed64SingleBlock {

	Packed64SingleBlock32(int valueCount) {
	super(valueCount, 32);
	}

	@Override
	public long get(int index) {
	final int o = index >>> 1;
	final int b = index & 1;
	final int shift = b << 5;
	return (blocks[o] >>> shift) & 4294967295L;
	}

	@Override
	public void set(int index, long value) {
	final int o = index >>> 1;
	final int b = index & 1;
	final int shift = b << 5;
	blocks[o] = (blocks[o] & ~(4294967295L << shift)) \| (value << shift);
	}

	}

	}