diff --git a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/KmerBytesWritable.java b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/KmerBytesWritable.java
index 2738b43..2d2907c 100644
--- a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/KmerBytesWritable.java
+++ b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/KmerBytesWritable.java
@@ -29,582 +29,618 @@
 import edu.uci.ics.genomix.oldtype.NodeWritable.DirectionFlag;
 
 /**
- * Variable kmer length byteswritable
- * It was used to generate the graph in which phase the kmer length doesn't change.
- * Thus the kmerByteSize of bytes doesn't change either.
+ * Variable kmer length byteswritable It was used to generate the graph in which
+ * phase the kmer length doesn't change. Thus the kmerByteSize of bytes doesn't
+ * change either.
  */
-public class KmerBytesWritable extends BinaryComparable implements Serializable, WritableComparable<BinaryComparable> {
+public class KmerBytesWritable extends BinaryComparable implements
+		Serializable, WritableComparable<BinaryComparable> {
 
-    private static final long serialVersionUID = 1L;
-    protected static final byte[] EMPTY_BYTES = {};
+	private static final long serialVersionUID = 1L;
+	protected static final byte[] EMPTY_BYTES = {};
 
-    protected int lettersInKmer;
-    protected int bytesUsed;
-    protected byte[] bytes;
-    protected int offset;
+	protected int lettersInKmer;
+	protected int bytesUsed;
+	protected byte[] bytes;
+	protected int offset;
 
-    /**
-     * Initialize as empty kmer
-     */
-    public KmerBytesWritable() {
-        this(0, EMPTY_BYTES, 0);
-    }
+	/**
+	 * Initialize as empty kmer
+	 */
+	public KmerBytesWritable() {
+		this(0, EMPTY_BYTES, 0);
+	}
 
-    /**
-     * Copy contents of kmer string
-     */
-    public KmerBytesWritable(String kmer) {
-        setAsCopy(kmer);
-    }
+	/**
+	 * Copy contents of kmer string
+	 */
+	public KmerBytesWritable(String kmer) {
+		setAsCopy(kmer);
+	}
 
-    /**
-     * Set as reference to given data
-     */
-    public KmerBytesWritable(int k, byte[] storage, int offset) {
-        setAsReference(k, storage, offset);
-    }
+	/**
+	 * Set as reference to given data
+	 */
+	public KmerBytesWritable(int k, byte[] storage, int offset) {
+		setAsReference(k, storage, offset);
+	}
 
-    /**
-     * Reserve space for k letters
-     */
-    public KmerBytesWritable(int k) {
-        if (k > 0) {
-            this.bytes = new byte[KmerUtil.getByteNumFromK(k)];
-        } else {
-            this.bytes = EMPTY_BYTES;
-        }
-        this.offset = 0;
-        setKmerLength(k);
-    }
+	/**
+	 * Reserve space for k letters
+	 */
+	public KmerBytesWritable(int k) {
+		if (k > 0) {
+			this.bytes = new byte[KmerUtil.getByteNumFromK(k)];
+		} else {
+			this.bytes = EMPTY_BYTES;
+		}
+		this.offset = 0;
+		setKmerLength(k);
+	}
 
-    /**
-     * copy kmer in other
-     * 
-     * @param other
-     */
-    public KmerBytesWritable(KmerBytesWritable other) {
-        this(other.lettersInKmer);
-        setAsCopy(other);
-    }
+	/**
+	 * copy kmer in other
+	 * 
+	 * @param other
+	 */
+	public KmerBytesWritable(KmerBytesWritable other) {
+		this(other.lettersInKmer);
+		setAsCopy(other);
+	}
 
-    /**
-     * Deep copy of the given kmer
-     * 
-     * @param other
-     */
-    public void setAsCopy(KmerBytesWritable other) {
-        reset(other.lettersInKmer);
-        if (lettersInKmer > 0) {
-            System.arraycopy(other.bytes, other.offset, bytes, this.offset, lettersInKmer);
-        }
-    }
+	/**
+	 * Deep copy of the given kmer
+	 * 
+	 * @param other
+	 */
+	public void setAsCopy(KmerBytesWritable other) {
+		reset(other.lettersInKmer);
+		if (lettersInKmer > 0) {
+			System.arraycopy(other.bytes, other.offset, bytes, this.offset,
+					bytesUsed);
+		}
+	}
 
-    /**
-     * set from String kmer
-     */
-    public void setAsCopy(String kmer) {
-        setKmerLength(kmer.length());
-        bytes = kmer.getBytes();
-        offset = 0;
-    }
+	/**
+	 * set from String kmer
+	 */
+	public void setAsCopy(String kmer) {
+		setKmerLength(kmer.length());
+		bytes = kmer.getBytes();
+		offset = 0;
+	}
 
-    /**
-     * Deep copy of the given bytes data
-     * 
-     * @param newData
-     * @param offset
-     */
-    public void setAsCopy(int k, byte[] newData, int offset) {
-        reset(k);
-        System.arraycopy(newData, offset, bytes, this.offset, k);
-    }
+	/**
+	 * Deep copy of the given bytes data
+	 * 
+	 * @param newData
+	 * @param offset
+	 */
+	public void setAsCopy(int k, byte[] newData, int offset) {
+		reset(k);
+		System.arraycopy(newData, offset, bytes, this.offset, k);
+	}
 
-    /**
-     * Reset array by kmerlength
-     * 
-     * @param k
-     */
-    public void reset(int k) {
-        setKmerLength(k);
-        setSize(bytesUsed);
-        clearLeadBit();
-    }
+	/**
+	 * Reset array by kmerlength
+	 * 
+	 * @param k
+	 */
+	public void reset(int k) {
+		setKmerLength(k);
+		setSize(bytesUsed);
+		clearLeadBit();
+	}
 
-    /**
-     * Point this datablock to the given bytes array
-     * It works like the pointer to new datablock.
-     * 
-     * @param newData
-     * @param offset
-     */
-    public void setAsReference(int k, byte[] newData, int offset) {
-        this.bytes = newData;
-        this.offset = offset;
-        setKmerLength(k);
-        if (newData.length - offset < bytesUsed) {
-            throw new IllegalArgumentException("Requested " + bytesUsed + " bytes (k=" + k
-                    + ") but buffer has only " + (newData.length - offset) + " bytes");
-        }
-    }
+	/**
+	 * Point this datablock to the given bytes array It works like the pointer
+	 * to new datablock.
+	 * 
+	 * @param newData
+	 * @param offset
+	 */
+	public void setAsReference(int k, byte[] newData, int offset) {
+		this.bytes = newData;
+		this.offset = offset;
+		// my java skills are lacking. In inherited classes with a header, this
+		// will use the header version...
+		// setKmerLength(k);
+		bytesUsed = KmerUtil.getByteNumFromK(k);
+		lettersInKmer = k;
+		if (newData.length - offset < bytesUsed) {
+			throw new IllegalArgumentException("Requested " + bytesUsed
+					+ " bytes (k=" + k + ") but buffer has only "
+					+ (newData.length - offset) + " bytes");
+		}
+	}
 
-    protected void setSize(int size) {
-        if (size > getCapacity()) {
-            setCapacity((size * 3 / 2));
-        }
-        this.bytesUsed = size;
-    }
+	/**
+	 * Ensures that there is space for at least `size` bytes of kmer (not
+	 * including any header)
+	 * 
+	 */
+	protected void setSize(int size) {
+		if (size > getCapacity()) {
+			setCapacity((size * 3 / 2));
+		}
+		this.bytesUsed = size;
+	}
 
-    protected int getCapacity() {
-        return bytes.length;
-    }
+	/**
+	 * return the number of bytes in use for the kmer (not including any header)
+	 */
+	protected int getCapacity() {
+		return bytes.length;
+	}
 
-    protected void setCapacity(int new_cap) {
-        if (new_cap != getCapacity()) {
-            byte[] new_data = new byte[new_cap];
-            if (new_cap < bytesUsed) {
-                bytesUsed = new_cap;
-            }
-            if (bytesUsed != 0) {
-                System.arraycopy(bytes, offset, new_data, 0, bytesUsed);
-            }
-            bytes = new_data;
-            offset = 0;
-        }
-    }
+	/**
+	 * shrinks/expands the storage area to allow new_cap bytes for the kmer (no
+	 * header included)
+	 */
+	protected void setCapacity(int new_cap) {
+		if (new_cap != getCapacity()) {
+			byte[] new_data = new byte[new_cap];
+			if (new_cap < bytesUsed) {
+				bytesUsed = new_cap;
+			}
+			if (bytesUsed != 0) {
+				System.arraycopy(bytes, offset, new_data, 0, bytesUsed);
+			}
+			bytes = new_data;
+			offset = 0;
+		}
+	}
 
-    /**
-     * Get one genecode (A|G|C|T) from the given kmer index
-     * e.g. Get the 4th gene of the kmer ACGTA will return T
-     * 
-     * @param pos
-     * @return
-     */
-    public byte getGeneCodeAtPosition(int pos) {
-        if (pos >= lettersInKmer) {
-            throw new IllegalArgumentException("gene position out of bound");
-        }
-        return geneCodeAtPosition(pos);
-    }
+	/**
+	 * Get one genecode (A|G|C|T) from the given kmer index e.g. Get the 4th
+	 * gene of the kmer ACGTA will return T
+	 * 
+	 * @param pos
+	 * @return
+	 */
+	public byte getGeneCodeAtPosition(int pos) {
+		if (pos >= lettersInKmer) {
+			throw new IllegalArgumentException("gene position out of bound");
+		}
+		return geneCodeAtPosition(pos);
+	}
 
-    // unchecked version of above. Used when kmerlength is inaccurate (mid-merge)
-    private byte geneCodeAtPosition(int pos) {
-        int posByte = pos / 4;
-        int shift = (pos % 4) << 1;
-        return (byte) ((bytes[offset + bytesUsed - 1 - posByte] >> shift) & 0x3);
-    }
+	// unchecked version of above. Used when kmerlength is inaccurate
+	// (mid-merge)
+	private byte geneCodeAtPosition(int pos) {
+		int posByte = pos / 4;
+		int shift = (pos % 4) << 1;
+		return (byte) ((bytes[offset + bytesUsed - 1 - posByte] >> shift) & 0x3);
+	}
 
-    public void setKmerLength(int k) {
-        this.bytesUsed = KmerUtil.getByteNumFromK(k);
-        this.lettersInKmer = k;
-    }
+	public void setKmerLength(int k) {
+		this.bytesUsed = KmerUtil.getByteNumFromK(k);
+		this.lettersInKmer = k;
+	}
 
-    public int getKmerLength() {
-        return lettersInKmer;
-    }
+	public int getKmerLength() {
+		return lettersInKmer;
+	}
 
-    @Override
-    public byte[] getBytes() {
-        return bytes;
-    }
+	@Override
+	public byte[] getBytes() {
+		return bytes;
+	}
 
-    public int getOffset() {
-        return offset;
-    }
+	public int getOffset() {
+		return offset;
+	}
 
-    @Override
-    public int getLength() {
-        return bytesUsed;
-    }
+	@Override
+	public int getLength() {
+		return bytesUsed;
+	}
 
-    /**
-     * Read Kmer from read text into bytes array e.g. AATAG will compress as
-     * [0x000G, 0xATAA]
-     * 
-     * @param k
-     * @param stringBytes
-     *            : byte array from a _string_. Meaning there's no header
-     * @param start
-     */
-    public void setByRead(byte[] stringBytes, int start) {
-        byte l = 0;
-        int bytecount = 0;
-        int bcount = this.bytesUsed - 1;
-        for (int i = start; i < start + lettersInKmer && i < stringBytes.length; i++) {
-            byte code = GeneCode.getCodeFromSymbol(stringBytes[i]);
-            l |= (byte) (code << bytecount);
-            bytecount += 2;
-            if (bytecount == 8) {
-                bytes[offset + bcount--] = l;
-                l = 0;
-                bytecount = 0;
-            }
-        }
-        if (bcount >= 0) {
-            bytes[offset] = l;
-        }
-    }
+	/**
+	 * Read Kmer from read text into bytes array e.g. AATAG will compress as
+	 * [0x000G, 0xATAA]
+	 * 
+	 * @param k
+	 * @param stringBytes
+	 *            : byte array from a _string_. Meaning there's no header
+	 * @param start
+	 */
+	public void setByRead(byte[] stringBytes, int start) {
+		byte l = 0;
+		int bytecount = 0;
+		int bcount = this.bytesUsed - 1;
+		for (int i = start; i < start + lettersInKmer && i < stringBytes.length; i++) {
+			byte code = GeneCode.getCodeFromSymbol(stringBytes[i]);
+			l |= (byte) (code << bytecount);
+			bytecount += 2;
+			if (bytecount == 8) {
+				bytes[offset + bcount--] = l;
+				l = 0;
+				bytecount = 0;
+			}
+		}
+		if (bcount >= 0) {
+			bytes[offset] = l;
+		}
+	}
 
-    public void setByRead(int k, byte[] array, int start) {
-        reset(k);
-        setByRead(array, start);
-    }
+	public void setByRead(int k, byte[] array, int start) {
+		reset(k);
+		setByRead(array, start);
+	}
 
-    /**
-     * Compress Reversed read into bytes array
-     * e.g. AATAG will paired to CTATT, and then compress as
-     * [0x000T,0xTATC]
-     * 
-     * @param input
-     *            array
-     * @param start
-     *            position
-     */
-    public void setByReadReverse(byte[] array, int start) {
-        byte l = 0;
-        int bytecount = 0;
-        int bcount = bytesUsed - 1;
-        //        for (int i = start + kmerlength - 1; i >= 0 && i < array.length; i--) {
-        for (int i = start + lettersInKmer - 1; i >= start && i < array.length; i--) {
-            byte code = GeneCode.getPairedCodeFromSymbol(array[i]);
-            l |= (byte) (code << bytecount);
-            bytecount += 2;
-            if (bytecount == 8) {
-                bytes[offset + bcount--] = l;
-                l = 0;
-                bytecount = 0;
-            }
-        }
-        if (bcount >= 0) {
-            bytes[offset] = l;
-        }
-    }
+	/**
+	 * Compress Reversed read into bytes array e.g. AATAG will paired to CTATT,
+	 * and then compress as [0x000T,0xTATC]
+	 * 
+	 * @param input
+	 *            array
+	 * @param start
+	 *            position
+	 */
+	public void setByReadReverse(byte[] array, int start) {
+		byte l = 0;
+		int bytecount = 0;
+		int bcount = bytesUsed - 1;
+		// for (int i = start + kmerlength - 1; i >= 0 && i < array.length; i--)
+		// {
+		for (int i = start + lettersInKmer - 1; i >= start && i < array.length; i--) {
+			byte code = GeneCode.getPairedCodeFromSymbol(array[i]);
+			l |= (byte) (code << bytecount);
+			bytecount += 2;
+			if (bytecount == 8) {
+				bytes[offset + bcount--] = l;
+				l = 0;
+				bytecount = 0;
+			}
+		}
+		if (bcount >= 0) {
+			bytes[offset] = l;
+		}
+	}
 
-    public void setByReadReverse(int k, byte[] array, int start) {
-        reset(k);
-        setByReadReverse(array, start);
-    }
+	public void setByReadReverse(int k, byte[] array, int start) {
+		reset(k);
+		setByReadReverse(array, start);
+	}
 
-    /**
-     * Shift Kmer to accept new char input
-     * 
-     * @param c
-     *            Input new gene character
-     * @return the shift out gene, in gene code format
-     */
-    public byte shiftKmerWithNextChar(byte c) {
-        return shiftKmerWithNextCode(GeneCode.getCodeFromSymbol(c));
-    }
+	/**
+	 * Shift Kmer to accept new char input
+	 * 
+	 * @param c
+	 *            Input new gene character
+	 * @return the shift out gene, in gene code format
+	 */
+	public byte shiftKmerWithNextChar(byte c) {
+		return shiftKmerWithNextCode(GeneCode.getCodeFromSymbol(c));
+	}
 
-    /**
-     * Shift Kmer to accept new gene code
-     * 
-     * @param c
-     *            Input new gene code
-     * @return the shift out gene, in gene code format
-     */
-    public byte shiftKmerWithNextCode(byte c) {
-        byte output = (byte) (bytes[offset + bytesUsed - 1] & 0x03);
-        for (int i = bytesUsed - 1; i > 0; i--) {
-            byte in = (byte) (bytes[offset + i - 1] & 0x03);
-            bytes[offset + i] = (byte) (((bytes[offset + i] >>> 2) & 0x3f) | (in << 6));
-        }
-        int pos = ((lettersInKmer - 1) % 4) << 1;
-        byte code = (byte) (c << pos);
-        bytes[offset] = (byte) (((bytes[offset] >>> 2) & 0x3f) | code);
-        clearLeadBit();
-        return output;
-    }
+	/**
+	 * Shift Kmer to accept new gene code
+	 * 
+	 * @param c
+	 *            Input new gene code
+	 * @return the shift out gene, in gene code format
+	 */
+	public byte shiftKmerWithNextCode(byte c) {
+		byte output = (byte) (bytes[offset + bytesUsed - 1] & 0x03);
+		for (int i = bytesUsed - 1; i > 0; i--) {
+			byte in = (byte) (bytes[offset + i - 1] & 0x03);
+			bytes[offset + i] = (byte) (((bytes[offset + i] >>> 2) & 0x3f) | (in << 6));
+		}
+		int pos = ((lettersInKmer - 1) % 4) << 1;
+		byte code = (byte) (c << pos);
+		bytes[offset] = (byte) (((bytes[offset] >>> 2) & 0x3f) | code);
+		clearLeadBit();
+		return output;
+	}
 
-    /**
-     * Shift Kmer to accept new input char
-     * 
-     * @param c
-     *            Input new gene character
-     * @return the shiftout gene, in gene code format
-     */
-    public byte shiftKmerWithPreChar(byte c) {
-        return shiftKmerWithPreCode(GeneCode.getCodeFromSymbol(c));
-    }
+	/**
+	 * Shift Kmer to accept new input char
+	 * 
+	 * @param c
+	 *            Input new gene character
+	 * @return the shiftout gene, in gene code format
+	 */
+	public byte shiftKmerWithPreChar(byte c) {
+		return shiftKmerWithPreCode(GeneCode.getCodeFromSymbol(c));
+	}
 
-    /**
-     * Shift Kmer to accept new gene code
-     * 
-     * @param c
-     *            Input new gene code
-     * @return the shiftout gene, in gene code format
-     */
-    public byte shiftKmerWithPreCode(byte c) {
-        int pos = ((lettersInKmer - 1) % 4) << 1;
-        byte output = (byte) ((bytes[offset] >> pos) & 0x03);
-        for (int i = 0; i < bytesUsed - 1; i++) {
-            byte in = (byte) ((bytes[offset + i + 1] >> 6) & 0x03);
-            bytes[offset + i] = (byte) ((bytes[offset + i] << 2) | in);
-        }
-        bytes[offset + bytesUsed - 1] = (byte) ((bytes[offset + bytesUsed - 1] << 2) | c);
-        clearLeadBit();
-        return output;
-    }
+	/**
+	 * Shift Kmer to accept new gene code
+	 * 
+	 * @param c
+	 *            Input new gene code
+	 * @return the shiftout gene, in gene code format
+	 */
+	public byte shiftKmerWithPreCode(byte c) {
+		int pos = ((lettersInKmer - 1) % 4) << 1;
+		byte output = (byte) ((bytes[offset] >> pos) & 0x03);
+		for (int i = 0; i < bytesUsed - 1; i++) {
+			byte in = (byte) ((bytes[offset + i + 1] >> 6) & 0x03);
+			bytes[offset + i] = (byte) ((bytes[offset + i] << 2) | in);
+		}
+		bytes[offset + bytesUsed - 1] = (byte) ((bytes[offset + bytesUsed - 1] << 2) | c);
+		clearLeadBit();
+		return output;
+	}
 
-    /**
-     * Merge Kmer with the next connected Kmer
-     * e.g. AAGCTAA merge with AACAACC, if the initial kmerSize = 3
-     * then it will return AAGCTAACAACC
-     * 
-     * @param initialKmerSize
-     *            : the initial kmerSize
-     * @param kmer
-     *            : the next kmer
-     */
-    public void mergeWithFFKmer(int initialKmerSize, KmerBytesWritable kmer) {
-        int preKmerLength = lettersInKmer;
-        int preSize = bytesUsed;
-        lettersInKmer += kmer.lettersInKmer - initialKmerSize + 1;
-        setSize(KmerUtil.getByteNumFromK(lettersInKmer));
-        for (int i = 1; i <= preSize; i++) {
-            bytes[offset + bytesUsed - i] = bytes[offset + preSize - i];
-        }
-        for (int k = initialKmerSize - 1; k < kmer.getKmerLength(); k += 4) {
-            byte onebyte = getOneByteFromKmerAtPosition(k, kmer.getBytes(), kmer.getOffset(), kmer.getLength());
-            appendOneByteAtPosition(preKmerLength + k - initialKmerSize + 1, onebyte, bytes, offset, bytesUsed);
-        }
-        clearLeadBit();
-    }
+	/**
+	 * Merge Kmer with the next connected Kmer e.g. AAGCTAA merge with AACAACC,
+	 * if the initial kmerSize = 3 then it will return AAGCTAACAACC
+	 * 
+	 * @param initialKmerSize
+	 *            : the initial kmerSize
+	 * @param kmer
+	 *            : the next kmer
+	 */
+	public void mergeWithFFKmer(int initialKmerSize, KmerBytesWritable kmer) {
+		int preKmerLength = lettersInKmer;
+		int preSize = bytesUsed;
+		lettersInKmer += kmer.lettersInKmer - initialKmerSize + 1;
+		setSize(KmerUtil.getByteNumFromK(lettersInKmer));
+		for (int i = 1; i <= preSize; i++) {
+			bytes[offset + bytesUsed - i] = bytes[offset + preSize - i];
+		}
+		for (int k = initialKmerSize - 1; k < kmer.getKmerLength(); k += 4) {
+			byte onebyte = getOneByteFromKmerAtPosition(k, kmer.getBytes(),
+					kmer.getOffset(), kmer.getLength());
+			appendOneByteAtPosition(preKmerLength + k - initialKmerSize + 1,
+					onebyte, bytes, offset, bytesUsed);
+		}
+		clearLeadBit();
+	}
 
-    /**
-     * Merge Kmer with the next connected Kmer, when that Kmer needs to be reverse-complemented
-     * e.g. AAGCTAA merge with GGTTGTT, if the initial kmerSize = 3
-     * then it will return AAGCTAACAACC
-     * A merge B => A B~
-     * 
-     * @param initialKmerSize
-     *            : the initial kmerSize
-     * @param kmer
-     *            : the next kmer
-     */
-    public void mergeWithFRKmer(int initialKmerSize, KmerBytesWritable kmer) {
-        int preSize = bytesUsed;
-        int preKmerLength = lettersInKmer;
-        lettersInKmer += kmer.lettersInKmer - initialKmerSize + 1;
-        setSize(KmerUtil.getByteNumFromK(lettersInKmer));
-        // copy prefix into right-side of buffer
-        for (int i = 1; i <= preSize; i++) {
-            bytes[offset + bytesUsed - i] = bytes[offset + preSize - i];
-        }
+	/**
+	 * Merge Kmer with the next connected Kmer, when that Kmer needs to be
+	 * reverse-complemented e.g. AAGCTAA merge with GGTTGTT, if the initial
+	 * kmerSize = 3 then it will return AAGCTAACAACC A merge B => A B~
+	 * 
+	 * @param initialKmerSize
+	 *            : the initial kmerSize
+	 * @param kmer
+	 *            : the next kmer
+	 */
+	public void mergeWithFRKmer(int initialKmerSize, KmerBytesWritable kmer) {
+		int preSize = bytesUsed;
+		int preKmerLength = lettersInKmer;
+		lettersInKmer += kmer.lettersInKmer - initialKmerSize + 1;
+		setSize(KmerUtil.getByteNumFromK(lettersInKmer));
+		// copy prefix into right-side of buffer
+		for (int i = 1; i <= preSize; i++) {
+			bytes[offset + bytesUsed - i] = bytes[offset + preSize - i];
+		}
 
-        int bytecount = (preKmerLength % 4) * 2;
-        int bcount = bytesUsed - preSize - bytecount / 8; // may overlap previous kmer
-        byte l = bcount == bytesUsed - preSize ? bytes[offset + bcount] : 0x00;
-        bytecount %= 8;
-        for (int i = kmer.lettersInKmer - initialKmerSize; i >= 0; i--) {
-            byte code = GeneCode.getPairedGeneCode(kmer.getGeneCodeAtPosition(i));
-            l |= (byte) (code << bytecount);
-            bytecount += 2;
-            if (bytecount == 8) {
-                bytes[offset + bcount--] = l;
-                l = 0;
-                bytecount = 0;
-            }
-        }
-        if (bcount >= 0) {
-            bytes[offset] = l;
-        }
-    }
+		int bytecount = (preKmerLength % 4) * 2;
+		int bcount = bytesUsed - preSize - bytecount / 8; // may overlap
+															// previous kmer
+		byte l = bcount == bytesUsed - preSize ? bytes[offset + bcount] : 0x00;
+		bytecount %= 8;
+		for (int i = kmer.lettersInKmer - initialKmerSize; i >= 0; i--) {
+			byte code = GeneCode.getPairedGeneCode(kmer
+					.getGeneCodeAtPosition(i));
+			l |= (byte) (code << bytecount);
+			bytecount += 2;
+			if (bytecount == 8) {
+				bytes[offset + bcount--] = l;
+				l = 0;
+				bytecount = 0;
+			}
+		}
+		if (bcount >= 0) {
+			bytes[offset] = l;
+		}
+	}
 
-    /**
-     * Merge Kmer with the previous connected Kmer, when that kmer needs to be reverse-complemented
-     * e.g. AACAACC merge with TTCTGCC, if the initial kmerSize = 3
-     * then it will return GGCAGAACAACC
-     * 
-     * @param initialKmerSize
-     *            : the initial kmerSize
-     * @param preKmer
-     *            : the previous kmer
-     */
-    public void mergeWithRFKmer(int initialKmerSize, KmerBytesWritable preKmer) {
-        int preKmerLength = lettersInKmer;
-        int preSize = bytesUsed;
-        lettersInKmer += preKmer.lettersInKmer - initialKmerSize + 1;
-        setSize(KmerUtil.getByteNumFromK(lettersInKmer));
-        //        byte cacheByte = getOneByteFromKmerAtPosition(0, bytes, offset, preSize);
+	/**
+	 * Merge Kmer with the previous connected Kmer, when that kmer needs to be
+	 * reverse-complemented e.g. AACAACC merge with TTCTGCC, if the initial
+	 * kmerSize = 3 then it will return GGCAGAACAACC
+	 * 
+	 * @param initialKmerSize
+	 *            : the initial kmerSize
+	 * @param preKmer
+	 *            : the previous kmer
+	 */
+	public void mergeWithRFKmer(int initialKmerSize, KmerBytesWritable preKmer) {
+		int preKmerLength = lettersInKmer;
+		int preSize = bytesUsed;
+		lettersInKmer += preKmer.lettersInKmer - initialKmerSize + 1;
+		setSize(KmerUtil.getByteNumFromK(lettersInKmer));
+		// byte cacheByte = getOneByteFromKmerAtPosition(0, bytes, offset,
+		// preSize);
 
-        int byteIndex = bytesUsed - 1;
-        byte cacheByte = 0x00;
-        int posnInByte = 0;
+		int byteIndex = bytesUsed - 1;
+		byte cacheByte = 0x00;
+		int posnInByte = 0;
 
-        // copy rc of preKmer into high bytes
-        for (int i = preKmer.lettersInKmer - 1; i >= initialKmerSize - 1; i--) {
-            byte code = GeneCode.getPairedGeneCode(preKmer.getGeneCodeAtPosition(i));
-            cacheByte |= (byte) (code << posnInByte);
-            posnInByte += 2;
-            if (posnInByte == 8) {
-                bytes[byteIndex--] = cacheByte;
-                cacheByte = 0;
-                posnInByte = 0;
-            }
-        }
+		// copy rc of preKmer into high bytes
+		for (int i = preKmer.lettersInKmer - 1; i >= initialKmerSize - 1; i--) {
+			byte code = GeneCode.getPairedGeneCode(preKmer
+					.getGeneCodeAtPosition(i));
+			cacheByte |= (byte) (code << posnInByte);
+			posnInByte += 2;
+			if (posnInByte == 8) {
+				bytes[byteIndex--] = cacheByte;
+				cacheByte = 0;
+				posnInByte = 0;
+			}
+		}
 
-        // copy my kmer into low positions of bytes
-        for (int i = 0; i < preKmerLength; i++) {
-            // expanding the capacity makes this offset incorrect.  It's off by the # of additional bytes added.
-            int newposn = i + (bytesUsed - preSize) * 4;
-            byte code = geneCodeAtPosition(newposn);
-            cacheByte |= (byte) (code << posnInByte);
-            posnInByte += 2;
-            if (posnInByte == 8) {
-                bytes[byteIndex--] = cacheByte;
-                cacheByte = 0;
-                posnInByte = 0;
-            }
-        }
-        bytes[offset] = cacheByte;
-        clearLeadBit();
-    }
+		// copy my kmer into low positions of bytes
+		for (int i = 0; i < preKmerLength; i++) {
+			// expanding the capacity makes this offset incorrect. It's off by
+			// the # of additional bytes added.
+			int newposn = i + (bytesUsed - preSize) * 4;
+			byte code = geneCodeAtPosition(newposn);  // TODO: this evaluation may be reading from a place we just overwrote :( 
+			cacheByte |= (byte) (code << posnInByte);
+			posnInByte += 2;
+			if (posnInByte == 8) {
+				bytes[byteIndex--] = cacheByte;
+				cacheByte = 0;
+				posnInByte = 0;
+			}
+		}
+		if (posnInByte > 0)
+			bytes[offset] = cacheByte;
+		clearLeadBit();
+	}
 
-    /**
-     * Merge Kmer with the previous connected Kmer
-     * e.g. AACAACC merge with AAGCTAA, if the initial kmerSize = 3
-     * then it will return AAGCTAACAACC
-     * 
-     * @param initialKmerSize
-     *            : the initial kmerSize
-     * @param preKmer
-     *            : the previous kmer
-     */
-    public void mergeWithRRKmer(int initialKmerSize, KmerBytesWritable preKmer) {
-        int preKmerLength = lettersInKmer;
-        int preSize = bytesUsed;
-        lettersInKmer += preKmer.lettersInKmer - initialKmerSize + 1;
-        setSize(KmerUtil.getByteNumFromK(lettersInKmer));
-        byte cacheByte = getOneByteFromKmerAtPosition(0, bytes, offset, preSize);
+	/**
+	 * Merge Kmer with the previous connected Kmer e.g. AACAACC merge with
+	 * AAGCTAA, if the initial kmerSize = 3 then it will return AAGCTAACAACC
+	 * 
+	 * @param initialKmerSize
+	 *            : the initial kmerSize
+	 * @param preKmer
+	 *            : the previous kmer
+	 */
+	public void mergeWithRRKmer(int initialKmerSize, KmerBytesWritable preKmer) {
+		int preKmerLength = lettersInKmer;
+		int preSize = bytesUsed;
+		lettersInKmer += preKmer.lettersInKmer - initialKmerSize + 1;
+		setSize(KmerUtil.getByteNumFromK(lettersInKmer));
+		byte cacheByte = getOneByteFromKmerAtPosition(0, bytes, offset, preSize);
 
-        // copy prekmer
-        for (int k = 0; k < preKmer.lettersInKmer - initialKmerSize + 1; k += 4) {
-            byte onebyte = getOneByteFromKmerAtPosition(k, preKmer.bytes, preKmer.offset, preKmer.bytesUsed);
-            appendOneByteAtPosition(k, onebyte, bytes, offset, bytesUsed);
-        }
+		// copy prekmer
+		for (int k = 0; k < preKmer.lettersInKmer - initialKmerSize + 1; k += 4) {
+			byte onebyte = getOneByteFromKmerAtPosition(k, preKmer.bytes,
+					preKmer.offset, preKmer.bytesUsed);
+			appendOneByteAtPosition(k, onebyte, bytes, offset, bytesUsed);
+		}
 
-        // copy current kmer
-        int k = 4;
-        for (; k < preKmerLength; k += 4) {
-            byte onebyte = getOneByteFromKmerAtPosition(k, bytes, offset, preSize);
-            appendOneByteAtPosition(preKmer.lettersInKmer - initialKmerSize + k - 4 + 1, cacheByte, bytes, offset,
-                    bytesUsed);
-            cacheByte = onebyte;
-        }
-        appendOneByteAtPosition(preKmer.lettersInKmer - initialKmerSize + k - 4 + 1, cacheByte, bytes, offset, bytesUsed);
-        clearLeadBit();
-    }
+		// copy current kmer
+		int k = 4;
+		for (; k < preKmerLength; k += 4) {
+			byte onebyte = getOneByteFromKmerAtPosition(k, bytes, offset,
+					preSize);
+			appendOneByteAtPosition(preKmer.lettersInKmer - initialKmerSize + k
+					- 4 + 1, cacheByte, bytes, offset, bytesUsed);
+			cacheByte = onebyte;
+		}
+		appendOneByteAtPosition(preKmer.lettersInKmer - initialKmerSize + k - 4
+				+ 1, cacheByte, bytes, offset, bytesUsed);
+		clearLeadBit();
+	}
 
-    public void mergeWithKmerInDir(byte dir, int initialKmerSize, KmerBytesWritable kmer) {
-        switch (dir & DirectionFlag.DIR_MASK) {
-            case DirectionFlag.DIR_FF:
-                mergeWithFFKmer(initialKmerSize, kmer);
-                break;
-            case DirectionFlag.DIR_FR:
-                mergeWithFRKmer(initialKmerSize, kmer);
-                break;
-            case DirectionFlag.DIR_RF:
-                mergeWithRFKmer(initialKmerSize, kmer);
-                break;
-            case DirectionFlag.DIR_RR:
-                mergeWithRRKmer(initialKmerSize, kmer);
-                break;
-            default:
-                throw new RuntimeException("Direction not recognized: " + dir);
-        }
-    }
+	public void mergeWithKmerInDir(byte dir, int initialKmerSize,
+			KmerBytesWritable kmer) {
+		switch (dir & DirectionFlag.DIR_MASK) {
+		case DirectionFlag.DIR_FF:
+			mergeWithFFKmer(initialKmerSize, kmer);
+			break;
+		case DirectionFlag.DIR_FR:
+			mergeWithFRKmer(initialKmerSize, kmer);
+			break;
+		case DirectionFlag.DIR_RF:
+			mergeWithRFKmer(initialKmerSize, kmer);
+			break;
+		case DirectionFlag.DIR_RR:
+			mergeWithRRKmer(initialKmerSize, kmer);
+			break;
+		default:
+			throw new RuntimeException("Direction not recognized: " + dir);
+		}
+	}
 
-    public static void appendOneByteAtPosition(int k, byte onebyte, byte[] buffer, int start, int length) {
-        int position = start + length - 1 - k / 4;
-        if (position < start) {
-            throw new IllegalArgumentException("Buffer for kmer storage is invalid");
-        }
-        int shift = ((k) % 4) << 1;
-        int mask = shift == 0 ? 0 : ((1 << shift) - 1);
+	public static void appendOneByteAtPosition(int k, byte onebyte,
+			byte[] buffer, int start, int length) {
+		int position = start + length - 1 - k / 4;
+		if (position < start) {
+			throw new IllegalArgumentException(
+					"Buffer for kmer storage is invalid");
+		}
+		int shift = ((k) % 4) << 1;
+		int mask = shift == 0 ? 0 : ((1 << shift) - 1);
 
-        buffer[position] = (byte) ((buffer[position] & mask) | ((0xff & onebyte) << shift));
-        if (position > start && shift != 0) {
-            buffer[position - 1] = (byte) ((buffer[position - 1] & (0xff - mask)) | ((byte) ((0xff & onebyte) >>> (8 - shift))));
-        }
-    }
+		buffer[position] = (byte) ((buffer[position] & mask) | ((0xff & onebyte) << shift));
+		if (position > start && shift != 0) {
+			buffer[position - 1] = (byte) ((buffer[position - 1] & (0xff - mask)) | ((byte) ((0xff & onebyte) >>> (8 - shift))));
+		}
+	}
 
-    public static byte getOneByteFromKmerAtPosition(int k, byte[] buffer, int start, int length) {
-        int position = start + length - 1 - k / 4;
-        if (position < start) {
-            throw new IllegalArgumentException("Buffer of kmer storage is invalid");
-        }
-        int shift = (k % 4) << 1;
-        byte data = (byte) (((0xff) & buffer[position]) >>> shift);
-        if (shift != 0 && position > start) {
-            data |= 0xff & (buffer[position - 1] << (8 - shift));
-        }
-        return data;
-    }
+	public static byte getOneByteFromKmerAtPosition(int k, byte[] buffer,
+			int start, int length) {
+		int position = start + length - 1 - k / 4;
+		if (position < start) {
+			throw new IllegalArgumentException(
+					"Buffer of kmer storage is invalid");
+		}
+		int shift = (k % 4) << 1;
+		byte data = (byte) (((0xff) & buffer[position]) >>> shift);
+		if (shift != 0 && position > start) {
+			data |= 0xff & (buffer[position - 1] << (8 - shift));
+		}
+		return data;
+	}
 
-    protected void clearLeadBit() {
-        if (lettersInKmer % 4 != 0) {
-            bytes[offset] &= (1 << ((lettersInKmer % 4) << 1)) - 1;
-        }
-    }
+	protected void clearLeadBit() {
+		if (lettersInKmer % 4 != 0) {
+			bytes[offset] &= (1 << ((lettersInKmer % 4) << 1)) - 1;
+		}
+	}
 
-    @Override
-    public void readFields(DataInput in) throws IOException {
-        lettersInKmer = in.readInt();
-        bytesUsed = KmerUtil.getByteNumFromK(lettersInKmer);
-        if (lettersInKmer > 0) {
-            if (this.bytes.length < this.bytesUsed) {
-                this.bytes = new byte[this.bytesUsed];
-                this.offset = 0;
-                
-            }
-            in.readFully(bytes, offset, bytesUsed);
-        }
-    }
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		lettersInKmer = in.readInt();
+		bytesUsed = KmerUtil.getByteNumFromK(lettersInKmer);
+		if (lettersInKmer > 0) {
+			if (this.bytes.length < this.bytesUsed) {
+				this.bytes = new byte[this.bytesUsed];
+				this.offset = 0;
 
-    @Override
-    public void write(DataOutput out) throws IOException {
-        out.writeInt(lettersInKmer);
-        if (lettersInKmer > 0) {
-            out.write(bytes, offset, bytesUsed);
-        }
-    }
+			}
+			in.readFully(bytes, offset, bytesUsed);
+		}
+	}
 
-    @Override
-    public int hashCode() {
-        return super.hashCode() * 31 + this.lettersInKmer;
-    }
+	@Override
+	public void write(DataOutput out) throws IOException {
+		out.writeInt(lettersInKmer);
+		if (lettersInKmer > 0) {
+			out.write(bytes, offset, bytesUsed);
+		}
+	}
 
-    @Override
-    public boolean equals(Object right_obj) {
-        if (right_obj instanceof KmerBytesWritable)
-            return this.lettersInKmer == ((KmerBytesWritable) right_obj).lettersInKmer && super.equals(right_obj);
-        return false;
-    }
+	@Override
+	public int hashCode() {
+		return super.hashCode() * 31 + this.lettersInKmer;
+	}
 
-    @Override
-    public String toString() {
-        return KmerUtil.recoverKmerFrom(this.lettersInKmer, this.getBytes(), offset, this.getLength());
-    }
+	@Override
+	public boolean equals(Object right_obj) {
+		if (right_obj instanceof KmerBytesWritable)
+			return this.lettersInKmer == ((KmerBytesWritable) right_obj).lettersInKmer
+					&& super.equals(right_obj);
+		return false;
+	}
 
-    public static class Comparator extends WritableComparator {
-    	private static final int LEADING_BYTES = 4;
+	@Override
+	public String toString() {
+		return KmerUtil.recoverKmerFrom(this.lettersInKmer, this.getBytes(),
+				offset, this.getLength());
+	}
 
-        public Comparator() {
-            super(KmerBytesWritable.class);
-        }
+	public static class Comparator extends WritableComparator {
+		private static final int LEADING_BYTES = 4;
 
-        public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
-            int kmerlength1 = Marshal.getInt(b1, s1);
-            int kmerlength2 = Marshal.getInt(b2, s2);
-            if (kmerlength1 == kmerlength2) {
-                return compareBytes(b1, s1 + LEADING_BYTES, l1 - LEADING_BYTES, b2, s2 + LEADING_BYTES, l2 - LEADING_BYTES);
-            }
-            return kmerlength1 - kmerlength2;
-        }
-    }
+		public Comparator() {
+			super(KmerBytesWritable.class);
+		}
 
-    static { // register this comparator
-        WritableComparator.define(KmerBytesWritable.class, new Comparator());
-    }
+		public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
+			int kmerlength1 = Marshal.getInt(b1, s1);
+			int kmerlength2 = Marshal.getInt(b2, s2);
+			if (kmerlength1 == kmerlength2) {
+				return compareBytes(b1, s1 + LEADING_BYTES, l1 - LEADING_BYTES,
+						b2, s2 + LEADING_BYTES, l2 - LEADING_BYTES);
+			}
+			return kmerlength1 - kmerlength2;
+		}
+	}
+
+	static { // register this comparator
+		WritableComparator.define(KmerBytesWritable.class, new Comparator());
+	}
 
 }
diff --git a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/VKmerBytesWritable.java b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/VKmerBytesWritable.java
index cd982ef..0e26b77 100644
--- a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/VKmerBytesWritable.java
+++ b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/VKmerBytesWritable.java
@@ -46,7 +46,7 @@
 	 * Initialize as empty kmer
 	 */
 	public VKmerBytesWritable() {
-		this(EMPTY_BYTES, 0);
+		this(EMPTY_BYTES, HEADER_SIZE);
 	}
 
 	/**
@@ -54,12 +54,16 @@
 	 */
 	public VKmerBytesWritable(String kmer) {
 		bytes = new byte[HEADER_SIZE + KmerUtil.getByteNumFromK(kmer.length())];
-		offset = 0;
+		offset = HEADER_SIZE;
 		setAsCopy(kmer);
 	}
 
 	/**
 	 * Set as reference to given data
+	 * 
+	 * @param storage
+	 *            : byte array with header
+	 * @param offset
 	 */
 	public VKmerBytesWritable(byte[] storage, int offset) {
 		setAsReference(storage, offset);
@@ -74,7 +78,7 @@
 		} else {
 			bytes = EMPTY_BYTES;
 		}
-		offset = 0;
+		offset = HEADER_SIZE;
 		setKmerLength(k);
 	}
 
@@ -97,21 +101,8 @@
 	public void setAsCopy(KmerBytesWritable other) {
 		reset(other.lettersInKmer);
 		if (lettersInKmer > 0) {
-			System.arraycopy(other.bytes, other.offset, bytes, this.offset
-					+ HEADER_SIZE, lettersInKmer);
-		}
-	}
-
-	/**
-	 * Deep copy of the given kmer
-	 * 
-	 * @param other
-	 */
-	public void setAsCopy(VKmerBytesWritable other) {
-		reset(other.lettersInKmer);
-		if (lettersInKmer > 0) {
-			System.arraycopy(other.bytes, other.offset + HEADER_SIZE, bytes,
-					this.offset + HEADER_SIZE, lettersInKmer);
+			System.arraycopy(other.bytes, other.offset, bytes, this.offset,
+					bytesUsed);
 		}
 	}
 
@@ -122,21 +113,7 @@
 	public void setAsCopy(String kmer) {
 		int k = kmer.length();
 		reset(k);
-		System.arraycopy(kmer.getBytes(), 0, bytes, offset + HEADER_SIZE, k);
-	}
-
-	/**
-	 * Deep copy of the given bytes data
-	 * 
-	 * @param k
-	 * @param newData
-	 *            : presumed NOT to have a header
-	 * @param offset
-	 */
-	@Override
-	public void setAsCopy(int k, byte[] newData, int offset) {
-		reset(k);
-		System.arraycopy(newData, offset, bytes, this.offset + HEADER_SIZE, k);
+		System.arraycopy(kmer.getBytes(), 0, bytes, offset, bytesUsed);
 	}
 
 	/**
@@ -149,8 +126,7 @@
 	public void setAsCopy(byte[] newData, int offset) {
 		int k = Marshal.getInt(newData, offset);
 		reset(k);
-		System.arraycopy(newData, offset + HEADER_SIZE, bytes, this.offset
-				+ HEADER_SIZE, k);
+		System.arraycopy(newData, offset + HEADER_SIZE, bytes, this.offset, bytesUsed);
 	}
 
 	/**
@@ -163,9 +139,9 @@
 	 */
 	public void setAsReference(byte[] newData, int offset) {
 		this.bytes = newData;
-		this.offset = offset;
+		this.offset = offset + HEADER_SIZE;
 		int kRequested = Marshal.getInt(newData, offset);
-		int bytesRequested = KmerUtil.getByteNumFromK(kRequested);
+		int bytesRequested = KmerUtil.getByteNumFromK(kRequested) + HEADER_SIZE;
 		if (newData.length - offset < bytesRequested) {
 			throw new IllegalArgumentException("Requested " + bytesRequested
 					+ " bytes (k=" + kRequested + ") but buffer has only "
@@ -176,164 +152,86 @@
 
 	@Override
 	public void setKmerLength(int k) {
-		this.bytesUsed = HEADER_SIZE + KmerUtil.getByteNumFromK(k);
+		this.bytesUsed = KmerUtil.getByteNumFromK(k);
 		this.lettersInKmer = k;
-		Marshal.putInt(k, bytes, offset);
+		Marshal.putInt(k, bytes, offset - HEADER_SIZE);
 	}
-
+	
 	@Override
-	public void setByRead(byte[] stringBytes, int start) {
-		offset += HEADER_SIZE;
-		super.setByRead(stringBytes, start);
-		offset -= HEADER_SIZE;
+	protected int getCapacity() {
+		return bytes.length - HEADER_SIZE;
 	}
-
+	
 	@Override
-	public void setByReadReverse(byte[] array, int start) {
-		offset += HEADER_SIZE;
-		super.setByReadReverse(array, start);
-		offset -= HEADER_SIZE;
+	protected void setCapacity(int new_cap) {
+		if (new_cap != getCapacity()) {
+			byte[] new_data = new byte[new_cap + HEADER_SIZE];
+			if (new_cap < bytesUsed) {
+				bytesUsed = new_cap;
+			}
+			if (bytesUsed != 0) {
+				System.arraycopy(bytes, offset, new_data, HEADER_SIZE, bytesUsed);
+			}
+			bytes = new_data;
+			offset = HEADER_SIZE;
+		}
 	}
 
-	@Override
-	public byte shiftKmerWithNextCode(byte c) {
-		offset += HEADER_SIZE;
-		byte retval = super.shiftKmerWithNextCode(c);
-		offset -= HEADER_SIZE;
-		return retval;
-
-	}
-
-	@Override
-	public byte shiftKmerWithPreCode(byte c) {
-		offset += HEADER_SIZE;
-		byte retval = super.shiftKmerWithPreCode(c);
-		offset -= HEADER_SIZE;
-		return retval;
-	}
 
 	@Override
 	public void mergeWithFFKmer(int initialKmerSize, KmerBytesWritable kmer) {
-		offset += HEADER_SIZE;
 		super.mergeWithFFKmer(initialKmerSize, kmer);
-		offset -= HEADER_SIZE;
-		Marshal.putInt(lettersInKmer, bytes, offset);
-	}
-
-	/**
-	 * Merge with kmer that's FF to me. See KmerBytesWritable.mergeWithFFKmer.
-	 */
-	public void mergeWithFFKmer(int initialKmerSize, VKmerBytesWritable kmer) {
-		offset += HEADER_SIZE;
-		kmer.offset += HEADER_SIZE;
-		super.mergeWithFFKmer(initialKmerSize, kmer);
-		offset -= HEADER_SIZE;
-		kmer.offset -= HEADER_SIZE;
-		Marshal.putInt(lettersInKmer, bytes, offset);
+		Marshal.putInt(lettersInKmer, bytes, offset - HEADER_SIZE);
 	}
 
 	@Override
 	public void mergeWithFRKmer(int initialKmerSize, KmerBytesWritable kmer) {
-		offset += HEADER_SIZE;
 		super.mergeWithFRKmer(initialKmerSize, kmer);
-		offset -= HEADER_SIZE;
-		Marshal.putInt(lettersInKmer, bytes, offset);
-	}
-
-	/**
-	 * Merge with kmer that's FR to me. See KmerBytesWritable.mergeWithFRKmer.
-	 */
-	public void mergeWithFRKmer(int initialKmerSize, VKmerBytesWritable kmer) {
-		offset += HEADER_SIZE;
-		kmer.offset += HEADER_SIZE;
-		super.mergeWithFRKmer(initialKmerSize, kmer);
-		offset -= HEADER_SIZE;
-		kmer.offset -= HEADER_SIZE;
-		Marshal.putInt(lettersInKmer, bytes, offset);
+		Marshal.putInt(lettersInKmer, bytes, offset - HEADER_SIZE);
 	}
 
 	@Override
 	public void mergeWithRFKmer(int initialKmerSize, KmerBytesWritable preKmer) {
-		offset += HEADER_SIZE;
 		super.mergeWithRFKmer(initialKmerSize, preKmer);
-		offset -= HEADER_SIZE;
-		Marshal.putInt(lettersInKmer, bytes, offset);
-	}
-
-	/**
-	 * Merge with kmer that's RF to me. See KmerBytesWritable.mergeWithRFKmer.
-	 */
-	public void mergeWithRFKmer(int initialKmerSize, VKmerBytesWritable preKmer) {
-		offset += HEADER_SIZE;
-		preKmer.offset += HEADER_SIZE;
-		super.mergeWithRFKmer(initialKmerSize, preKmer);
-		offset -= HEADER_SIZE;
-		preKmer.offset -= HEADER_SIZE;
-		Marshal.putInt(lettersInKmer, bytes, offset);
+		Marshal.putInt(lettersInKmer, bytes, offset - HEADER_SIZE);
 	}
 
 	@Override
 	public void mergeWithRRKmer(int initialKmerSize, KmerBytesWritable preKmer) {
-		offset += HEADER_SIZE;
 		super.mergeWithRRKmer(initialKmerSize, preKmer);
-		offset -= HEADER_SIZE;
-		Marshal.putInt(lettersInKmer, bytes, offset);
-	}
-
-	/**
-	 * Merge with kmer that's RR to me. See KmerBytesWritable.mergeWithRRKmer.
-	 */
-	public void mergeWithRRKmer(int initialKmerSize, VKmerBytesWritable preKmer) {
-		offset += HEADER_SIZE;
-		preKmer.offset += HEADER_SIZE;
-		super.mergeWithRRKmer(initialKmerSize, preKmer);
-		offset -= HEADER_SIZE;
-		preKmer.offset -= HEADER_SIZE;
-		Marshal.putInt(lettersInKmer, bytes, offset);
-	}
-
-	@Override
-	protected void clearLeadBit() {
-		offset += HEADER_SIZE;
-		super.clearLeadBit();
-		offset -= HEADER_SIZE;
+		Marshal.putInt(lettersInKmer, bytes, offset - HEADER_SIZE);
 	}
 
 	@Override
 	public void readFields(DataInput in) throws IOException {
 		lettersInKmer = in.readInt();
-		bytesUsed = HEADER_SIZE + KmerUtil.getByteNumFromK(lettersInKmer);
+		bytesUsed = KmerUtil.getByteNumFromK(lettersInKmer);
 		if (lettersInKmer > 0) {
-			if (this.bytes.length < this.bytesUsed) {
-				this.bytes = new byte[this.bytesUsed];
-				this.offset = 0;
+			if (getCapacity() < this.bytesUsed) {
+				this.bytes = new byte[this.bytesUsed + HEADER_SIZE];
+				this.offset = HEADER_SIZE;
 			}
-			in.readFully(bytes, offset + HEADER_SIZE, bytesUsed - HEADER_SIZE);
+			in.readFully(bytes, offset, bytesUsed);
 		}
-		Marshal.putInt(lettersInKmer, bytes, offset);
+		Marshal.putInt(lettersInKmer, bytes, offset - HEADER_SIZE);
 	}
 
 	@Override
 	public void write(DataOutput out) throws IOException {
-		out.writeInt(lettersInKmer);
-		if (lettersInKmer > 0) {
-			out.write(bytes, offset + HEADER_SIZE, bytesUsed - HEADER_SIZE);
-		}
+		out.write(bytes, offset - HEADER_SIZE, bytesUsed + HEADER_SIZE);
 	}
 
 	@Override
 	public boolean equals(Object right) {
 		if (right instanceof VKmerBytesWritable) {
-			return this.lettersInKmer == ((VKmerBytesWritable) right).lettersInKmer
-					&& super.equals(right);
+			return super.equals(right); // compare bytes directly
 		} else if (right instanceof KmerBytesWritable) {
 			// for Kmers, we need to skip our header
 			KmerBytesWritable rightKmer = (KmerBytesWritable) right;
-			if (lettersInKmer != rightKmer.lettersInKmer) {
-				// break early
+			if (lettersInKmer != rightKmer.lettersInKmer) { // check length
 				return false;
 			}
-			for (int i = 0; i < lettersInKmer; i++) {
+			for (int i = 0; i < lettersInKmer; i++) { // check letters
 				if (bytes[i + HEADER_SIZE] != rightKmer.bytes[i]) {
 					return false;
 				}
@@ -346,7 +244,7 @@
 	@Override
 	public String toString() {
 		return KmerUtil.recoverKmerFrom(this.lettersInKmer, this.getBytes(),
-				offset + HEADER_SIZE, this.getLength());
+				offset, this.getLength());
 	}
 
 	public static class Comparator extends WritableComparator {
diff --git a/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/KmerBytesWritableTest.java b/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/KmerBytesWritableTest.java
index 3a8fb93..807ac13 100644
--- a/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/KmerBytesWritableTest.java
+++ b/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/KmerBytesWritableTest.java
@@ -229,14 +229,24 @@
         merge.mergeWithRFKmer(i, kmer2);
         Assert.assertEquals("GGCACAACAACCC", merge.toString());
         
-        String test1 = "CTA";
-        String test2 = "AGA";
-        KmerBytesWritable k1 = new KmerBytesWritable(3);
-        KmerBytesWritable k2 = new KmerBytesWritable(3);
-        k1.setByRead(test1.getBytes(), 0);
-        k2.setByRead(test2.getBytes(), 0);
-        k1.mergeWithRFKmer(3, k2);
-        Assert.assertEquals("CTAT", k1);
+//        String test1 = "CTTAT";
+//        String test2 = "AGACC";  // rc = GGTCT
+//        KmerBytesWritable k1 = new KmerBytesWritable(5);
+//        KmerBytesWritable k2 = new KmerBytesWritable(5);
+//        k1.setByRead(test1.getBytes(), 0);
+//        k2.setByRead(test2.getBytes(), 0);
+//        k1.mergeWithRFKmer(3, k2);
+//        Assert.assertEquals("GGTCTTAT", k1.toString());  //GGTCGTCT  -> AGACGACC ??
+        
+        String test3 = "CTA";
+        String test4 = "AGA";  // rc = TCT
+        KmerBytesWritable k3 = new KmerBytesWritable(3);
+        KmerBytesWritable k4 = new KmerBytesWritable(3);
+        k3.setByRead(test3.getBytes(), 0);
+        k4.setByRead(test4.getBytes(), 0);
+        k3.mergeWithRFKmer(3, k4);
+        Assert.assertEquals("TCTA", k3.toString());
+//        Assert.assertEquals("CTAT", k3);  // this is an incorrect test case-- the merge always flips the passed-in kmer
     }
     
     
@@ -282,4 +292,22 @@
         }
     }
 
+    @Test
+    public void TestMergeRFAndRRKmer() {
+    	String test1 = "TAGAT";
+    	String test2 = "TCTAG";  // rc = CTAGA
+    	String test3 = "GCTAG";
+    	KmerBytesWritable k1 = new KmerBytesWritable(5);
+        KmerBytesWritable k2 = new KmerBytesWritable(5);
+        KmerBytesWritable k3 = new KmerBytesWritable(5);
+        k1.setByRead(test1.getBytes(), 0);
+        k2.setByRead(test2.getBytes(), 0);
+        k3.setByRead(test3.getBytes(), 0);
+        k1.mergeWithRFKmer(5, k2);
+        Assert.assertEquals("CTAGAT", k1.toString());
+        k1.mergeWithRRKmer(5, k3);
+        Assert.assertEquals("GCTAGAT", k1.toString());
+    }
 }
+
+
diff --git a/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/VKmerBytesWritableTest.java b/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/VKmerBytesWritableTest.java
new file mode 100644
index 0000000..0506a08
--- /dev/null
+++ b/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/VKmerBytesWritableTest.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright 2009-2012 by The Regents of the University of California
+ * Licensed 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 from
+ *
+ *     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 edu.uci.ics.genomix.data.test;
+
+import junit.framework.Assert;
+
+import org.junit.Test;
+
+import edu.uci.ics.genomix.type.GeneCode;
+import edu.uci.ics.genomix.type.VKmerBytesWritable;
+
+public class VKmerBytesWritableTest {
+	static byte[] array = { 'A', 'A', 'T', 'A', 'G', 'A', 'A', 'G' };
+	static int k = 7;
+
+	@Test
+	public void TestCompressKmer() {
+		VKmerBytesWritable kmer = new VKmerBytesWritable(k);
+		kmer.setByRead(array, 0);
+		Assert.assertEquals(kmer.toString(), "AATAGAA");
+
+		kmer.setByRead(array, 1);
+		Assert.assertEquals(kmer.toString(), "ATAGAAG");
+	}
+
+	@Test
+	public void TestMoveKmer() {
+		VKmerBytesWritable kmer = new VKmerBytesWritable(k);
+		kmer.setByRead(array, 0);
+		Assert.assertEquals(kmer.toString(), "AATAGAA");
+
+		for (int i = k; i < array.length - 1; i++) {
+			kmer.shiftKmerWithNextCode(array[i]);
+			Assert.assertTrue(false);
+		}
+
+		byte out = kmer.shiftKmerWithNextChar(array[array.length - 1]);
+		Assert.assertEquals(out, GeneCode.getCodeFromSymbol((byte) 'A'));
+		Assert.assertEquals(kmer.toString(), "ATAGAAG");
+	}
+
+	@Test
+	public void TestCompressKmerReverse() {
+		VKmerBytesWritable kmer = new VKmerBytesWritable(k);
+		kmer.setByRead(array, 0);
+		Assert.assertEquals(kmer.toString(), "AATAGAA");
+
+		kmer.setByReadReverse(array, 1);
+		Assert.assertEquals(kmer.toString(), "CTTCTAT");
+	}
+
+	@Test
+	public void TestMoveKmerReverse() {
+		VKmerBytesWritable kmer = new VKmerBytesWritable(k);
+		kmer.setByRead(array, 0);
+		Assert.assertEquals(kmer.toString(), "AATAGAA");
+
+		for (int i = k; i < array.length - 1; i++) {
+			kmer.shiftKmerWithPreChar(array[i]);
+			Assert.assertTrue(false);
+		}
+
+		byte out = kmer.shiftKmerWithPreChar(array[array.length - 1]);
+		Assert.assertEquals(out, GeneCode.getCodeFromSymbol((byte) 'A'));
+		Assert.assertEquals(kmer.toString(), "GAATAGA");
+	}
+
+	@Test
+	public void TestGetGene() {
+		VKmerBytesWritable kmer = new VKmerBytesWritable(9);
+		String text = "AGCTGACCG";
+		byte[] array = { 'A', 'G', 'C', 'T', 'G', 'A', 'C', 'C', 'G' };
+		kmer.setByRead(array, 0);
+
+		for (int i = 0; i < 9; i++) {
+			Assert.assertEquals(text.charAt(i), (char) (GeneCode
+					.getSymbolFromCode(kmer.getGeneCodeAtPosition(i))));
+		}
+	}
+
+	@Test
+	public void TestGetOneByteFromKmer() {
+		byte[] array = { 'A', 'G', 'C', 'T', 'G', 'A', 'C', 'C', 'G', 'T' };
+		String string = "AGCTGACCGT";
+		for (int k = 3; k <= 10; k++) {
+			VKmerBytesWritable kmer = new VKmerBytesWritable(k);
+			VKmerBytesWritable kmerAppend = new VKmerBytesWritable(k);
+			kmer.setByRead(array, 0);
+			Assert.assertEquals(string.substring(0, k), kmer.toString());
+			for (int b = 0; b < k; b++) {
+				byte byteActual = VKmerBytesWritable
+						.getOneByteFromKmerAtPosition(b, kmer.getBytes(),
+								kmer.getOffset(), kmer.getLength());
+				byte byteExpect = GeneCode.getCodeFromSymbol(array[b]);
+				for (int i = 1; i < 4 && b + i < k; i++) {
+					byteExpect += GeneCode.getCodeFromSymbol(array[b + i]) << (i * 2);
+				}
+				Assert.assertEquals(byteActual, byteExpect);
+				VKmerBytesWritable.appendOneByteAtPosition(b, byteActual,
+						kmerAppend.getBytes(), kmerAppend.getOffset(),
+						kmerAppend.getLength());
+			}
+			Assert.assertEquals(kmer.toString(), kmerAppend.toString());
+		}
+	}
+
+	@Test
+	public void TestMergeFFKmer() {
+		byte[] array = { 'A', 'G', 'C', 'T', 'G', 'A', 'C', 'C', 'G', 'T' };
+		String text = "AGCTGACCGT";
+		VKmerBytesWritable kmer1 = new VKmerBytesWritable(8);
+		kmer1.setByRead(array, 0);
+		String text1 = "AGCTGACC";
+		Assert.assertEquals(text1, kmer1.toString());
+		
+		VKmerBytesWritable kmer2 = new VKmerBytesWritable(8);
+		kmer2.setByRead(array, 1);
+		String text2 = "GCTGACCG";
+		Assert.assertEquals(text2, kmer2.toString());
+		
+		VKmerBytesWritable merge = new VKmerBytesWritable(kmer1);
+		int kmerSize = 8;
+		merge.mergeWithFFKmer(kmerSize, kmer2);
+		Assert.assertEquals(text1 + text2.substring(kmerSize - 1),
+				merge.toString());
+
+		for (int i = 1; i < 8; i++) {
+			merge.setAsCopy(kmer1);
+			merge.mergeWithFFKmer(i, kmer2);
+			Assert.assertEquals(text1 + text2.substring(i - 1),
+					merge.toString());
+		}
+
+		for (int ik = 1; ik <= 10; ik++) {
+			for (int jk = 1; jk <= 10; jk++) {
+				kmer1 = new VKmerBytesWritable(ik);
+				kmer2 = new VKmerBytesWritable(jk);
+				kmer1.setByRead(array, 0);
+				kmer2.setByRead(array, 0);
+				text1 = text.substring(0, ik);
+				text2 = text.substring(0, jk);
+				Assert.assertEquals(text1, kmer1.toString());
+				Assert.assertEquals(text2, kmer2.toString());
+				for (int x = 1; x < jk; x++) {
+					merge.setAsCopy(kmer1);
+					merge.mergeWithFFKmer(x, kmer2);
+					Assert.assertEquals(text1 + text2.substring(x - 1),
+							merge.toString());
+				}
+			}
+		}
+	}
+
+	@Test
+	public void TestMergeFRKmer() {
+		int kmerSize = 3;
+		String result = "AAGCTAACAACC";
+		byte[] resultArray = result.getBytes();
+
+		String text1 = "AAGCTAA";
+		VKmerBytesWritable kmer1 = new VKmerBytesWritable(text1.length());
+		kmer1.setByRead(resultArray, 0);
+		Assert.assertEquals(text1, kmer1.toString());
+
+		// kmer2 is the rc of the end of the read
+		String text2 = "GGTTGTT";
+		VKmerBytesWritable kmer2 = new VKmerBytesWritable(text2.length());
+		kmer2.setByReadReverse(resultArray, result.length() - text2.length());
+		Assert.assertEquals(text2, kmer2.toString());
+
+		VKmerBytesWritable merge = new VKmerBytesWritable(kmer1);
+		merge.mergeWithFRKmer(kmerSize, kmer2);
+		Assert.assertEquals(result, merge.toString());
+
+		int i = 1;
+		merge.setAsCopy(kmer1);
+		merge.mergeWithFRKmer(i, kmer2);
+		Assert.assertEquals("AAGCTAAAACAACC", merge.toString());
+
+		i = 2;
+		merge.setAsCopy(kmer1);
+		merge.mergeWithFRKmer(i, kmer2);
+		Assert.assertEquals("AAGCTAAACAACC", merge.toString());
+
+		i = 3;
+		merge.setAsCopy(kmer1);
+		merge.mergeWithFRKmer(i, kmer2);
+		Assert.assertEquals("AAGCTAACAACC", merge.toString());
+	}
+
+	@Test
+	public void TestMergeRFKmer() {
+		int kmerSize = 3;
+		String result = "GGCACAACAACCC";
+		byte[] resultArray = result.getBytes();
+
+		String text1 = "AACAACCC";
+		VKmerBytesWritable kmer1 = new VKmerBytesWritable(text1.length());
+		kmer1.setByRead(resultArray, 5);
+		Assert.assertEquals(text1, kmer1.toString());
+
+		// kmer2 is the rc of the end of the read
+		String text2 = "TTGTGCC";
+		VKmerBytesWritable kmer2 = new VKmerBytesWritable(text2.length());
+		kmer2.setByReadReverse(resultArray, 0);
+		Assert.assertEquals(text2, kmer2.toString());
+
+		VKmerBytesWritable merge = new VKmerBytesWritable(kmer1);
+		merge.mergeWithRFKmer(kmerSize, kmer2);
+		Assert.assertEquals(result, merge.toString());
+
+		int i = 1;
+		merge.setAsCopy(kmer1);
+		merge.mergeWithRFKmer(i, kmer2);
+		Assert.assertEquals("GGCACAAAACAACCC", merge.toString());
+
+		i = 2;
+		merge.setAsCopy(kmer1);
+		merge.mergeWithRFKmer(i, kmer2);
+		Assert.assertEquals("GGCACAAACAACCC", merge.toString());
+
+		i = 3;
+		merge.setAsCopy(kmer1);
+		merge.mergeWithRFKmer(i, kmer2);
+		Assert.assertEquals("GGCACAACAACCC", merge.toString());
+
+		// String test1 = "CTTAT";
+		// String test2 = "AGACC"; // rc = GGTCT
+		// VKmerBytesWritable k1 = new VKmerBytesWritable(5);
+		// VKmerBytesWritable k2 = new VKmerBytesWritable(5);
+		// k1.setByRead(test1.getBytes(), 0);
+		// k2.setByRead(test2.getBytes(), 0);
+		// k1.mergeWithRFKmer(3, k2);
+		// Assert.assertEquals("GGTCTTAT", k1.toString()); //GGTCGTCT ->
+		// AGACGACC ??
+
+		String test3 = "CTA";
+		String test4 = "AGA"; // rc = TCT
+		VKmerBytesWritable k3 = new VKmerBytesWritable(3);
+		VKmerBytesWritable k4 = new VKmerBytesWritable(3);
+		k3.setByRead(test3.getBytes(), 0);
+		k4.setByRead(test4.getBytes(), 0);
+		k3.mergeWithRFKmer(3, k4);
+		Assert.assertEquals("TCTA", k3.toString());
+		// Assert.assertEquals("CTAT", k3); // this is an incorrect test case--
+		// the merge always flips the passed-in kmer
+	}
+
+	@Test
+	public void TestMergeRRKmer() {
+		byte[] array = { 'A', 'G', 'C', 'T', 'G', 'A', 'C', 'C', 'G', 'T' };
+		String text = "AGCTGACCGT";
+		VKmerBytesWritable kmer1 = new VKmerBytesWritable(8);
+		kmer1.setByRead(array, 0);
+		String text1 = "AGCTGACC";
+		VKmerBytesWritable kmer2 = new VKmerBytesWritable(8);
+		kmer2.setByRead(array, 1);
+		String text2 = "GCTGACCG";
+		Assert.assertEquals(text2, kmer2.toString());
+		VKmerBytesWritable merge = new VKmerBytesWritable(kmer2);
+		int kmerSize = 8;
+		merge.mergeWithRRKmer(kmerSize, kmer1);
+		Assert.assertEquals(text1 + text2.substring(kmerSize - 1),
+				merge.toString());
+
+		for (int i = 1; i < 8; i++) {
+			merge.setAsCopy(kmer2);
+			merge.mergeWithRRKmer(i, kmer1);
+			Assert.assertEquals(text1.substring(0, text1.length() - i + 1)
+					+ text2, merge.toString());
+		}
+
+		for (int ik = 1; ik <= 10; ik++) {
+			for (int jk = 1; jk <= 10; jk++) {
+				kmer1 = new VKmerBytesWritable(ik);
+				kmer2 = new VKmerBytesWritable(jk);
+				kmer1.setByRead(array, 0);
+				kmer2.setByRead(array, 0);
+				text1 = text.substring(0, ik);
+				text2 = text.substring(0, jk);
+				Assert.assertEquals(text1, kmer1.toString());
+				Assert.assertEquals(text2, kmer2.toString());
+				for (int x = 1; x < ik; x++) {
+					merge.setAsCopy(kmer2);
+					merge.mergeWithRRKmer(x, kmer1);
+					Assert.assertEquals(
+							text1.substring(0, text1.length() - x + 1) + text2,
+							merge.toString());
+				}
+			}
+		}
+	}
+
+	@Test
+	public void TestMergeRFAndRRKmer() {
+		String test1 = "TAGAT";
+		String test2 = "TCTAG"; // rc = CTAGA
+		String test3 = "GCTAG";
+		VKmerBytesWritable k1 = new VKmerBytesWritable(5);
+		VKmerBytesWritable k2 = new VKmerBytesWritable(5);
+		VKmerBytesWritable k3 = new VKmerBytesWritable(5);
+		k1.setByRead(test1.getBytes(), 0);
+		k2.setByRead(test2.getBytes(), 0);
+		k3.setByRead(test3.getBytes(), 0);
+		k1.mergeWithRFKmer(5, k2);
+		Assert.assertEquals("CTAGAT", k1.toString());
+		k1.mergeWithRRKmer(5, k3);
+		Assert.assertEquals("GCTAGAT", k1.toString());
+	}
+}