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 b2af5ee..6c02468 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
@@ -1,9 +1,5 @@
 package edu.uci.ics.genomix.type;
 
-import java.io.DataInput;
-import java.io.DataOutput;
-import java.io.IOException;
-
 import org.apache.hadoop.io.WritableComparator;
 
 public class VKmerBytesWritable extends KmerBytesWritable {
diff --git a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/old/Kmer.java b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/old/Kmer.java
new file mode 100644
index 0000000..ee806cc
--- /dev/null
+++ b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/old/Kmer.java
@@ -0,0 +1,285 @@
+package edu.uci.ics.genomix.type.old;
+
+@Deprecated
+public class Kmer {
+    
+    public final static byte[] GENE_SYMBOL = { 'A', 'C', 'G', 'T' };
+
+    public final static class GENE_CODE {
+
+        /**
+         * make sure this 4 ids equal to the sequence id of char in
+         * {@GENE_SYMBOL}
+         */
+        public static final byte A = 0;
+        public static final byte C = 1;
+        public static final byte G = 2;
+        public static final byte T = 3;
+
+        public static byte getCodeFromSymbol(byte ch) {
+            byte r = 0;
+            switch (ch) {
+            case 'A':
+            case 'a':
+                r = A;
+                break;
+            case 'C':
+            case 'c':
+                r = C;
+                break;
+            case 'G':
+            case 'g':
+                r = G;
+                break;
+            case 'T':
+            case 't':
+                r = T;
+                break;
+            }
+            return r;
+        }
+
+        public static byte getSymbolFromCode(byte code) {
+            if (code > 3) {
+                return '!';
+            }
+            return GENE_SYMBOL[code];
+        }
+
+        public static byte getAdjBit(byte t) {
+            byte r = 0;
+            switch (t) {
+            case 'A':
+            case 'a':
+                r = 1 << A;
+                break;
+            case 'C':
+            case 'c':
+                r = 1 << C;
+                break;
+            case 'G':
+            case 'g':
+                r = 1 << G;
+                break;
+            case 'T':
+            case 't':
+                r = 1 << T;
+                break;
+            }
+            return r;
+        }
+
+        /** 
+         * It works for path merge. 
+         * Merge the kmer by his next, we need to make sure the @{t} is a single neighbor.
+         * @param t the neighbor code in BitMap
+         * @return the genecode 
+         */
+        public static byte getGeneCodeFromBitMap(byte t) {
+            switch (t) {
+            case 1 << A:
+                return A;
+            case 1 << C:
+                return C;
+            case 1 << G:
+                return G;
+            case 1 << T:
+                return T;
+            }
+            return -1;
+        }
+
+        public static byte mergePreNextAdj(byte pre, byte next) {
+            return (byte) (pre << 4 | (next & 0x0f));
+        }
+
+        public static String getSymbolFromBitMap(byte code) {
+            int left = (code >> 4) & 0x0F;
+            int right = code & 0x0F;
+            StringBuilder str = new StringBuilder();
+            for (int i = A; i <= T; i++) {
+                if ((left & (1 << i)) != 0) {
+                    str.append((char) GENE_SYMBOL[i]);
+                }
+            }
+            str.append('|');
+            for (int i = A; i <= T; i++) {
+                if ((right & (1 << i)) != 0) {
+                    str.append((char) GENE_SYMBOL[i]);
+                }
+            }
+            return str.toString();
+        }
+    }
+
+    public static String recoverKmerFrom(int k, byte[] keyData, int keyStart,
+            int keyLength) {
+        StringBuilder strKmer = new StringBuilder();
+        int byteId = keyStart + keyLength - 1;
+        byte currentbyte = keyData[byteId];
+        for (int geneCount = 0; geneCount < k; geneCount++) {
+            if (geneCount % 4 == 0 && geneCount > 0) {
+                currentbyte = keyData[--byteId];
+            }
+            strKmer.append((char) GENE_SYMBOL[(currentbyte >> ((geneCount % 4) * 2)) & 0x03]);
+        }
+        return strKmer.toString();
+    }
+
+    public static int getByteNumFromK(int k) {
+        int x = k / 4;
+        if (k % 4 != 0) {
+            x += 1;
+        }
+        return x;
+    }
+
+    /**
+     * Compress Kmer into bytes array AATAG will compress as [0x000G, 0xATAA]
+     * 
+     * @param kmer
+     * @param input
+     *            array
+     * @param start
+     *            position
+     * @return initialed kmer array
+     */
+    public static byte[] compressKmer(int k, byte[] array, int start) {
+        final int byteNum = getByteNumFromK(k);
+        byte[] bytes = new byte[byteNum];
+
+        byte l = 0;
+        int bytecount = 0;
+        int bcount = byteNum - 1;
+        for (int i = start; i < start + k; i++) {
+            byte code = GENE_CODE.getCodeFromSymbol(array[i]);
+            l |= (byte) (code << bytecount);
+            bytecount += 2;
+            if (bytecount == 8) {
+                bytes[bcount--] = l;
+                l = 0;
+                bytecount = 0;
+            }
+        }
+        if (bcount >= 0) {
+            bytes[0] = l;
+        }
+        return bytes;
+    }
+
+    /**
+     * Shift Kmer to accept new input
+     * 
+     * @param kmer
+     * @param bytes
+     *            Kmer Array
+     * @param c
+     *            Input new gene character
+     * @return the shiftout gene, in gene code format
+     */
+    public static byte moveKmer(int k, byte[] kmer, byte c) {
+        int byteNum = kmer.length;
+        byte output = (byte) (kmer[byteNum - 1] & 0x03);
+        for (int i = byteNum - 1; i > 0; i--) {
+            byte in = (byte) (kmer[i - 1] & 0x03);
+            kmer[i] = (byte) (((kmer[i] >>> 2) & 0x3f) | (in << 6));
+        }
+        int pos = ((k - 1) % 4) << 1;
+        byte code = (byte) (GENE_CODE.getCodeFromSymbol(c) << pos);
+        kmer[0] = (byte) (((kmer[0] >>> 2) & 0x3f) | code);
+        return (byte) (1 << output);
+    }
+
+    public static byte reverseKmerByte(byte k) {
+        int x = (((k >> 2) & 0x33) | ((k << 2) & 0xcc));
+        return (byte) (((x >> 4) & 0x0f) | ((x << 4) & 0xf0));
+    }
+
+    public static byte[] reverseKmer(int k, byte[] kmer) {
+        byte[] reverseKmer = new byte[kmer.length];
+
+        int curPosAtKmer = ((k - 1) % 4) << 1;
+        int curByteAtKmer = 0;
+
+        int curPosAtReverse = 0;
+        int curByteAtReverse = reverseKmer.length - 1;
+        reverseKmer[curByteAtReverse] = 0;
+        for (int i = 0; i < k; i++) {
+            byte gene = (byte) ((kmer[curByteAtKmer] >> curPosAtKmer) & 0x03);
+            reverseKmer[curByteAtReverse] |= gene << curPosAtReverse;
+            curPosAtReverse += 2;
+            if (curPosAtReverse >= 8) {
+                curPosAtReverse = 0;
+                reverseKmer[--curByteAtReverse] = 0;
+            }
+            curPosAtKmer -= 2;
+            if (curPosAtKmer < 0) {
+                curPosAtKmer = 6;
+                curByteAtKmer++;
+            }
+        }
+
+        return reverseKmer;
+    }
+
+    /**
+     * Compress Reversed Kmer into bytes array AATAG will compress as
+     * [0x000A,0xATAG]
+     * 
+     * @param kmer
+     * @param input
+     *            array
+     * @param start
+     *            position
+     * @return initialed kmer array
+     */
+    public static byte[] compressKmerReverse(int k, byte[] array, int start) {
+        final int byteNum = getByteNumFromK(k);
+        byte[] bytes = new byte[byteNum];
+
+        byte l = 0;
+        int bytecount = 0;
+        int bcount = byteNum - 1;
+        for (int i = start + k - 1; i >= 0; i--) {
+            byte code = GENE_CODE.getCodeFromSymbol(array[i]);
+            l |= (byte) (code << bytecount);
+            bytecount += 2;
+            if (bytecount == 8) {
+                bytes[bcount--] = l;
+                l = 0;
+                bytecount = 0;
+            }
+        }
+        if (bcount >= 0) {
+            bytes[0] = l;
+        }
+        return bytes;
+    }
+
+    /**
+     * Shift Kmer to accept new input
+     * 
+     * @param kmer
+     * @param bytes
+     *            Kmer Array
+     * @param c
+     *            Input new gene character
+     * @return the shiftout gene, in gene code format
+     */
+    public static byte moveKmerReverse(int k, byte[] kmer, byte c) {
+        int pos = ((k - 1) % 4) << 1;
+        byte output = (byte) ((kmer[0] >> pos) & 0x03);
+        for (int i = 0; i < kmer.length - 1; i++) {
+            byte in = (byte) ((kmer[i + 1] >> 6) & 0x03);
+            kmer[i] = (byte) ((kmer[i] << 2) | in);
+        }
+        // (k%4) * 2
+        if (k % 4 != 0) {
+            kmer[0] &= (1 << ((k % 4) << 1)) - 1;
+        }
+        kmer[kmer.length - 1] = (byte) ((kmer[kmer.length - 1] << 2) | GENE_CODE
+                .getCodeFromSymbol(c));
+        return (byte) (1 << output);
+    }
+
+}
diff --git a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/old/KmerBytesWritable.java b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/old/KmerBytesWritable.java
new file mode 100644
index 0000000..dd76427
--- /dev/null
+++ b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/old/KmerBytesWritable.java
@@ -0,0 +1,138 @@
+package edu.uci.ics.genomix.type.old;
+
+import java.io.IOException;
+import java.io.DataInput;
+import java.io.DataOutput;
+import org.apache.hadoop.io.BinaryComparable;
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+@Deprecated
+public class KmerBytesWritable extends BinaryComparable implements
+        WritableComparable<BinaryComparable> {
+    private static final int LENGTH_BYTES = 4;
+    private static final byte[] EMPTY_BYTES = {};
+    private byte size;
+    private byte[] bytes;
+
+    public KmerBytesWritable() {
+        this(EMPTY_BYTES);
+    }
+
+    public KmerBytesWritable(byte[] bytes) {
+        this.bytes = bytes;
+        this.size = (byte) bytes.length;
+    }
+
+    @Override
+    public byte[] getBytes() {
+        return bytes;
+    }
+
+    @Deprecated
+    public byte[] get() {
+        return getBytes();
+    }
+
+    @Override
+    public int getLength() {
+        return (int) size;
+    }
+
+    @Deprecated
+    public int getSize() {
+        return getLength();
+    }
+
+    public void setSize(byte size) {
+        if ((int) size > getCapacity()) {
+            setCapacity((byte) (size * 3 / 2));
+        }
+        this.size = size;
+    }
+
+    public int getCapacity() {
+        return bytes.length;
+    }
+
+    public void setCapacity(byte new_cap) {
+        if (new_cap != getCapacity()) {
+            byte[] new_data = new byte[new_cap];
+            if (new_cap < size) {
+                size = new_cap;
+            }
+            if (size != 0) {
+                System.arraycopy(bytes, 0, new_data, 0, size);
+            }
+            bytes = new_data;
+        }
+    }
+
+    public void set(KmerBytesWritable newData) {
+        set(newData.bytes, (byte) 0, newData.size);
+    }
+
+    public void set(byte[] newData, byte offset, byte length) {
+        setSize((byte) 0);
+        setSize(length);
+        System.arraycopy(newData, offset, bytes, 0, size);
+    }
+
+    public void readFields(DataInput in) throws IOException {
+        setSize((byte) 0); // clear the old data
+        setSize(in.readByte());
+        in.readFully(bytes, 0, size);
+    }
+
+    @Override
+    public void write(DataOutput out) throws IOException {
+        out.writeByte(size);
+        out.write(bytes, 0, size);
+    }
+
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object right_obj) {
+        if (right_obj instanceof KmerBytesWritable)
+            return super.equals(right_obj);
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        StringBuffer sb = new StringBuffer(3 * size);
+        for (int idx = 0; idx < (int) size; idx++) {
+            // if not the first, put a blank separator in
+            if (idx != 0) {
+                sb.append(' ');
+            }
+            String num = Integer.toHexString(0xff & bytes[idx]);
+            // if it is only one digit, add a leading 0.
+            if (num.length() < 2) {
+                sb.append('0');
+            }
+            sb.append(num);
+        }
+        return sb.toString();
+    }
+
+    public static class Comparator extends WritableComparator {
+        public Comparator() {
+            super(KmerBytesWritable.class);
+        }
+
+        public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
+            return compareBytes(b1, s1 + LENGTH_BYTES, l1 - LENGTH_BYTES, b2,
+                    s2 + LENGTH_BYTES, l2 - LENGTH_BYTES);
+        }
+    }
+
+    static { // register this comparator
+        WritableComparator.define(KmerBytesWritable.class, new Comparator());
+    }
+
+}
diff --git a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/old/KmerUtil.java b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/old/KmerUtil.java
new file mode 100644
index 0000000..7e9d2f3
--- /dev/null
+++ b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/old/KmerUtil.java
@@ -0,0 +1,223 @@
+package edu.uci.ics.genomix.type.old;
+
+import java.util.Arrays;
+
+@Deprecated
+public class KmerUtil {
+
+    public static int countNumberOfBitSet(int i) {
+        int c = 0;
+        for (; i != 0; c++) {
+            i &= i - 1;
+        }
+        return c;
+    }
+
+    public static int inDegree(byte bitmap) {
+        return countNumberOfBitSet((bitmap >> 4) & 0x0f);
+    }
+
+    public static int outDegree(byte bitmap) {
+        return countNumberOfBitSet(bitmap & 0x0f);
+    }
+
+    /**
+     * Get last kmer from kmer-chain. 
+     * e.g. kmerChain is AAGCTA, if k =5, it will
+     * return AGCTA
+     * @param k
+     * @param kInChain
+     * @param kmerChain
+     * @return LastKmer bytes array
+     */
+    public static byte[] getLastKmerFromChain(int k, int kInChain,
+            byte[] kmerChain, int offset, int length) {
+        if (k > kInChain) {
+            return null;
+        }
+        if (k == kInChain) {
+            return kmerChain.clone();
+        }
+        int byteNum = Kmer.getByteNumFromK(k);
+        byte[] kmer = new byte[byteNum];
+
+        /** from end to start */
+        int byteInChain = length - 1 - (kInChain - k) / 4;
+        int posInByteOfChain = ((kInChain - k) % 4) << 1; // *2
+        int byteInKmer = byteNum - 1;
+        for (; byteInKmer >= 0 && byteInChain > 0; byteInKmer--, byteInChain--) {
+            kmer[byteInKmer] = (byte) ((0xff & kmerChain[offset + byteInChain]) >> posInByteOfChain);
+            kmer[byteInKmer] |= ((kmerChain[offset + byteInChain - 1] << (8 - posInByteOfChain)));
+        }
+
+        /** last kmer byte */
+        if (byteInKmer == 0) {
+            kmer[0] = (byte) ((kmerChain[offset] & 0xff) >> posInByteOfChain);
+        }
+        return kmer;
+    }
+
+    /**
+     * Get first kmer from kmer-chain e.g. kmerChain is AAGCTA, if k=5, it will
+     * return AAGCT
+     * 
+     * @param k
+     * @param kInChain
+     * @param kmerChain
+     * @return FirstKmer bytes array
+     */
+    public static byte[] getFirstKmerFromChain(int k, int kInChain,
+            byte[] kmerChain, int offset, int length) {
+        if (k > kInChain) {
+            return null;
+        }
+        if (k == kInChain) {
+            return kmerChain.clone();
+        }
+        int byteNum = Kmer.getByteNumFromK(k);
+        byte[] kmer = new byte[byteNum];
+
+        int i = 1;
+        for (; i < kmer.length; i++) {
+            kmer[kmer.length - i] = kmerChain[offset + length - i];
+        }
+        int posInByteOfChain = (k % 4) << 1; // *2
+        if (posInByteOfChain == 0) {
+            kmer[0] = kmerChain[offset + length - i];
+        } else {
+            kmer[0] = (byte) (kmerChain[offset + length - i] & ((1 << posInByteOfChain) - 1));
+        }
+        return kmer;
+    }
+
+    /**
+     * Merge kmer with next neighbor in gene-code format.
+     * The k of new kmer will increase by 1
+     * e.g. AAGCT merge with A => AAGCTA
+     * @param k :input k of kmer
+     * @param kmer : input bytes of kmer
+     * @param nextCode: next neighbor in gene-code format
+     * @return the merged Kmer, this K of this Kmer is k+1
+     */
+    public static byte[] mergeKmerWithNextCode(int k, byte[] kmer, int offset, int length, byte nextCode) {
+        int byteNum = length;
+        if (k % 4 == 0) {
+            byteNum++;
+        }
+        byte[] mergedKmer = new byte[byteNum];
+        for (int i = 1; i <= length; i++) {
+            mergedKmer[mergedKmer.length - i] = kmer[offset + length - i];
+        }
+        if (mergedKmer.length > length) {
+            mergedKmer[0] = (byte) (nextCode & 0x3);
+        } else {
+            mergedKmer[0] = (byte) (kmer[offset] | ((nextCode & 0x3) << ((k % 4) << 1)));
+        }
+        return mergedKmer;
+    }
+
+    /**
+     * Merge kmer with previous neighbor in gene-code format.
+     * The k of new kmer will increase by 1
+     * e.g. AAGCT merge with A => AAAGCT
+     * @param k :input k of kmer
+     * @param kmer : input bytes of kmer
+     * @param preCode: next neighbor in gene-code format
+     * @return the merged Kmer,this K of this Kmer is k+1
+     */
+    public static byte[] mergeKmerWithPreCode(int k, byte[] kmer, int offset, int length, byte preCode) {
+        int byteNum = length;
+        byte[] mergedKmer = null;
+        int byteInMergedKmer = 0;
+        if (k % 4 == 0) {
+            byteNum++;
+            mergedKmer = new byte[byteNum];
+            mergedKmer[0] = (byte) ((kmer[offset] >> 6) & 0x3);
+            byteInMergedKmer++;
+        } else {
+            mergedKmer = new byte[byteNum];
+        }
+        for (int i = 0; i < length - 1; i++, byteInMergedKmer++) {
+            mergedKmer[byteInMergedKmer] = (byte) ((kmer[offset + i] << 2) | ((kmer[offset + i + 1] >> 6) & 0x3));
+        }
+        mergedKmer[byteInMergedKmer] = (byte) ((kmer[offset + length - 1] << 2) | (preCode & 0x3));
+        return mergedKmer;
+    }
+
+    /**
+     * Merge two kmer to one kmer
+     * e.g. ACTA + ACCGT => ACTAACCGT
+     * @param preK : previous k of kmer
+     * @param kmerPre : bytes array of previous kmer
+     * @param nextK : next k of kmer
+     * @param kmerNext : bytes array of next kmer
+     * @return merged kmer, the new k is @preK + @nextK
+     */
+    public static byte[] mergeTwoKmer(int preK, byte[] kmerPre, int offsetPre, int lengthPre, int nextK,
+            byte[] kmerNext, int offsetNext, int lengthNext) {
+        int byteNum = Kmer.getByteNumFromK(preK + nextK);
+        byte[] mergedKmer = new byte[byteNum];
+        int i = 1;
+        for (; i <= lengthPre; i++) {
+            mergedKmer[byteNum - i] = kmerPre[offsetPre + lengthPre - i];
+        }
+        if ( i > 1){
+            i--;
+        }
+        if (preK % 4 == 0) {
+            for (int j = 1; j <= lengthNext; j++) {
+                mergedKmer[byteNum - i - j] = kmerNext[offsetNext + lengthNext - j];
+            }
+        } else {
+            int posNeedToMove = ((preK % 4) << 1);
+            mergedKmer[byteNum - i] |= kmerNext[offsetNext + lengthNext - 1] << posNeedToMove;
+            for (int j = 1; j < lengthNext; j++) {
+                mergedKmer[byteNum - i - j] = (byte) (((kmerNext[offsetNext + lengthNext
+                        - j] & 0xff) >> (8 - posNeedToMove)) | (kmerNext[offsetNext + lengthNext
+                        - j - 1] << posNeedToMove));
+            }
+            if ( (nextK % 4) * 2 + posNeedToMove > 8) {
+                mergedKmer[0] = (byte) (kmerNext[offsetNext] >> (8 - posNeedToMove));
+            }
+        }
+        return mergedKmer;
+    }
+    
+    /**
+     * Safely shifted the kmer forward without change the input kmer
+     * e.g. AGCGC shift with T => GCGCT
+     * @param k: kmer length
+     * @param kmer: input kmer
+     * @param afterCode: input genecode 
+     * @return new created kmer that shifted by afterCode, the K will not change
+     */
+    public static byte[] shiftKmerWithNextCode(int k, final byte[] kmer, int offset, int length, byte afterCode){
+        byte[] shifted = Arrays.copyOfRange(kmer, offset, offset+length);
+        Kmer.moveKmer(k, shifted, Kmer.GENE_CODE.getSymbolFromCode(afterCode));
+        return shifted;
+    }
+    
+    /**
+     * Safely shifted the kmer backward without change the input kmer
+     * e.g. AGCGC shift with T => TAGCG
+     * @param k: kmer length
+     * @param kmer: input kmer
+     * @param preCode: input genecode 
+     * @return new created kmer that shifted by preCode, the K will not change
+     */
+    public static byte[] shiftKmerWithPreCode(int k, final byte[] kmer, int offset, int length, byte preCode){
+        byte[] shifted = Arrays.copyOfRange(kmer, offset, offset+length);
+        Kmer.moveKmerReverse(k, shifted, Kmer.GENE_CODE.getSymbolFromCode(preCode));
+        return shifted;
+    }
+
+    public static byte getGeneCodeAtPosition(int pos, int k, final byte[] kmer,
+            int offset, int length) {
+        if (pos >= k) {
+            return -1;
+        }
+        int posByte = pos / 4;
+        int shift = (pos  % 4) << 1;
+        return (byte) ((kmer[offset + length - 1 - posByte] >> shift) & 0x3);
+    }
+}
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/GraphVertexOperation.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/GraphVertexOperation.java
index 6a5299b..553de45 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/GraphVertexOperation.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/GraphVertexOperation.java
@@ -2,8 +2,8 @@
 
 import org.apache.hadoop.io.BytesWritable;
 
-import edu.uci.ics.genomix.type.Kmer;
-import edu.uci.ics.genomix.type.KmerUtil;
+import edu.uci.ics.genomix.type.old.Kmer;
+import edu.uci.ics.genomix.type.old.KmerUtil;
 
 public class GraphVertexOperation {
 	
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/LogAlgorithmForMergeGraphVertex.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/LogAlgorithmForMergeGraphVertex.java
index bd368cb..88c5c35 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/LogAlgorithmForMergeGraphVertex.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/LogAlgorithmForMergeGraphVertex.java
@@ -14,8 +14,8 @@
 import edu.uci.ics.genomix.pregelix.io.ValueStateWritable;
 import edu.uci.ics.genomix.pregelix.type.Message;
 import edu.uci.ics.genomix.pregelix.type.State;
-import edu.uci.ics.genomix.type.Kmer;
-import edu.uci.ics.genomix.type.KmerUtil;
+import edu.uci.ics.genomix.type.old.Kmer;
+import edu.uci.ics.genomix.type.old.KmerUtil;
 
 /*
  * vertexId: BytesWritable
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/MergeGraphVertex.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/MergeGraphVertex.java
index 067b70d..ec45019 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/MergeGraphVertex.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/MergeGraphVertex.java
@@ -5,8 +5,8 @@
 import org.apache.hadoop.io.BytesWritable;
 import org.apache.hadoop.io.NullWritable;
 
-import edu.uci.ics.genomix.type.Kmer;
-import edu.uci.ics.genomix.type.KmerUtil;
+import edu.uci.ics.genomix.type.old.Kmer;
+import edu.uci.ics.genomix.type.old.KmerUtil;
 import edu.uci.ics.pregelix.api.graph.Vertex;
 import edu.uci.ics.pregelix.api.job.PregelixJob;
 import edu.uci.ics.genomix.pregelix.client.Client;
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/format/LogAlgorithmForMergeGraphOutputFormat.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/format/LogAlgorithmForMergeGraphOutputFormat.java
index 9cea793..865a787 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/format/LogAlgorithmForMergeGraphOutputFormat.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/format/LogAlgorithmForMergeGraphOutputFormat.java
@@ -13,7 +13,7 @@
 import edu.uci.ics.pregelix.api.io.VertexWriter;
 import edu.uci.ics.genomix.pregelix.io.ValueStateWritable;
 import edu.uci.ics.genomix.pregelix.type.State;
-import edu.uci.ics.genomix.type.Kmer;
+import edu.uci.ics.genomix.type.old.Kmer;
 
 public class LogAlgorithmForMergeGraphOutputFormat extends 
 	BinaryVertexOutputFormat<BytesWritable, ValueStateWritable, NullWritable> {
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/io/ValueStateWritable.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/io/ValueStateWritable.java
index f101d7f..ffc1d38 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/io/ValueStateWritable.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/io/ValueStateWritable.java
@@ -5,7 +5,7 @@
 import org.apache.hadoop.io.WritableComparable;
 
 import edu.uci.ics.genomix.pregelix.type.State;
-import edu.uci.ics.genomix.type.Kmer;
+import edu.uci.ics.genomix.type.old.Kmer;
 
 
 public class ValueStateWritable implements WritableComparable<ValueStateWritable> {
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/DataLoadLogFormatter.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/DataLoadLogFormatter.java
index f5ddfc6..7e56a66 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/DataLoadLogFormatter.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/DataLoadLogFormatter.java
@@ -6,7 +6,7 @@
 
 import org.apache.hadoop.io.BytesWritable;
 
-import edu.uci.ics.genomix.type.Kmer;
+import edu.uci.ics.genomix.type.old.Kmer;
 import edu.uci.ics.genomix.type.KmerCountValue;
 
 public class DataLoadLogFormatter extends Formatter{
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/LogAlgorithmLogFormatter.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/LogAlgorithmLogFormatter.java
index e0d241a..3af9b6f 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/LogAlgorithmLogFormatter.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/LogAlgorithmLogFormatter.java
@@ -5,7 +5,7 @@
 import edu.uci.ics.genomix.pregelix.io.LogAlgorithmMessageWritable;
 import edu.uci.ics.genomix.pregelix.type.Message;
 import edu.uci.ics.genomix.pregelix.type.State;
-import edu.uci.ics.genomix.type.Kmer;
+import edu.uci.ics.genomix.type.old.Kmer;
 
 public class LogAlgorithmLogFormatter extends Formatter {
 	//
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/NaiveAlgorithmLogFormatter.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/NaiveAlgorithmLogFormatter.java
index ef0d96f..c337a16 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/NaiveAlgorithmLogFormatter.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/log/NaiveAlgorithmLogFormatter.java
@@ -3,7 +3,7 @@
 import java.util.logging.*;
 
 import edu.uci.ics.genomix.pregelix.io.MessageWritable;
-import edu.uci.ics.genomix.type.Kmer;
+import edu.uci.ics.genomix.type.old.Kmer;
 
 public class NaiveAlgorithmLogFormatter extends Formatter {
 	//
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/sequencefile/CombineSequenceFile.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/sequencefile/CombineSequenceFile.java
index 8924302..d9f0efe 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/sequencefile/CombineSequenceFile.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/sequencefile/CombineSequenceFile.java
@@ -9,7 +9,7 @@
 import org.apache.hadoop.io.SequenceFile;
 import org.apache.hadoop.io.SequenceFile.CompressionType;
 
-import edu.uci.ics.genomix.type.Kmer;
+import edu.uci.ics.genomix.type.old.Kmer;
 import edu.uci.ics.genomix.type.KmerCountValue;
 
 
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/sequencefile/GenerateTextFile.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/sequencefile/GenerateTextFile.java
index a054ede..18214a8 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/sequencefile/GenerateTextFile.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/sequencefile/GenerateTextFile.java
@@ -11,7 +11,7 @@
 import org.apache.hadoop.io.SequenceFile;
 
 import edu.uci.ics.genomix.pregelix.io.ValueStateWritable;
-import edu.uci.ics.genomix.type.Kmer;
+import edu.uci.ics.genomix.type.old.Kmer;
 
 public class GenerateTextFile {