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 df93069..9c6f9a3 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
@@ -133,6 +133,12 @@
         System.arraycopy(newData, offset + HEADER_SIZE, bytes, this.kmerStartOffset, bytesUsed);
     }
 
+    public void setAsCopy(int k, byte[] newData, int offset) {
+//        int k = Marshal.getInt(newData, offset);
+        reset(k);
+        System.arraycopy(newData, offset, bytes, this.kmerStartOffset, bytesUsed);
+    }
+    
     /**
      * Point this datablock to the given bytes array It works like the pointer
      * to new datablock.
diff --git a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/VKmerListWritable.java b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/VKmerListWritable.java
index 620e8ad..1a006ca 100644
--- a/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/VKmerListWritable.java
+++ b/genomix/genomix-data/src/main/java/edu/uci/ics/genomix/type/VKmerListWritable.java
@@ -24,7 +24,7 @@
     protected byte[] storage;
     protected int offset;
     protected int valueCount;
-    protected int storageMaxSize;  // since we may be a reference inside a larger datablock, we must track our maximum size
+    protected int storageMaxSize; // since we may be a reference inside a larger datablock, we must track our maximum size
 
     private VKmerBytesWritable posIter = new VKmerBytesWritable();
 
@@ -32,7 +32,7 @@
         storage = EMPTY_BYTES;
         valueCount = 0;
         offset = 0;
-        storageMaxSize = storage.length; 
+        storageMaxSize = storage.length;
     }
 
     public VKmerListWritable(byte[] data, int offset) {
@@ -55,8 +55,16 @@
 
     public void append(VKmerBytesWritable kmer) {
         setSize(getLength() + kmer.getLength());
-        System.arraycopy(kmer.getBytes(), kmer.kmerStartOffset - VKmerBytesWritable.HEADER_SIZE,
-                storage, offset + getLength(), 
+        System.arraycopy(kmer.getBytes(), kmer.kmerStartOffset - VKmerBytesWritable.HEADER_SIZE, storage, offset
+                + getLength(), kmer.getLength());
+        valueCount += 1;
+        Marshal.putInt(valueCount, storage, offset);
+    }
+
+    public void append(int k, KmerBytesWritable kmer) {
+        setSize(getLength() + HEADER_SIZE + kmer.getLength());
+        Marshal.putInt(k, storage, offset + getLength());
+        System.arraycopy(kmer.getBytes(), kmer.getOffset(), storage, offset + getLength() + HEADER_SIZE,
                 kmer.getLength());
         valueCount += 1;
         Marshal.putInt(valueCount, storage, offset);
@@ -68,7 +76,7 @@
     public void appendList(VKmerListWritable otherList) {
         if (otherList.valueCount > 0) {
             setSize(getLength() + otherList.getLength() - HEADER_SIZE); // one of the headers is redundant
-            
+
             // copy contents of otherList into the end of my storage
             System.arraycopy(otherList.storage, otherList.offset + HEADER_SIZE, // skip other header
                     storage, offset + getLength(), // add to end
@@ -92,7 +100,7 @@
         for (VKmerBytesWritable kmer : otherList) {
             uniqueElements.add(kmer); // references okay
         }
-        setSize(getLength() + otherList.getLength());  // upper bound on memory usage
+        setSize(getLength() + otherList.getLength()); // upper bound on memory usage
         valueCount = 0;
         for (VKmerBytesWritable kmer : uniqueElements) {
             append(kmer);
@@ -131,9 +139,9 @@
         posIter.setAsReference(storage, getOffsetOfKmer(i));
         return posIter;
     }
-    
+
     /**
-     * Return the offset of the kmer at the i'th position 
+     * Return the offset of the kmer at the i'th position
      */
     public int getOffsetOfKmer(int i) {
         if (i >= valueCount) {
@@ -159,9 +167,8 @@
         int newLength = getLength(newData, newOffset);
         setSize(newLength);
         if (newValueCount > 0) {
-            System.arraycopy(newData, newOffset + HEADER_SIZE, 
-                    storage, this.offset + HEADER_SIZE,
-                    newLength - HEADER_SIZE);
+            System.arraycopy(newData, newOffset + HEADER_SIZE, storage, this.offset + HEADER_SIZE, newLength
+                    - HEADER_SIZE);
         }
         valueCount = newValueCount;
         Marshal.putInt(valueCount, storage, this.offset);
@@ -172,7 +179,7 @@
         Iterator<VKmerBytesWritable> it = new Iterator<VKmerBytesWritable>() {
 
             private int currentIndex = 0;
-            private int currentOffset = HEADER_SIZE; // init as offset of first kmer
+            private int currentOffset = offset + HEADER_SIZE; // init as offset of first kmer
 
             @Override
             public boolean hasNext() {
@@ -182,7 +189,8 @@
             @Override
             public VKmerBytesWritable next() {
                 posIter.setAsReference(storage, currentOffset);
-                currentOffset += KmerUtil.getByteNumFromK(Marshal.getInt(storage, currentOffset)) + VKmerBytesWritable.HEADER_SIZE;
+                currentOffset += KmerUtil.getByteNumFromK(Marshal.getInt(storage, currentOffset))
+                        + VKmerBytesWritable.HEADER_SIZE;
                 currentIndex++;
                 return posIter;
             }
@@ -190,16 +198,17 @@
             @Override
             public void remove() {
                 if (currentOffset <= 0) {
-                    throw new IllegalStateException("You must advance the iterator using .next() before calling remove()!");
+                    throw new IllegalStateException(
+                            "You must advance the iterator using .next() before calling remove()!");
                 }
                 // we're removing the element at prevIndex
                 int prevIndex = currentIndex - 1;
                 int prevOffset = getOffsetOfKmer(prevIndex);
-                
+
                 if (currentIndex < valueCount) { // if it's the last element, don't have to do any copying
                     System.arraycopy(storage, currentOffset, // from the "next" element
                             storage, prevOffset, // to the one just returned (overwriting it)
-                            getLength() - currentOffset + offset);  // remaining bytes except current element
+                            getLength() - currentOffset + offset); // remaining bytes except current element
                 }
                 valueCount--;
                 currentIndex--;
@@ -219,7 +228,7 @@
         while (posIterator.hasNext()) {
             if (toRemove.equals(posIterator.next())) {
                 posIterator.remove();
-                return;  // break as soon as the element is found 
+                return; // break as soon as the element is found 
             }
         }
         // element was not found
@@ -247,7 +256,8 @@
             elemBytes = KmerUtil.getByteNumFromK(elemLetters) + VKmerBytesWritable.HEADER_SIZE;
             setSize(curLength + elemBytes); // make sure we have room for the new element
             Marshal.putInt(elemLetters, storage, curOffset); // write header
-            in.readFully(storage, curOffset + VKmerBytesWritable.HEADER_SIZE, elemBytes - VKmerBytesWritable.HEADER_SIZE); // write kmer
+            in.readFully(storage, curOffset + VKmerBytesWritable.HEADER_SIZE, elemBytes
+                    - VKmerBytesWritable.HEADER_SIZE); // write kmer
             curOffset += elemBytes;
             curLength += elemBytes;
         }
@@ -273,19 +283,21 @@
     public int getLength() {
         int totalSize = HEADER_SIZE;
         for (int curCount = 0; curCount < valueCount; curCount++) {
-            totalSize += KmerUtil.getByteNumFromK(Marshal.getInt(storage, offset + totalSize)) + VKmerBytesWritable.HEADER_SIZE;
+            totalSize += KmerUtil.getByteNumFromK(Marshal.getInt(storage, offset + totalSize))
+                    + VKmerBytesWritable.HEADER_SIZE;
         }
         return totalSize;
     }
-    
+
     public static int getLength(byte[] listStorage, int listOffset) {
-      int totalSize = HEADER_SIZE;
-      int listValueCount = Marshal.getInt(listStorage, listOffset);
-      for (int curCount = 0; curCount < listValueCount; curCount++) {
-          totalSize += KmerUtil.getByteNumFromK(Marshal.getInt(listStorage, listOffset + totalSize)) + VKmerBytesWritable.HEADER_SIZE;
-      }
-      return totalSize;
-  }
+        int totalSize = HEADER_SIZE;
+        int listValueCount = Marshal.getInt(listStorage, listOffset);
+        for (int curCount = 0; curCount < listValueCount; curCount++) {
+            totalSize += KmerUtil.getByteNumFromK(Marshal.getInt(listStorage, listOffset + totalSize))
+                    + VKmerBytesWritable.HEADER_SIZE;
+        }
+        return totalSize;
+    }
 
     @Override
     public String toString() {
diff --git a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/ReadsKeyValueParserFactory.java b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/ReadsKeyValueParserFactory.java
index bda4ea9..c77fa70 100644
--- a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/ReadsKeyValueParserFactory.java
+++ b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/ReadsKeyValueParserFactory.java
@@ -18,14 +18,12 @@
 import java.nio.ByteBuffer;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.hadoop.io.LongWritable;
 import org.apache.hadoop.io.Text;
 
 import edu.uci.ics.genomix.type.KmerBytesWritable;
-import edu.uci.ics.genomix.type.VKmerListWritable;
 import edu.uci.ics.genomix.type.NodeWritable;
 import edu.uci.ics.genomix.type.PositionListWritable;
 import edu.uci.ics.genomix.type.PositionWritable;
@@ -47,24 +45,23 @@
 
     public static final int OutputKmerField = 0;
     public static final int OutputNodeField = 1;
-    
 
     private final int readLength;
     private final int kmerSize;
 
     public static final RecordDescriptor readKmerOutputRec = new RecordDescriptor(new ISerializerDeserializer[] { null,
-            null});
+            null });
 
     public ReadsKeyValueParserFactory(int readlength, int k) {
         this.readLength = readlength;
         this.kmerSize = k;
     }
-    
-    public static enum KmerDir {
+
+    public enum KmerDir {
         FORWARD,
         REVERSE,
     }
-    
+
     @Override
     public IKeyValueParser<LongWritable, Text> createKeyValueParser(final IHyracksTaskContext ctx) {
         final ArrayTupleBuilder tupleBuilder = new ArrayTupleBuilder(2);
@@ -73,27 +70,22 @@
         outputAppender.reset(outputBuffer, true);
         KmerBytesWritable.setGlobalKmerLength(kmerSize);
         return new IKeyValueParser<LongWritable, Text>() {
-            
+
             private PositionWritable nodeId = new PositionWritable();
             private PositionListWritable nodeIdList = new PositionListWritable();
-            private VKmerListWritable edgeListForPreKmer = new VKmerListWritable();
-            private VKmerListWritable edgeListForNextKmer = new VKmerListWritable();
-            private NodeWritable outputNode = new NodeWritable();
-//            private NodeWritable outputNode2 = new NodeWritable();
+            private NodeWritable curNode = new NodeWritable();
+            private NodeWritable nextNode = new NodeWritable();
 
-            private KmerBytesWritable preForwardKmer = new KmerBytesWritable();           
-            private KmerBytesWritable preReverseKmer = new KmerBytesWritable();
             private KmerBytesWritable curForwardKmer = new KmerBytesWritable();
             private KmerBytesWritable curReverseKmer = new KmerBytesWritable();
             private KmerBytesWritable nextForwardKmer = new KmerBytesWritable();
             private KmerBytesWritable nextReverseKmer = new KmerBytesWritable();
-            
-            private KmerDir preKmerDir = KmerDir.FORWARD;
+
             private KmerDir curKmerDir = KmerDir.FORWARD;
             private KmerDir nextKmerDir = KmerDir.FORWARD;
 
             byte mateId = (byte) 0;
-            
+
             @Override
             public void parse(LongWritable key, Text value, IFrameWriter writer) throws HyracksDataException {
                 String[] geneLine = value.toString().split("\\t"); // Read the Real Gene Line
@@ -125,145 +117,87 @@
                 if (kmerSize >= array.length) {
                     return;
                 }
-                outputNode.reset();
+                curNode.reset();
+                nextNode.reset();
                 curForwardKmer.setByRead(array, 0);
                 curReverseKmer.setByReadReverse(array, 0);
                 curKmerDir = curForwardKmer.compareTo(curReverseKmer) <= 0 ? KmerDir.FORWARD : KmerDir.REVERSE;
-                setNextKmer(array[kmerSize]);
-                setnodeId(mateId, readID, 0);
-                setEdgeListForNextKmer();
-                writeToFrame(writer);
+                nextForwardKmer.setAsCopy(curForwardKmer);
+                setNextKmer(nextForwardKmer, nextReverseKmer, nextKmerDir, array[kmerSize]);
+                setnodeId(curNode, mateId, readID, 0);
+                setnodeId(nextNode, mateId, readID, 0);
+                setEdgeListForCurAndNextKmer(curKmerDir, curNode, nextKmerDir, nextNode);
+                writeToFrame(curForwardKmer, curReverseKmer, curKmerDir, curNode, writer);
 
                 /*middle kmer*/
                 int i = kmerSize + 1;
                 for (; i < array.length; i++) {
-                    outputNode.reset();
-                    setPreKmerByOldCurKmer();
-                    setCurKmerByOldNextKmer();
-                    setNextKmer(array[i]);
-                    setnodeId(mateId, readID, 0);//i - kmerSize + 1
-                    setEdgeListForPreKmer();
-                    setEdgeListForNextKmer();
-                    writeToFrame(writer);
+                    curForwardKmer.setAsCopy(nextForwardKmer);
+                    curReverseKmer.setAsCopy(nextReverseKmer);
+                    curNode.set(nextNode);
+                    nextNode.reset();
+                    setNextKmer(nextForwardKmer, nextReverseKmer, nextKmerDir, array[kmerSize]);
+                    setnodeId(nextNode, mateId, readID, 0);
+                    setEdgeListForCurAndNextKmer(curKmerDir, curNode, nextKmerDir, nextNode);
+                    writeToFrame(curForwardKmer, curReverseKmer, curKmerDir, curNode, writer);
                 }
-                
+
                 /*last kmer*/
-                outputNode.reset();
-                setPreKmerByOldCurKmer();
-                setCurKmerByOldNextKmer();
-                setnodeId(mateId, readID, 0);//array.length - kmerSize + 1
-                setEdgeListForPreKmer();
-                writeToFrame(writer);
+                writeToFrame(nextForwardKmer, nextReverseKmer, nextKmerDir, nextNode, writer);
             }
-            
-            public void setnodeId(byte mateId, long readID, int posId){
+
+            public void setnodeId(NodeWritable node, byte mateId, long readID, int posId) {
                 nodeId.set(mateId, readID, posId);
                 nodeIdList.reset();
                 nodeIdList.append(nodeId);
-                outputNode.setNodeIdList(nodeIdList);
-            }
-            
-            public void setNextKmer(byte nextChar){
-                nextForwardKmer.setAsCopy(curForwardKmer);
-                nextForwardKmer.shiftKmerWithNextChar(nextChar);
-                nextReverseKmer.setByReadReverse(nextForwardKmer.toString().getBytes(), nextForwardKmer.getOffset());
-                nextKmerDir = nextForwardKmer.compareTo(nextReverseKmer) <= 0 ? KmerDir.FORWARD : KmerDir.REVERSE;
-            }
-            
-            public void setPreKmerByOldCurKmer(){
-                preKmerDir = curKmerDir;
-                preForwardKmer.setAsCopy(curForwardKmer);
-                preReverseKmer.setAsCopy(curReverseKmer);
+                node.setNodeIdList(nodeIdList);
             }
 
-            public void setCurKmerByOldNextKmer(){
-                curKmerDir = nextKmerDir;
-                curForwardKmer.setAsCopy(nextForwardKmer);
-                curReverseKmer.setAsCopy(nextReverseKmer);
+            public void setNextKmer(KmerBytesWritable forwardKmer, KmerBytesWritable ReverseKmer, KmerDir nextKmerDir,
+                    byte nextChar) {
+                forwardKmer.shiftKmerWithNextChar(nextChar);
+                ReverseKmer.setByReadReverse(forwardKmer.toString().getBytes(), forwardKmer.getOffset());
+                nextKmerDir = forwardKmer.compareTo(ReverseKmer) <= 0 ? KmerDir.FORWARD : KmerDir.REVERSE;
             }
-            
-            public void writeToFrame(IFrameWriter writer) {
-                switch(curKmerDir){
+
+            public void writeToFrame(KmerBytesWritable forwardKmer, KmerBytesWritable reverseKmer, KmerDir curKmerDir,
+                    NodeWritable node, IFrameWriter writer) {
+                switch (curKmerDir) {
                     case FORWARD:
-                        InsertToFrame(curForwardKmer, outputNode, writer);
+                        InsertToFrame(forwardKmer, node, writer);
                         break;
                     case REVERSE:
-                        InsertToFrame(curReverseKmer, outputNode, writer);
+                        InsertToFrame(forwardKmer, node, writer);
                         break;
                 }
             }
-            public void setEdgeListForPreKmer(){
-                switch(curKmerDir){
-                    case FORWARD:
-                        switch(preKmerDir){
-                            case FORWARD:
-                                edgeListForPreKmer.reset();
-                                edgeListForPreKmer.append(preForwardKmer);
-                                outputNode.setRRList(edgeListForPreKmer);
-                                break;
-                            case REVERSE:
-                                edgeListForPreKmer.reset();
-                                edgeListForPreKmer.append(preReverseKmer);
-                                outputNode.setRFList(edgeListForPreKmer);
-                                break;
-                        }
-                        break;
-                    case REVERSE:
-                        switch(preKmerDir){
-                            case FORWARD:
-                                edgeListForPreKmer.reset();
-                                edgeListForPreKmer.append(preForwardKmer);
-                                outputNode.setFRList(edgeListForPreKmer);
-                                break;
-                            case REVERSE:
-                                edgeListForPreKmer.reset();
-                                edgeListForPreKmer.append(preReverseKmer);
-                                outputNode.setFFList(edgeListForPreKmer);
-                                break;
-                        }
-                        break;
+
+            public void setEdgeListForCurAndNextKmer(KmerDir curKmerDir, NodeWritable curNode, KmerDir nextKmerDir,
+                    NodeWritable nextNode) {
+                if (curKmerDir == KmerDir.FORWARD && nextKmerDir == KmerDir.FORWARD) {
+                    curNode.getFFList().append(kmerSize, nextForwardKmer);
+                    nextNode.getRRList().append(kmerSize, curForwardKmer);
+                }
+                if (curKmerDir == KmerDir.FORWARD && nextKmerDir == KmerDir.REVERSE) {
+                    curNode.getFRList().append(kmerSize, nextReverseKmer);
+                    nextNode.getFRList().append(kmerSize, curForwardKmer);
+                }
+                if (curKmerDir == KmerDir.REVERSE && nextKmerDir == KmerDir.FORWARD) {
+                    curNode.getRFList().append(kmerSize, nextForwardKmer);
+                    nextNode.getRFList().append(kmerSize, curReverseKmer);
+                }
+                if (curKmerDir == KmerDir.REVERSE && nextKmerDir == KmerDir.REVERSE) {
+                    curNode.getRRList().append(kmerSize, nextReverseKmer);
+                    nextNode.getFFList().append(kmerSize, curReverseKmer);
                 }
             }
-            
-            public void setEdgeListForNextKmer(){
-                switch(curKmerDir){
-                    case FORWARD:
-                        switch(nextKmerDir){
-                            case FORWARD:
-                                edgeListForNextKmer.reset();
-                                edgeListForNextKmer.append(nextForwardKmer);
-                                outputNode.setFFList(edgeListForNextKmer);
-                                break;
-                            case REVERSE:
-                                edgeListForNextKmer.reset();
-                                edgeListForNextKmer.append(nextReverseKmer);
-                                outputNode.setFRList(edgeListForNextKmer);
-                                break;
-                        }
-                        break;
-                    case REVERSE:
-                        switch(nextKmerDir){
-                            case FORWARD:
-                                edgeListForNextKmer.reset();
-                                edgeListForNextKmer.append(nextForwardKmer);
-                                outputNode.setRFList(edgeListForNextKmer);
-                                break;
-                            case REVERSE:
-                                edgeListForNextKmer.reset();
-                                edgeListForNextKmer.append(nextReverseKmer);
-                                outputNode.setRRList(edgeListForNextKmer);
-                                break;
-                        }
-                        break;
-                }
-            }
-            
+
             private void InsertToFrame(KmerBytesWritable kmer, NodeWritable node, IFrameWriter writer) {
                 try {
                     tupleBuilder.reset();
                     tupleBuilder.addField(kmer.getBytes(), kmer.getOffset(), kmer.getLength());
                     tupleBuilder.addField(node.marshalToByteArray(), 0, node.getSerializedLength());
-                    
+
                     if (!outputAppender.append(tupleBuilder.getFieldEndOffsets(), tupleBuilder.getByteArray(), 0,
                             tupleBuilder.getSize())) {
                         FrameUtils.flushFrame(outputBuffer, writer);
@@ -289,5 +223,4 @@
             }
         };
     }
-
 }
diff --git a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/aggregators/MergeKmerAggregateFactory.java b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/aggregators/MergeKmerAggregateFactory.java
index 1ee6cae..aa3c9f6 100644
--- a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/aggregators/MergeKmerAggregateFactory.java
+++ b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/aggregators/MergeKmerAggregateFactory.java
@@ -20,8 +20,11 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
+import edu.uci.ics.genomix.data.Marshal;
 import edu.uci.ics.genomix.type.KmerBytesWritable;
 import edu.uci.ics.genomix.type.NodeWritable;
+import edu.uci.ics.genomix.type.VKmerBytesWritable;
 import edu.uci.ics.hyracks.api.comm.IFrameTupleAccessor;
 import edu.uci.ics.hyracks.api.context.IHyracksTaskContext;
 import edu.uci.ics.hyracks.api.dataflow.value.RecordDescriptor;
@@ -70,6 +73,9 @@
                 localUniNode.reset();
                 readNode.setAsReference(accessor.getBuffer().array(), getOffSet(accessor, tIndex, 1));
                 localUniNode.getNodeIdList().unionUpdate(readNode.getNodeIdList());
+//                VKmerBytesWritable a = new VKmerBytesWritable();
+ //               a.setAsCopy(readNode.getFFList().getPosition(0));
+  //              int kRequested = Marshal.getInt(readNode.getFFList().getByteArray(), readNode.getFFList().getStartOffset() + 4);
                 localUniNode.getFFList().unionUpdate(readNode.getFFList());
                 localUniNode.getFRList().unionUpdate(readNode.getFRList());
                 localUniNode.getRFList().unionUpdate(readNode.getRFList());
diff --git a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/assembleKeyIntoNodeOperator.java b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/assembleKeyIntoNodeOperator.java
index 36a1d1e..e248c3b 100644
--- a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/assembleKeyIntoNodeOperator.java
+++ b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/dataflow/assembleKeyIntoNodeOperator.java
@@ -35,9 +35,9 @@
 import edu.uci.ics.hyracks.dataflow.std.base.AbstractSingleActivityOperatorDescriptor;
 import edu.uci.ics.hyracks.dataflow.std.base.AbstractUnaryInputUnaryOutputOperatorNodePushable;
 
-public class assembleKeyIntoNodeOperator extends AbstractSingleActivityOperatorDescriptor {
+public class AssembleKeyIntoNodeOperator extends AbstractSingleActivityOperatorDescriptor {
 
-    public assembleKeyIntoNodeOperator(IOperatorDescriptorRegistry spec, RecordDescriptor outRecDesc, int kmerSize) {
+    public AssembleKeyIntoNodeOperator(IOperatorDescriptorRegistry spec, RecordDescriptor outRecDesc, int kmerSize) {
         super(spec, 1, 1);
         recordDescriptors[0] = outRecDesc;
         this.kmerSize = kmerSize;
@@ -102,7 +102,7 @@
             setKmer(readKmer, offsetPoslist + accessor.getFieldStartOffset(tIndex, InputKmerField));
             readNode.reset();
             setNode(readNode, offsetPoslist + accessor.getFieldStartOffset(tIndex, InputtempNodeField));
-
+            readNode.getKmer().setAsCopy(readKmer.getKmerLength(), readKmer.getBytes(), readKmer.getOffset());
             outputNode(readNode);
         }
 
diff --git a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/io/NodeTextWriterFactory.java b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/io/NodeTextWriterFactory.java
index 3836b13..fa6ae9b 100644
--- a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/io/NodeTextWriterFactory.java
+++ b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/io/NodeTextWriterFactory.java
@@ -17,7 +17,7 @@
 import java.io.DataOutput;
 import java.io.IOException;
 
-import edu.uci.ics.genomix.hyracks.newgraph.dataflow.assembleKeyIntoNodeOperator;
+import edu.uci.ics.genomix.hyracks.newgraph.dataflow.AssembleKeyIntoNodeOperator;
 import edu.uci.ics.genomix.type.NodeWritable;
 import edu.uci.ics.genomix.type.KmerBytesWritable;
 import edu.uci.ics.hyracks.api.context.IHyracksTaskContext;
@@ -33,7 +33,7 @@
      */
     private static final long serialVersionUID = 1L;
     private final int kmerSize;
-    public static final int OutputNodeField = assembleKeyIntoNodeOperator.OutputNodeField;
+    public static final int OutputNodeField = AssembleKeyIntoNodeOperator.OutputNodeField;
     
     public NodeTextWriterFactory(int k) {
         this.kmerSize = k;
diff --git a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/job/JobGenBrujinGraph.java b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/job/JobGenBrujinGraph.java
index 5b35eac..6a5dcc4 100644
--- a/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/job/JobGenBrujinGraph.java
+++ b/genomix/genomix-hyracks/src/main/java/edu/uci/ics/genomix/hyracks/newgraph/job/JobGenBrujinGraph.java
@@ -29,7 +29,7 @@
 import edu.uci.ics.genomix.hyracks.data.primitive.KmerPointable;
 import edu.uci.ics.genomix.hyracks.newgraph.dataflow.ConnectorPolicyAssignmentPolicy;
 import edu.uci.ics.genomix.hyracks.newgraph.dataflow.ReadsKeyValueParserFactory;
-import edu.uci.ics.genomix.hyracks.newgraph.dataflow.assembleKeyIntoNodeOperator;
+import edu.uci.ics.genomix.hyracks.newgraph.dataflow.AssembleKeyIntoNodeOperator;
 import edu.uci.ics.genomix.hyracks.newgraph.dataflow.aggregators.AggregateKmerAggregateFactory;
 import edu.uci.ics.genomix.hyracks.newgraph.dataflow.aggregators.MergeKmerAggregateFactory;
 import edu.uci.ics.genomix.hyracks.newgraph.io.NodeTextWriterFactory;
@@ -185,8 +185,8 @@
     public AbstractOperatorDescriptor generateKmerToFinalNode(JobSpecification jobSpec,
             AbstractOperatorDescriptor kmerCrossAggregator) {
 
-        AbstractOperatorDescriptor mapToFinalNode = new assembleKeyIntoNodeOperator(jobSpec,
-                assembleKeyIntoNodeOperator.nodeOutputRec, kmerSize);
+        AbstractOperatorDescriptor mapToFinalNode = new AssembleKeyIntoNodeOperator(jobSpec,
+                AssembleKeyIntoNodeOperator.nodeOutputRec, kmerSize);
         connectOperators(jobSpec, kmerCrossAggregator, ncNodeNames, mapToFinalNode, ncNodeNames,
                 new OneToOneConnectorDescriptor(jobSpec));
         return mapToFinalNode;