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 26c4088..5ca7946 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
@@ -36,8 +36,8 @@
     private static final long serialVersionUID = 1L;
     protected static final byte[] EMPTY_BYTES = {};
 
-    protected static int lettersInKmer = -1;
-    protected static int bytesUsed = -1;
+    protected static int lettersInKmer;
+    protected static int bytesUsed;
     protected byte[] bytes;
     protected int offset;
 
@@ -149,10 +149,14 @@
         return (byte) ((bytes[offset + bytesUsed - 1 - posByte] >> shift) & 0x3);
     }
 
-    public int getKmerLength() {
+    public static int getKmerLength() {
         return lettersInKmer;
     }
 
+    public static int getBytesPerKmer() {
+        return bytesUsed;
+    }
+
     @Override
     public byte[] getBytes() {
         return bytes;
diff --git a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/KmerListWritable.java b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/KmerListWritable.java
index 6bf8dac..995643e 100644
--- a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/KmerListWritable.java
+++ b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/KmerListWritable.java
@@ -10,259 +10,246 @@
 
 import org.apache.hadoop.io.Writable;
 
-import edu.uci.ics.genomix.data.KmerUtil;
 import edu.uci.ics.genomix.data.Marshal;
 
-
 /**
- * A list of fixed-length kmers.  The length of this list is stored internally 
- *
+ * A list of fixed-length kmers. The length of this list is stored internally.
  */
-public class KmerListWritable implements Writable, Iterable<KmerBytesWritable>,
-		Serializable {
-	private static final long serialVersionUID = 1L;
-	protected static final byte[] EMPTY_BYTES = { 0, 0, 0, 0 };
-	protected static final int HEADER_SIZE = 4;
-
-	protected byte[] storage;
-	protected int offset;
-	protected int valueCount;
-
-	protected int bytesPerKmer = 0;
-	protected int lettersPerKmer = 0;
-	private KmerBytesWritable posIter = new KmerBytesWritable();
-
-	public KmerListWritable() {
-		this.storage = EMPTY_BYTES;
-		this.valueCount = 0;
-		this.offset = 0;
-	}
-
-	public KmerListWritable(int kmerlength) {
-		this();
-		this.lettersPerKmer = kmerlength;
-		this.bytesPerKmer = KmerUtil.getByteNumFromK(kmerlength);
-	}
-
-	public KmerListWritable(int kmerlength, byte[] data, int offset) {
-		this.lettersPerKmer = kmerlength;
-		this.bytesPerKmer = KmerUtil.getByteNumFromK(kmerlength);
-		setNewReference(data, offset);
-	}
-
-	public KmerListWritable(List<KmerBytesWritable> kmers) {
-		this();
-		setSize(kmers.size()); // reserve space for all elements
-		for (KmerBytesWritable kmer : kmers) {
-			if (kmer.getKmerLength() != lettersPerKmer)
-				throw new IllegalArgumentException("Kmer " + kmer.toString()
-						+ " is of incorrect length (l=" + kmer.getKmerLength()
-						+ ") for this list (should be " + lettersPerKmer + ").");
-			append(kmer);
-		}
-	}
-
-	public void setNewReference(byte[] data, int offset) {
-		this.valueCount = Marshal.getInt(data, offset);
-		this.storage = data;
-		this.offset = offset;
-	}
-
-	public void append(KmerBytesWritable kmer) {
-		setSize((1 + valueCount) * bytesPerKmer);
-		System.arraycopy(kmer.getBytes(), 0, storage, offset + valueCount
-				* bytesPerKmer, bytesPerKmer);
-		valueCount += 1;
-	}
-
-	/*
-	 * Append the otherList to the end of myList
-	 */
-	public void appendList(KmerListWritable otherList) {
-		if (otherList.valueCount > 0) {
-			setSize((valueCount + otherList.valueCount) * bytesPerKmer);
-			// copy contents of otherList into the end of my storage
-			System.arraycopy(otherList.storage, otherList.offset, storage,
-					offset + valueCount * bytesPerKmer, otherList.valueCount
-							* bytesPerKmer);
-			valueCount += otherList.valueCount;
-		}
-	}
-
-	/**
-	 * Save the union of my list and otherList. Uses a temporary HashSet for
-	 * uniquefication
-	 */
-	public void unionUpdate(KmerListWritable otherList) {
-		int newSize = valueCount + otherList.valueCount;
-		HashSet<KmerBytesWritable> uniqueElements = new HashSet<KmerBytesWritable>(
-				newSize);
-		for (KmerBytesWritable kmer : this) {
-			uniqueElements.add(kmer);
-		}
-		for (KmerBytesWritable kmer : otherList) {
-			uniqueElements.add(kmer);
-		}
-		valueCount = 0;
-		setSize(newSize);
-		for (KmerBytesWritable kmer : uniqueElements) {
-			append(kmer);
-		}
-	}
-
-	protected void setSize(int size) {
-		if (size > getCapacity()) {
-			setCapacity((size * 3 / 2));
-		}
-	}
-
-	protected int getCapacity() {
-		return storage.length - offset;
-	}
-
-	protected void setCapacity(int new_cap) {
-		if (new_cap > getCapacity()) {
-			byte[] new_data = new byte[new_cap];
-			if (storage.length - offset > 0) {
-				System.arraycopy(storage, offset, new_data, 0, storage.length
-						- offset);
-			}
-			storage = new_data;
-			offset = 0;
-		}
-	}
-
-	public void reset(int kmerSize) {
-		lettersPerKmer = kmerSize;
-		bytesPerKmer = KmerUtil.getByteNumFromK(lettersPerKmer);
-		storage = EMPTY_BYTES;
-		valueCount = 0;
-		offset = 0;
-	}
-
-	public KmerBytesWritable getPosition(int i) {
-		if (i >= valueCount) {
-			throw new ArrayIndexOutOfBoundsException("No such positions");
-		}
-		posIter.setAsReference(lettersPerKmer, storage, offset + i
-				* bytesPerKmer);
-		return posIter;
-	}
-
-	public void set(KmerListWritable otherList) {
-		this.lettersPerKmer = otherList.lettersPerKmer;
-		this.bytesPerKmer = otherList.bytesPerKmer;
-		set(otherList.valueCount, otherList.storage, otherList.offset);
-	}
-
-	public void set(int valueCount, byte[] newData, int offset) {
-		this.valueCount = valueCount;
-		setSize(valueCount * bytesPerKmer);
-		if (valueCount > 0) {
-			System.arraycopy(newData, offset, storage, this.offset, valueCount
-					* bytesPerKmer);
-		}
-	}
-
-	@Override
-	public Iterator<KmerBytesWritable> iterator() {
-		Iterator<KmerBytesWritable> it = new Iterator<KmerBytesWritable>() {
-
-			private int currentIndex = 0;
-
-			@Override
-			public boolean hasNext() {
-				return currentIndex < valueCount;
-			}
-
-			@Override
-			public KmerBytesWritable next() {
-				return getPosition(currentIndex++);
-			}
-
-			@Override
-			public void remove() {
-				if (currentIndex < valueCount)
-					System.arraycopy(storage, offset + currentIndex
-							* bytesPerKmer, storage, offset
-							+ (currentIndex - 1) * bytesPerKmer,
-							(valueCount - currentIndex) * bytesPerKmer);
-				valueCount--;
-				currentIndex--;
-			}
-		};
-		return it;
-	}
-
-	/*
-	 * remove the first instance of `toRemove`. Uses a linear scan. Throws an
-	 * exception if not in this list.
-	 */
-	public void remove(KmerBytesWritable toRemove, boolean ignoreMissing) {
-		Iterator<KmerBytesWritable> posIterator = this.iterator();
-		while (posIterator.hasNext()) {
-			if (toRemove.equals(posIterator.next())) {
-				posIterator.remove();
-				return;
-			}
-		}
-		if (!ignoreMissing) {
-			throw new ArrayIndexOutOfBoundsException("the KmerBytesWritable `"
-					+ toRemove.toString() + "` was not found in this list.");
-		}
-	}
-
-	public void remove(KmerBytesWritable toRemove) {
-		remove(toRemove, false);
-	}
-
-	@Override
-	public void readFields(DataInput in) throws IOException {
-		this.valueCount = in.readInt();
-		setSize(valueCount * bytesPerKmer);// kmerByteSize
-		in.readFully(storage, offset, valueCount * bytesPerKmer);// kmerByteSize
-	}
-
-	@Override
-	public void write(DataOutput out) throws IOException {
-		out.writeInt(valueCount);
-		out.write(storage, offset, valueCount * bytesPerKmer);
-	}
-
-	public int getCountOfPosition() {
-		return valueCount;
-	}
-
-	public byte[] getByteArray() {
-		return storage;
-	}
-
-	public int getStartOffset() {
-		return offset;
-	}
-
-	public int getLength() {
-		return valueCount * bytesPerKmer;
-	}
-
-	@Override
-	public String toString() {
-		StringBuilder sbuilder = new StringBuilder();
-		sbuilder.append('[');
-		for (int i = 0; i < valueCount; i++) {
-			sbuilder.append(getPosition(i).toString());
-			sbuilder.append(',');
-		}
-		if (valueCount > 0) {
-			sbuilder.setCharAt(sbuilder.length() - 1, ']');
-		} else {
-			sbuilder.append(']');
-		}
-		return sbuilder.toString();
-	}
-
 	@Override
 	public int hashCode() {
 		return Marshal.hashBytes(getByteArray(), getStartOffset(), getLength());
 	}
+public class KmerListWritable implements Writable, Iterable<KmerBytesWritable>, Serializable {
+    private static final long serialVersionUID = 1L;
+    protected static final byte[] EMPTY_BYTES = { 0, 0, 0, 0 };
+    protected static final int HEADER_SIZE = 4;
+
+    protected byte[] storage;
+    protected int offset;
+    protected int valueCount;
+
+    private KmerBytesWritable posIter = new KmerBytesWritable();
+
+    public KmerListWritable() {
+        this.storage = EMPTY_BYTES;
+        this.valueCount = 0;
+        this.offset = 0;
+    }
+
+    public KmerListWritable(byte[] data, int offset) {
+        setNewReference(data, offset);
+    }
+
+    public KmerListWritable(List<KmerBytesWritable> kmers) {
+        this();
+        setSize(kmers.size() * KmerBytesWritable.getBytesPerKmer() + HEADER_SIZE); // reserve space for all elements
+        for (KmerBytesWritable kmer : kmers) {
+            append(kmer);
+        }
+    }
+
+    public void setNewReference(byte[] data, int offset) {
+        valueCount = Marshal.getInt(data, offset);
+        if (valueCount * KmerBytesWritable.getBytesPerKmer() > data.length - offset) {
+            throw new IllegalArgumentException("Specified data buffer (len=" + (data.length - offset)
+                    + ") is not large enough to store requested number of elements (" + valueCount + ")!");
+        }
+        this.storage = data;
+        this.offset = offset;
+    }
+
+    public void append(KmerBytesWritable kmer) {
+        setSize((1 + valueCount) * KmerBytesWritable.getBytesPerKmer() + HEADER_SIZE);
+        System.arraycopy(kmer.getBytes(), 0, storage,
+                offset + HEADER_SIZE + valueCount * KmerBytesWritable.getBytesPerKmer(),
+                KmerBytesWritable.getBytesPerKmer());
+        valueCount += 1;
+        Marshal.putInt(valueCount, storage, offset);
+    }
+
+    /*
+     * Append the otherList to the end of myList
+     */
+    public void appendList(KmerListWritable otherList) {
+        if (otherList.valueCount > 0) {
+            setSize((valueCount + otherList.valueCount) * KmerBytesWritable.getBytesPerKmer() + HEADER_SIZE);
+            // copy contents of otherList into the end of my storage
+            System.arraycopy(otherList.storage, otherList.offset + HEADER_SIZE, storage, offset + HEADER_SIZE
+                    + valueCount * KmerBytesWritable.getBytesPerKmer(),
+                    otherList.valueCount * KmerBytesWritable.getBytesPerKmer());
+            valueCount += otherList.valueCount;
+            Marshal.putInt(valueCount, storage, offset);
+        }
+    }
+
+    /**
+     * Save the union of my list and otherList. Uses a temporary HashSet for
+     * uniquefication
+     */
+    public void unionUpdate(KmerListWritable otherList) {
+        int newSize = valueCount + otherList.valueCount;
+        HashSet<KmerBytesWritable> uniqueElements = new HashSet<KmerBytesWritable>(newSize);
+        for (KmerBytesWritable kmer : this) {
+            uniqueElements.add(kmer);
+        }
+        for (KmerBytesWritable kmer : otherList) {
+            uniqueElements.add(kmer);
+        }
+        valueCount = 0;
+        setSize(newSize * KmerBytesWritable.getBytesPerKmer() + HEADER_SIZE);
+        for (KmerBytesWritable kmer : uniqueElements) {
+            append(kmer);
+        }
+        Marshal.putInt(valueCount, storage, offset);
+    }
+
+    protected void setSize(int size) {
+        if (size > getCapacity()) {
+            setCapacity((size * 3 / 2));
+        }
+    }
+
+    protected int getCapacity() {
+        return storage.length - offset;
+    }
+
+    protected void setCapacity(int new_cap) {
+        if (new_cap > getCapacity()) {
+            byte[] new_data = new byte[new_cap];
+            if (storage.length - offset > 0) {
+                System.arraycopy(storage, offset, new_data, 0, storage.length - offset);
+            }
+            storage = new_data;
+            offset = 0;
+        }
+    }
+
+    public void reset() {
+        storage = EMPTY_BYTES;
+        valueCount = 0;
+        offset = 0;
+    }
+
+    public KmerBytesWritable getPosition(int i) {
+        if (i >= valueCount) {
+            throw new ArrayIndexOutOfBoundsException("No such positions");
+        }
+        posIter.setAsReference(storage, offset + HEADER_SIZE + i * KmerBytesWritable.getBytesPerKmer());
+        return posIter;
+    }
+
+    public void setCopy(KmerListWritable otherList) {
+        setCopy(otherList.storage, otherList.offset);
+    }
+
+    /**
+     * save as a copy of the given data buffer, including the header
+     */
+    public void setCopy(byte[] newData, int offset) {
+        valueCount = Marshal.getInt(newData, offset);
+        setSize(valueCount * KmerBytesWritable.getBytesPerKmer() + HEADER_SIZE);
+        if (valueCount > 0) {
+            System.arraycopy(newData, offset + HEADER_SIZE, storage, this.offset + HEADER_SIZE, valueCount
+                    * KmerBytesWritable.getBytesPerKmer());
+        }
+        Marshal.putInt(valueCount, storage, offset);
+    }
+
+    @Override
+    public Iterator<KmerBytesWritable> iterator() {
+        Iterator<KmerBytesWritable> it = new Iterator<KmerBytesWritable>() {
+
+            private int currentIndex = 0;
+
+            @Override
+            public boolean hasNext() {
+                return currentIndex < valueCount;
+            }
+
+            @Override
+            public KmerBytesWritable next() {
+                return getPosition(currentIndex++);
+            }
+
+            @Override
+            public void remove() {
+                if (currentIndex < valueCount)
+                    System.arraycopy(storage, offset + currentIndex * KmerBytesWritable.getBytesPerKmer(), storage,
+                            offset + (currentIndex - 1) * KmerBytesWritable.getBytesPerKmer(),
+                            (valueCount - currentIndex) * KmerBytesWritable.getBytesPerKmer());
+                valueCount--;
+                currentIndex--;
+                Marshal.putInt(valueCount, storage, offset);
+            }
+        };
+        return it;
+    }
+
+    /*
+     * remove the first instance of `toRemove`. Uses a linear scan. Throws an
+     * exception if not in this list.
+     */
+    public void remove(KmerBytesWritable toRemove, boolean ignoreMissing) {
+        Iterator<KmerBytesWritable> posIterator = this.iterator();
+        while (posIterator.hasNext()) {
+            if (toRemove.equals(posIterator.next())) {
+                posIterator.remove();
+                return;
+            }
+        }
+        if (!ignoreMissing) {
+            throw new ArrayIndexOutOfBoundsException("the KmerBytesWritable `" + toRemove.toString()
+                    + "` was not found in this list.");
+        }
+    }
+
+    public void remove(KmerBytesWritable toRemove) {
+        remove(toRemove, false);
+    }
+
+    @Override
+    public void readFields(DataInput in) throws IOException {
+        valueCount = in.readInt();
+        setSize(valueCount * KmerBytesWritable.getBytesPerKmer() + HEADER_SIZE);
+        in.readFully(storage, offset + HEADER_SIZE, valueCount * KmerBytesWritable.getBytesPerKmer() - HEADER_SIZE);
+        Marshal.putInt(valueCount, storage, offset);
+    }
+
+    @Override
+    public void write(DataOutput out) throws IOException {
+        out.write(storage, offset, valueCount * KmerBytesWritable.getBytesPerKmer() + HEADER_SIZE);
+    }
+
+    public int getCountOfPosition() {
+        return valueCount;
+    }
+
+    public byte[] getByteArray() {
+        return storage;
+    }
+
+    public int getStartOffset() {
+        return offset;
+    }
+
+    public int getLength() {
+        return valueCount * KmerBytesWritable.getBytesPerKmer() + HEADER_SIZE;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sbuilder = new StringBuilder();
+        sbuilder.append('[');
+        for (int i = 0; i < valueCount; i++) {
+            sbuilder.append(getPosition(i).toString());
+            sbuilder.append(',');
+        }
+        if (valueCount > 0) {
+            sbuilder.setCharAt(sbuilder.length() - 1, ']');
+        } else {
+            sbuilder.append(']');
+        }
+        return sbuilder.toString();
+    }
+
 }
diff --git a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/NodeWritable.java b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/NodeWritable.java
index 98e37dc..81c9c92 100644
--- a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/NodeWritable.java
+++ b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/NodeWritable.java
@@ -59,10 +59,10 @@
     public void set(PositionListWritable nodeIdList, KmerListWritable FFList, KmerListWritable FRList,
             KmerListWritable RFList, KmerListWritable RRList, KmerBytesWritable kmer) {
         this.nodeIdList.set(nodeIdList);
-        this.forwardForwardList.set(FFList);
-        this.forwardReverseList.set(FRList);
-        this.reverseForwardList.set(RFList);
-        this.reverseReverseList.set(RRList);
+        this.forwardForwardList.setCopy(FFList);
+        this.forwardReverseList.setCopy(FRList);
+        this.reverseForwardList.setCopy(RFList);
+        this.reverseReverseList.setCopy(RRList);
         this.kmer.setAsCopy(kmer);
     }
 
@@ -122,19 +122,19 @@
     }
     
 	public void setFFList(KmerListWritable forwardForwardList) {
-		this.forwardForwardList.set(forwardForwardList);
+		this.forwardForwardList.setCopy(forwardForwardList);
 	}
 
 	public void setFRList(KmerListWritable forwardReverseList) {
-		this.forwardReverseList.set(forwardReverseList);
+		this.forwardReverseList.setCopy(forwardReverseList);
 	}
 
 	public void setRFList(KmerListWritable reverseForwardList) {
-		this.reverseForwardList.set(reverseForwardList);
+		this.reverseForwardList.setCopy(reverseForwardList);
 	}
 
 	public void setRRList(KmerListWritable reverseReverseList) {
-		this.reverseReverseList.set(reverseReverseList);
+		this.reverseReverseList.setCopy(reverseReverseList);
 	}
 
 	public KmerListWritable getListFromDir(byte dir) {
@@ -212,14 +212,14 @@
     }
 
     public void mergeForwardNext(NodeWritable nextNode, int initialKmerSize) {
-        this.forwardForwardList.set(nextNode.forwardForwardList);
-        this.forwardReverseList.set(nextNode.forwardReverseList);
+        this.forwardForwardList.setCopy(nextNode.forwardForwardList);
+        this.forwardReverseList.setCopy(nextNode.forwardReverseList);
         kmer.mergeWithFFKmer(initialKmerSize, nextNode.getKmer());
     }
 
     public void mergeForwardPre(NodeWritable preNode, int initialKmerSize) {
-        this.reverseForwardList.set(preNode.reverseForwardList);
-        this.reverseReverseList.set(preNode.reverseReverseList);
+        this.reverseForwardList.setCopy(preNode.reverseForwardList);
+        this.reverseReverseList.setCopy(preNode.reverseReverseList);
         kmer.mergeWithRRKmer(initialKmerSize, preNode.getKmer());
     }
     
diff --git a/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/KmerListWritableTest.java b/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/KmerListWritableTest.java
index 1bbb771..6e95653 100644
--- a/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/KmerListWritableTest.java
+++ b/genomix/genomix-data/src/test/java/edu/uci/ics/genomix/data/test/KmerListWritableTest.java
@@ -20,20 +20,22 @@
         //one kmer in list and reset each time
         KmerBytesWritable kmer;
         for (int i = 1; i < 200; i++) {
-            kmer = new KmerBytesWritable(i);
+            KmerBytesWritable.setGlobalKmerLength(i);
+            kmer = new KmerBytesWritable();
             String randomString = generateString(i);
             byte[] array = randomString.getBytes();
             kmer.setByRead(array, 0);
-            kmerList.reset(kmer.getKmerLength());
+            kmerList.reset();
             kmerList.append(kmer);
-            Assert.assertEquals(kmerList.getPosition(0).toString(), randomString);
+            Assert.assertEquals(randomString, kmerList.getPosition(0).toString());
             Assert.assertEquals(1, kmerList.getCountOfPosition());
         }
         
-        kmerList.reset(0);
+        kmerList.reset();
         //add one more kmer each time and fix kmerSize
         for (int i = 0; i < 200; i++) {
-            kmer = new KmerBytesWritable(5);
+            KmerBytesWritable.setGlobalKmerLength(5);
+            kmer = new KmerBytesWritable();
             String randomString = generateString(5);
             byte[] array = randomString.getBytes();
             kmer.setByRead(array, 0);
@@ -44,8 +46,8 @@
         
         byte [] another = new byte [kmerList.getLength()*2];
         int start = 20;
-        System.arraycopy(kmerList.getByteArray(), 0, another, start, kmerList.getLength());
-        KmerListWritable plist2 = new KmerListWritable(kmerList.kmerlength, kmerList.getCountOfPosition(),another,start);
+        System.arraycopy(kmerList.getByteArray(), kmerList.getStartOffset(), another, start, kmerList.getLength());
+        KmerListWritable plist2 = new KmerListWritable(another, start);
         for(int i = 0; i < plist2.getCountOfPosition(); i++){
             Assert.assertEquals(kmerList.getPosition(i).toString(), plist2.getPosition(i).toString());
         }
@@ -59,12 +61,13 @@
         int i;
         KmerBytesWritable kmer;
         for (i = 0; i < 200; i++) {
-            kmer = new KmerBytesWritable(5);
+            KmerBytesWritable.setGlobalKmerLength(5);
+            kmer = new KmerBytesWritable();
             String randomString = generateString(5);
             byte[] array = randomString.getBytes();
             kmer.setByRead(array, 0);
             kmerList.append(kmer);
-            Assert.assertEquals(kmerList.getPosition(i).toString(), randomString);
+            Assert.assertEquals(randomString, kmerList.getPosition(i).toString());
             Assert.assertEquals(i + 1, kmerList.getCountOfPosition());
         }
         
@@ -72,12 +75,12 @@
         KmerBytesWritable tmpKmer = new KmerBytesWritable();
         i = 0;
         KmerListWritable copyList = new KmerListWritable();
-        copyList.set(kmerList);
+        copyList.setCopy(kmerList);
         Iterator<KmerBytesWritable> iterator;
         for(int j = 0; j < 5; j++){
             iterator = copyList.iterator();
             byte[] array = kmerList.getPosition(j).toString().getBytes();
-            KmerBytesWritable deletePos = new KmerBytesWritable(5);
+            KmerBytesWritable deletePos = new KmerBytesWritable();
             deletePos.setByRead(array, 0);
             while(iterator.hasNext()){
                 tmpKmer = iterator.next();
diff --git a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/io/AdjacencyListWritable.java b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/io/AdjacencyListWritable.java
index c35ad7f..29872fa 100644
--- a/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/io/AdjacencyListWritable.java
+++ b/genomix/genomix-pregelix/src/main/java/edu/uci/ics/genomix/pregelix/io/AdjacencyListWritable.java
@@ -24,8 +24,8 @@
     }
 
     public void set(AdjacencyListWritable adjacencyList){
-        forwardList.set(adjacencyList.getForwardList());
-        reverseList.set(adjacencyList.getReverseList());
+        forwardList.setCopy(adjacencyList.getForwardList());
+        reverseList.setCopy(adjacencyList.getReverseList());
     }
     
     public void reset(){