add back old version of Kmer to support genomix-pregelix
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 {