diff --git a/job/gatherNeoFiles.sh b/job/gatherNeoFiles.sh
new file mode 100755
index 0000000..e12cdcd
--- /dev/null
+++ b/job/gatherNeoFiles.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+rm -rf ./graph.db
+mkdir graph.db/
+
+TO=./graph.db/
+FROM=${1}
+hadoop fs -get ${FROM}/neostore ${TO}
+hadoop fs -get ${FROM}/neostore.id ${TO}
+hadoop fs -get ${FROM}/neostore.nodestore.db.id ${TO}
+hadoop fs -get ${FROM}/neostore.relationshipstore.db.id ${TO}
+hadoop fs -get ${FROM}/neostore.relationshiptypestore.db ${TO}
+hadoop fs -get ${FROM}/neostore.relationshiptypestore.db.id ${TO}
+hadoop fs -get ${FROM}/neostore.relationshiptypestore.db.names ${TO}
+hadoop fs -get ${FROM}/neostore.relationshiptypestore.db.names.id ${TO}
+
+hadoop fs -get ${FROM}/properties/neostore.propertystore.db.* ${TO}
+
+hadoop fs -cat ${FROM}/neostore.nodestore.db/part-r-* > ${TO}/neostore.nodestore.db
+hadoop fs -cat ${FROM}/neostore.relationshipstore.db/part-r-* > ${TO}/neostore.relationshipstore.db
+
+hadoop fs -cat ${FROM}/nodeproperties/propertystore.db/props-r-* ${FROM}/edgeproperties/propertystore.db/props-r-* ${FROM}/properties/neostore.propertystore.db.footer > ${TO}/neostore.propertystore.db
+hadoop fs -cat ${FROM}/properties/neostore.propertystore.db.strings.header ${FROM}/nodeproperties/propertystore.db/strings-r-* ${FROM}/edgeproperties/propertystore.db/strings-r-* ${FROM}/properties/neostore.propertystore.db.strings.footer > ${TO}/neostore.propertystore.db.strings
+
+rm ${TO}/*.footer
+rm ${TO}/*.header
+exit
diff --git a/job/pom.xml b/job/pom.xml
index 079e7ad..7b79101 100644
--- a/job/pom.xml
+++ b/job/pom.xml
@@ -36,6 +36,11 @@
 			<artifactId>commons-io</artifactId>
 			<version>1.3.2</version>
 		</dependency>
+		<dependency>
+			<groupId>commons-lang</groupId>
+			<artifactId>commons-lang</artifactId>
+			<version>2.6</version>
+		</dependency>
 		<!-- Test -->
 		<dependency>
 			<groupId>junit</groupId>
@@ -43,6 +48,12 @@
 			<version>4.8</version>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+            <groupId>org.apache.hadoop</groupId> 
+            <artifactId>hadoop-mrunit</artifactId>
+            <version>0.20.2-cdh3u2</version>
+            <scope>test</scope>
+        </dependency>
 		<dependency>
 			<groupId>org.easymock</groupId>
 			<artifactId>easymock</artifactId>
@@ -57,7 +68,7 @@
 		<dependency>
 			<groupId>org.neo4j</groupId>
 			<artifactId>neo4j</artifactId>
-			<version>1.6</version>
+			<version>1.8.M05</version>
 		</dependency>
 		<!-- <dependency>
             <groupId>ant</groupId>
diff --git a/job/src/main/java/nl/waredingen/graphs/Main.java b/job/src/main/java/nl/waredingen/graphs/Main.java
index e9a0166..a6c67ae 100644
--- a/job/src/main/java/nl/waredingen/graphs/Main.java
+++ b/job/src/main/java/nl/waredingen/graphs/Main.java
@@ -3,6 +3,9 @@
 import nl.waredingen.graphs.bgp.PrepareBgpGraphJob;
 import nl.waredingen.graphs.importer.Neo4jImportJob;
 import nl.waredingen.graphs.misc.RowNumberJob;
+import nl.waredingen.graphs.neo.NeoGraphEdgesJob;
+import nl.waredingen.graphs.neo.NeoGraphNodesJob;
+import nl.waredingen.graphs.neo.mapreduce.PureMRNodesAndEdgesJob;
 import nl.waredingen.graphs.partition.IterateJob;
 import nl.waredingen.graphs.partition.IterateWithFlagsJob;
 import nl.waredingen.graphs.partition.PrepareJob;
@@ -38,7 +41,13 @@ public int run(String[] args) throws Exception {
 		} else if (args[0].equalsIgnoreCase("prepare-bgp")) {
 			return PrepareBgpGraphJob.runJob(args[1], args[2], args[3]);
 		} else if (args[0].equalsIgnoreCase("rownumbers")) {
-			return RowNumberJob.run(args[1], args[2], getConf());
+			return (int) RowNumberJob.run(args[1], args[2], getConf());
+		} else if (args[0].equalsIgnoreCase("neographnodes")) {
+			return NeoGraphNodesJob.runJob(args[1], args[2], args[3]);
+		} else if (args[0].equalsIgnoreCase("neographedges")) {
+			return NeoGraphEdgesJob.runJob(args[1], args[2], args[3]);
+		} else if (args[0].equalsIgnoreCase("neograph")) {
+			return PureMRNodesAndEdgesJob.run(args[1], args[2], args[3], getConf());
 		} else {
 			System.err.println("Wrong arguments!");
 			System.exit(1);
diff --git a/job/src/main/java/nl/waredingen/graphs/importer/Neo4jImportJob.java b/job/src/main/java/nl/waredingen/graphs/importer/Neo4jImportJob.java
index 897df27..c6cfaa6 100644
--- a/job/src/main/java/nl/waredingen/graphs/importer/Neo4jImportJob.java
+++ b/job/src/main/java/nl/waredingen/graphs/importer/Neo4jImportJob.java
@@ -175,9 +175,9 @@ public static void main(String[] args) {
 	}
 
 	private Map<String, String> getConfig() {
-        if (new File("batch.properties").exists()) {
-			return BatchInserterImpl.loadProperties("batch.properties");
-        } else {
+//        if (new File("batch.properties").exists()) {
+//			return BatchInserterImpl.loadProperties("batch.properties");
+//        } else {
             return stringMap(
                     "dump_configuration", "true",
                     "cache_type", "none",
@@ -187,7 +187,7 @@ private Map<String, String> getConfig() {
                     "neostore.relationshipstore.db.mapped_memory", "1000M",
                     "neostore.propertystore.db.mapped_memory", "1000M",
                     "neostore.propertystore.db.strings.mapped_memory", "100M");
-        }
+//        }
     }
 	
 	private boolean progress() {
diff --git a/job/src/main/java/nl/waredingen/graphs/misc/RowNumberJob.java b/job/src/main/java/nl/waredingen/graphs/misc/RowNumberJob.java
index ab2694a..cac29a1 100644
--- a/job/src/main/java/nl/waredingen/graphs/misc/RowNumberJob.java
+++ b/job/src/main/java/nl/waredingen/graphs/misc/RowNumberJob.java
@@ -9,19 +9,20 @@
 import org.apache.hadoop.io.LongWritable;
 import org.apache.hadoop.io.RawComparator;
 import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapred.Task.Counter;
 import org.apache.hadoop.mapreduce.Job;
 import org.apache.hadoop.mapreduce.Mapper;
 import org.apache.hadoop.mapreduce.Reducer;
 import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
 import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
-import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
+import org.apache.hadoop.mapreduce.lib.output.SequenceFileOutputFormat;
 
 public class RowNumberJob {
 	public final static byte COUNTER_MARKER = (byte) 'T';
 	public final static byte VALUE_MARKER = (byte) 'W';
 	
-	public static int run(String input, String output, Configuration conf) {
+	public static long run(String input, String output, Configuration conf) {
 		try {
 			Job job = new Job(conf, "Row number generator job.");
 			job.setGroupingComparatorClass(IndifferentComparator.class);
@@ -35,7 +36,7 @@ public static int run(String input, String output, Configuration conf) {
 			job.setOutputKeyClass(Text.class);
 			job.setOutputValueClass(Text.class);
 			
-			job.setOutputFormatClass(TextOutputFormat.class);
+			job.setOutputFormatClass(SequenceFileOutputFormat.class);
 			FileOutputFormat.setOutputPath(job, new Path(output));
 			
 			job.setInputFormatClass(TextInputFormat.class);
@@ -44,13 +45,13 @@ public static int run(String input, String output, Configuration conf) {
 			job.setJarByClass(RowNumberJob.class);
 			
 			job.waitForCompletion(true);
+			
+			return job.getCounters().findCounter(Counter.REDUCE_OUTPUT_RECORDS).getValue();
 		} catch (Exception e) {
 			System.err.println(e.getMessage());
 			e.printStackTrace(System.err);
 			return 1;
 		}
-		
-		return 0;
 	}
 	
 	static class RowNumberMapper extends Mapper<LongWritable, Text, ByteWritable, RowNumberWritable> {
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/ByteBufferOutputFormat.java b/job/src/main/java/nl/waredingen/graphs/neo/ByteBufferOutputFormat.java
new file mode 100644
index 0000000..a600ef6
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/ByteBufferOutputFormat.java
@@ -0,0 +1,54 @@
+package nl.waredingen.graphs.neo;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+import org.apache.hadoop.fs.FSDataOutputStream;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapred.FileOutputFormat;
+import org.apache.hadoop.mapred.JobConf;
+import org.apache.hadoop.mapred.RecordWriter;
+import org.apache.hadoop.mapred.Reporter;
+import org.apache.hadoop.util.Progressable;
+
+public class ByteBufferOutputFormat<K, V> extends FileOutputFormat<K, V> {
+
+	protected static class ByteRecordWriter<K, V> implements RecordWriter<K, V> {
+		private DataOutputStream out;
+
+		public ByteRecordWriter(DataOutputStream out) {
+			this.out = out;
+		}
+
+		public void write(K key, V value) throws IOException {
+			boolean nullValue = value == null || value instanceof NullWritable;
+			if (!nullValue) {
+				BytesWritable bw = (BytesWritable) value;
+				out.write(bw.get(), 0, bw.getSize());
+			}
+		}
+
+		@Override
+		public void close(Reporter reporter) throws IOException {
+			out.close();
+		}
+
+	}
+
+	@Override
+	public RecordWriter<K, V> getRecordWriter(
+			FileSystem ignored, JobConf job, String name, Progressable progress)
+			throws IOException {
+		Path path = FileOutputFormat.getTaskOutputPath(job, name);
+
+		// create the file in the file system
+		FileSystem fs = path.getFileSystem(job);
+		FSDataOutputStream fileOut = fs.create(path, progress);
+
+		// create our record writer with the new file
+		return new ByteRecordWriter<K, V>(new DataOutputStream(fileOut));
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/ByteBufferScheme.java b/job/src/main/java/nl/waredingen/graphs/neo/ByteBufferScheme.java
new file mode 100644
index 0000000..5ed10fe
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/ByteBufferScheme.java
@@ -0,0 +1,50 @@
+package nl.waredingen.graphs.neo;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapred.JobConf;
+import org.apache.hadoop.mapred.OutputCollector;
+
+import cascading.scheme.Scheme;
+import cascading.tap.Tap;
+import cascading.tuple.Fields;
+import cascading.tuple.Tuple;
+import cascading.tuple.TupleEntry;
+
+@SuppressWarnings("serial")
+public class ByteBufferScheme extends Scheme {
+
+	@Override
+	public void sink(TupleEntry tupleEntry, OutputCollector outputCollector)
+			throws IOException {
+		Fields sinkFields = getSinkFields();
+        Tuple result = sinkFields != null ? tupleEntry.selectTuple(sinkFields) : tupleEntry.getTuple();
+
+        ByteBuffer bb = (ByteBuffer) result.getObject(0);
+        byte[] ba = bb.array();
+        BytesWritable bw = new BytesWritable();
+        bw.set(ba, 0, ba.length);
+        outputCollector.collect(NullWritable.get(), bw);
+    }
+	
+	@Override
+	public void sinkInit(Tap tap, JobConf jobconf) throws IOException {
+		jobconf.setOutputFormat(ByteBufferOutputFormat.class);
+	}
+
+	@Override
+	public Tuple source(Object obj, Object obj1) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public void sourceInit(Tap tap, JobConf jobconf) throws IOException {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/NeoGraphEdgesJob.java b/job/src/main/java/nl/waredingen/graphs/neo/NeoGraphEdgesJob.java
new file mode 100644
index 0000000..2b6d657
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/NeoGraphEdgesJob.java
@@ -0,0 +1,281 @@
+package nl.waredingen.graphs.neo;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Properties;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.neo4j.kernel.impl.nioneo.store.Record;
+import org.neo4j.kernel.impl.nioneo.store.RelationshipRecord;
+
+import cascading.flow.Flow;
+import cascading.flow.FlowConnector;
+import cascading.flow.FlowProcess;
+import cascading.operation.BaseOperation;
+import cascading.operation.BufferCall;
+import cascading.operation.Filter;
+import cascading.operation.FilterCall;
+import cascading.operation.Function;
+import cascading.operation.FunctionCall;
+import cascading.pipe.CoGroup;
+import cascading.pipe.Each;
+import cascading.pipe.Every;
+import cascading.pipe.GroupBy;
+import cascading.pipe.Pipe;
+import cascading.pipe.assembly.Unique;
+import cascading.pipe.cogroup.InnerJoin;
+import cascading.scheme.Scheme;
+import cascading.scheme.TextDelimited;
+import cascading.tap.GlobHfs;
+import cascading.tap.Hfs;
+import cascading.tap.SinkMode;
+import cascading.tap.Tap;
+import cascading.tuple.Fields;
+import cascading.tuple.Tuple;
+import cascading.tuple.TupleEntry;
+
+public class NeoGraphEdgesJob {
+
+	public static final long NUMBER_OF_PROPERTIES_PER_NODE = 1L;
+	private static final Log LOG = LogFactory.getLog(NeoGraphEdgesJob.class);
+
+	public static int runJob(String nodesFile, String edgesFile, String output) {
+
+		//TODO properties store is yet to be done
+		// TODO see if this job can be simplified and combined into one edge creation job with rownumbering on the spot
+		// TODO see if combining this with nodes job is possible
+
+		Scheme nodesScheme = new TextDelimited(new Fields("id", "name", "rownum"), "\t");
+		Tap nodeSource = new GlobHfs(nodesScheme, nodesFile);
+
+		Scheme edgesScheme = new TextDelimited(new Fields("from", "to", "rownum"), "\t");
+		Tap edgeSource = new GlobHfs(edgesScheme, edgesFile);
+
+		Map<String, Tap> sourceMap = new HashMap<String, Tap>(2);
+		sourceMap.put("nodes", nodeSource);
+		sourceMap.put("edges", edgeSource);
+
+		Scheme graphEdgesScheme = new ByteBufferScheme();
+		//Scheme graphEdgesScheme = new TextDelimited(new Fields("id", "name", "rownum", "from", "to", "relnum", "fromid", "toid"), "\t");
+		Tap edgesSink = new Hfs(graphEdgesScheme, output + "/neostore.relationshipstore.db", SinkMode.REPLACE);
+
+		Map<String, Tap> sinkMap = new HashMap<String, Tap>(1);
+		sinkMap.put("graphedges", edgesSink);
+
+
+		Pipe nodesPipe = new Pipe("nodes");
+		Pipe edgesPipe = new Pipe("edges");
+
+		Pipe fromjoin = new CoGroup("fromjoin", nodesPipe, new Fields("id"), edgesPipe, new Fields("from"), new Fields(
+				"id", "name", "rownum", "from", "to", "relnum"), new InnerJoin());
+		Pipe tojoin = new CoGroup("tojoin", nodesPipe, new Fields("id"), edgesPipe, new Fields("to"), new Fields("id",
+				"name", "rownum", "from", "to", "relnum"), new InnerJoin());
+
+		Pipe graphEdgesJoinPipe = new GroupBy(Pipe.pipes(fromjoin, tojoin), new Fields("id"), new Fields("relnum"),
+				true);
+
+
+		graphEdgesJoinPipe = new Unique(graphEdgesJoinPipe, new Fields("id", "from", "to", "relnum"));
+		// TODO Edges are now outputed with original id, but this needs to be the rownum of the node (from and to node)
+		// EdgeNodeIdsToNodeRownums method is a first try to do so.
+//		graphEdgesJoinPipe = new Each(graphEdgesJoinPipe, new EdgeNodeIdsToNodeRownums(), Fields.RESULTS);
+//		graphEdgesJoinPipe = new CoGroup(nodesPipe, new Fields("id"), graphEdgesJoinPipe, new Fields())
+		Pipe graphEdgesPipe = new GroupBy(graphEdgesJoinPipe, new Fields("id"), new Fields("relnum"), true);
+		graphEdgesPipe = new Every(graphEdgesPipe, new RelationshipRownumBuffer(), Fields.RESULTS);
+		
+		graphEdgesPipe = new CoGroup(graphEdgesPipe, new Fields("from", "to", "relnum"), 1, new Fields("id", "from", "to", "relnum", "fromprev", "fromnext", "toid", "from2", "to2", "relnum2", "toprev", "tonext"));
+		graphEdgesPipe = new Unique(graphEdgesPipe, new Fields("id", "from", "to", "relnum", "fromprev", "fromnext", "toid", "from2", "to2", "relnum2", "toprev", "tonext"));
+		graphEdgesPipe = new Each(graphEdgesPipe, new Fields("id", "from", "to", "relnum", "fromprev", "fromnext", "toid", "from2", "to2", "relnum2", "toprev", "tonext"), new DuplicateSelfJoinFilter());
+		graphEdgesPipe = new GroupBy("graphedges", graphEdgesPipe, new Fields("relnum"));
+		graphEdgesPipe = new Each(graphEdgesPipe, new EdgeRecordCreator(), Fields.RESULTS);
+		
+		Properties properties = new Properties();
+		FlowConnector.setApplicationJarClass(properties, NeoGraphEdgesJob.class);
+
+		FlowConnector flowConnector = new FlowConnector(properties);
+		Flow flow = flowConnector.connect(sourceMap, sinkMap, graphEdgesPipe);
+		flow.writeDOT("flow.dot");
+
+		flow.complete();
+
+		return 0;
+	}
+
+	private static class RelationshipRownumContext {
+		long id = -1L, from = -1L, to = -1L, relnum = -1L, prev = -1L, next = -1L;
+
+		public RelationshipRownumContext() {
+		}
+
+		public Tuple asTuple() {
+			return new Tuple(id, from, to, relnum, prev, next);
+		}
+
+		@Override
+		public String toString() {
+			return "" + id + ";" + from + ":" + to + ":" + relnum + ":" + prev + ":" + next;
+		}
+	}
+
+	@SuppressWarnings({ "serial" })
+	private static class RelationshipRownumBuffer extends BaseOperation<RelationshipRownumContext> implements
+			cascading.operation.Buffer<RelationshipRownumContext> {
+		public RelationshipRownumBuffer() {
+			super(new Fields("id", "from", "to", "relnum", "prev", "next"));
+		}
+
+		@Override
+		public void operate(FlowProcess flow, BufferCall<RelationshipRownumContext> call) {
+			RelationshipRownumContext context = new RelationshipRownumContext();
+
+			Iterator<TupleEntry> arguments = call.getArgumentsIterator();
+
+			while (arguments.hasNext()) {
+				
+				TupleEntry entry = arguments.next();
+				long id = entry.getLong("id");
+				long from = entry.getLong("from");
+				long to = entry.getLong("to");
+				long relnum = entry.getLong("relnum");
+				if (context.id == -1L) {
+					// first call, so set current fields
+					context.id = id;
+					context.from = from;
+					context.to = to;
+					context.relnum = relnum;
+					context.prev = -1L; // don't know yet
+					context.next = -1L; // first call, relationships ordered descending, so last rel, so no next available
+				} else if (context.prev == -1L) {
+					// not the first so current relationship will become prev in
+					// context and context can be emitted and refilled with
+					// current
+					context.prev = relnum;
+					call.getOutputCollector().add(context.asTuple());
+					long next = context.relnum;
+					context.id = id;
+					context.from = from;
+					context.to = to;
+					context.relnum = relnum;
+					context.prev = -1L; // don't know yet
+					context.next = next;
+				}
+
+			}
+			// write out last context
+			call.getOutputCollector().add(context.asTuple());
+
+		}
+	}
+	
+	@SuppressWarnings({ "serial", "rawtypes" })
+	private static class DuplicateSelfJoinFilter extends BaseOperation implements Filter {
+
+		@Override
+		public boolean isRemove(FlowProcess flow, FilterCall call) {
+			TupleEntry arguments = call.getArguments();
+			long id = arguments.getLong("id");
+			long from = arguments.getLong("from");
+			long to = arguments.getLong("to");
+			long relnum = arguments.getLong("relnum");
+			long toid = arguments.getLong("toid");
+			long from2 = arguments.getLong("from2");
+			long to2 = arguments.getLong("to2");
+			long relnum2 = arguments.getLong("relnum2");
+
+			//TODO Also remove the records which don't start
+			return id == toid && from == from2 && to == to2 && relnum == relnum2;
+			
+		}
+		
+	}
+
+	@SuppressWarnings({ "serial", "rawtypes" })
+	private static class EdgeNodeIdsToNodeRownums extends BaseOperation implements Function {
+
+		public EdgeNodeIdsToNodeRownums() {
+			super(new Fields("id", "name", "rownum", "from", "to", "relnum", "fromid", "toid"));
+		}
+		
+		@Override
+		public void operate(FlowProcess flow, FunctionCall call) {
+			TupleEntry arguments = call.getArguments();
+			long id = arguments.getLong("id");
+			long rownum = arguments.getLong("rownum");
+			long from = arguments.getLong("from");
+			long to = arguments.getLong("to");
+			long toid = -1L;
+			long fromid = -1L;
+			if (id == from) fromid = rownum;
+			if (id == to) toid = rownum;
+			call.getOutputCollector().add(new Tuple(id, arguments.getString("name"), rownum, from, to, arguments.getLong("relnum"), fromid, toid));
+		}
+		
+	}
+	
+	@SuppressWarnings({ "serial", "rawtypes" })
+	private static class EdgeRecordCreator extends BaseOperation implements Function {
+		public EdgeRecordCreator() {
+			super(new Fields("edge"));
+		}
+
+		@Override
+		public void operate(FlowProcess flow, FunctionCall call) {
+			TupleEntry arguments = call.getArguments();
+			long id = arguments.getLong("id");
+			long from = arguments.getLong("from");
+			long to = arguments.getLong("to");
+			long relnum = arguments.getLong("relnum");
+			long fromprev = arguments.getLong("fromprev");
+			long fromnext = arguments.getLong("fromnext");
+			long toprev = arguments.getLong("toprev");
+			long tonext = arguments.getLong("tonext");
+			
+
+			call.getOutputCollector().add(
+					new Tuple(getEdgeAsBuffer(relnum, from, to, -1, fromprev, fromnext, toprev, tonext, -1L)));
+
+		}
+
+		private Buffer getEdgeAsBuffer(long relnum, long from, long to, int type, long fromprev, long fromnext, long toprev, long tonext, long prop) {
+			ByteBuffer buffer = ByteBuffer.allocate(33);
+
+			RelationshipRecord rr = new RelationshipRecord(relnum, from, to, type);
+			rr.setInUse(true);
+			rr.setCreated();
+
+//			LOG.debug(rr.toString());
+
+            short fromMod = (short)((from & 0x700000000L) >> 31);
+            long toMod = (to & 0x700000000L) >> 4;
+            long fromPrevRelMod = fromprev == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (fromprev & 0x700000000L) >> 7;
+            long fromNextRelMod = fromnext == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (fromnext & 0x700000000L) >> 10;
+            long toPrevRelMod = toprev == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (toprev & 0x700000000L) >> 13;
+            long toNextRelMod = tonext == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (tonext & 0x700000000L) >> 16;
+            long propMod = prop == Record.NO_NEXT_PROPERTY.intValue() ? 0 : (prop & 0xF00000000L) >> 28;
+
+            // [    ,   x] in use flag
+            // [    ,xxx ] first node high order bits
+            // [xxxx,    ] next prop high order bits
+            short inUseUnsignedByte = (short)((rr.inUse() ? Record.IN_USE : Record.NOT_IN_USE).byteValue() | fromMod | propMod);
+
+            // [ xxx,    ][    ,    ][    ,    ][    ,    ] second node high order bits,     0x70000000
+            // [    ,xxx ][    ,    ][    ,    ][    ,    ] first prev rel high order bits,  0xE000000
+            // [    ,   x][xx  ,    ][    ,    ][    ,    ] first next rel high order bits,  0x1C00000
+            // [    ,    ][  xx,x   ][    ,    ][    ,    ] second prev rel high order bits, 0x380000
+            // [    ,    ][    , xxx][    ,    ][    ,    ] second next rel high order bits, 0x70000
+            // [    ,    ][    ,    ][xxxx,xxxx][xxxx,xxxx] type
+            int typeInt = (int)(rr.getType() | toMod | fromPrevRelMod | fromNextRelMod | toPrevRelMod | toNextRelMod);
+
+            buffer.put( (byte)inUseUnsignedByte ).putInt( (int) from ).putInt( (int) to )
+                .putInt( typeInt ).putInt( (int) fromprev ).putInt( (int) fromnext )
+                .putInt( (int) toprev ).putInt( (int) tonext ).putInt( (int) prop );
+			return buffer;
+
+		}
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/NeoGraphNodesJob.java b/job/src/main/java/nl/waredingen/graphs/neo/NeoGraphNodesJob.java
new file mode 100644
index 0000000..7a321c5
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/NeoGraphNodesJob.java
@@ -0,0 +1,138 @@
+package nl.waredingen.graphs.neo;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.neo4j.kernel.impl.nioneo.store.NodeRecord;
+import org.neo4j.kernel.impl.nioneo.store.Record;
+
+import cascading.flow.Flow;
+import cascading.flow.FlowConnector;
+import cascading.flow.FlowProcess;
+import cascading.operation.BaseOperation;
+import cascading.operation.Function;
+import cascading.operation.FunctionCall;
+import cascading.operation.aggregator.First;
+import cascading.pipe.CoGroup;
+import cascading.pipe.Each;
+import cascading.pipe.Every;
+import cascading.pipe.GroupBy;
+import cascading.pipe.Pipe;
+import cascading.pipe.cogroup.InnerJoin;
+import cascading.scheme.Scheme;
+import cascading.scheme.TextDelimited;
+import cascading.tap.GlobHfs;
+import cascading.tap.Hfs;
+import cascading.tap.SinkMode;
+import cascading.tap.Tap;
+import cascading.tuple.Fields;
+import cascading.tuple.Tuple;
+import cascading.tuple.TupleEntry;
+
+public class NeoGraphNodesJob {
+
+	public static final long NUMBER_OF_PROPERTIES_PER_NODE = 1L;
+	private static final Log LOG = LogFactory.getLog(NeoGraphNodesJob.class);
+
+	public static int runJob(String nodesFile, String edgesFile, String output) {
+		// TODO properties store is yet to be done
+		// TODO see if this job can be simplified and combined into one node creation job with rownumbering on the spot
+		// TODO see if combining this with edges job is possible
+		Scheme nodesScheme = new TextDelimited(new Fields("id", "name", "rownum"), "\t");
+		Tap nodeSource = new GlobHfs(nodesScheme, nodesFile);
+
+		Scheme edgesScheme = new TextDelimited(new Fields("from", "to", "rownum"), "\t");
+		Tap edgeSource = new GlobHfs(edgesScheme, edgesFile);
+
+		Map<String, Tap> sourceMap = new HashMap<String, Tap>(2);
+		sourceMap.put("nodes", nodeSource);
+		sourceMap.put("edges", edgeSource);
+
+		Scheme graphNodesScheme = new ByteBufferScheme();
+		Tap nodesSink = new Hfs(graphNodesScheme, output + "/neostore.nodestore.db", SinkMode.REPLACE);
+
+		Map<String, Tap> sinkMap = new HashMap<String, Tap>(1);
+		sinkMap.put("graphnodes", nodesSink);
+
+		Pipe nodesPipe = new Pipe("nodes");
+		Pipe edgesPipe = new Pipe("edges");
+
+		Pipe fromjoin = new CoGroup("fromjoin", nodesPipe, new Fields("id"), edgesPipe, new Fields("from"), new Fields(
+				"id", "name", "rownum", "from", "to", "relnum"), new InnerJoin());
+		Pipe tojoin = new CoGroup("tojoin", nodesPipe, new Fields("id"), edgesPipe, new Fields("to"), new Fields("id",
+				"name", "rownum", "from", "to", "relnum"), new InnerJoin());
+
+		Pipe graphNodesJoinPipe = new GroupBy(Pipe.pipes(fromjoin, tojoin), new Fields("id"), new Fields("relnum"),
+				true);
+
+		Pipe graphNodesPipe = new Every(graphNodesJoinPipe, new First(), Fields.RESULTS);
+		graphNodesPipe = new GroupBy("graphnodes", graphNodesPipe, new Fields("rownum"));
+		graphNodesPipe = new Each(graphNodesPipe, new NodeRecordCreator(), Fields.RESULTS);
+
+		Properties properties = new Properties();
+		FlowConnector.setApplicationJarClass(properties, NeoGraphNodesJob.class);
+
+		FlowConnector flowConnector = new FlowConnector(properties);
+		Flow flow = flowConnector.connect(sourceMap, sinkMap, graphNodesPipe);
+		flow.writeDOT("flow.dot");
+
+		flow.complete();
+
+		return 0;
+	}
+
+	@SuppressWarnings({ "serial", "rawtypes" })
+	private static class NodeRecordCreator extends BaseOperation implements Function {
+		public NodeRecordCreator() {
+			super(new Fields("node"));
+		}
+
+		@Override
+		public void operate(FlowProcess flow, FunctionCall call) {
+			TupleEntry arguments = call.getArguments();
+			long relnum = arguments.getLong("relnum");
+			long id = arguments.getLong("rownum");
+			if (id == 0L) {
+				call.getOutputCollector().add(
+						new Tuple(getNodeAsBuffer(id, Record.NO_NEXT_RELATIONSHIP.intValue(),
+								Record.NO_NEXT_PROPERTY.intValue())));
+			}
+			call.getOutputCollector().add(
+					new Tuple(getNodeAsBuffer(id + 1L, relnum, id * NUMBER_OF_PROPERTIES_PER_NODE)));
+
+		}
+
+		private Buffer getNodeAsBuffer(long id, long relnum, long prop) {
+			ByteBuffer buffer = ByteBuffer.allocate(9);
+
+			NodeRecord nr = new NodeRecord(id, relnum, prop);
+			nr.setInUse(true);
+			nr.setCreated();
+
+//			LOG.debug(nr.toString());
+
+			long nextRel = nr.getNextRel();
+			long nextProp = nr.getNextProp();
+
+			short relModifier = nextRel == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0
+					: (short) ((nextRel & 0x700000000L) >> 31);
+			short propModifier = nextProp == Record.NO_NEXT_PROPERTY.intValue() ? 0
+					: (short) ((nextProp & 0xF00000000L) >> 28);
+
+			// [ , x] in use bit
+			// [ ,xxx ] higher bits for rel id
+			// [xxxx, ] higher bits for prop id
+			short inUseUnsignedByte = (nr.inUse() ? Record.IN_USE : Record.NOT_IN_USE).byteValue();
+			inUseUnsignedByte = (short) (inUseUnsignedByte | relModifier | propModifier);
+
+			buffer.put((byte) inUseUnsignedByte).putInt((int) nextRel).putInt((int) nextProp);
+			return buffer;
+
+		}
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AbstractRownumPartitioner.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AbstractRownumPartitioner.java
new file mode 100644
index 0000000..b72cba7
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AbstractRownumPartitioner.java
@@ -0,0 +1,37 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+import org.apache.hadoop.conf.Configurable;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mapreduce.Partitioner;
+
+public abstract class AbstractRownumPartitioner<K, V> extends Partitioner<K, V> implements Configurable {
+
+	private long max = 0L;
+	protected Configuration conf;
+	
+	@Override
+	public int getPartition(K key, V value, int numPartitions) {
+		double divider = Math.max(1, (double) max / numPartitions);
+
+		return (int) (((LongWritable) key).get() / divider);
+	}
+
+	@Override
+	public void setConf(Configuration conf) {
+		this.conf = conf;
+		configure();
+		
+	}
+
+	private void configure() {
+		this.max = getMaxCounter();
+	}
+
+	@Override
+	public Configuration getConf() {
+		return conf;
+	}
+
+	public abstract long getMaxCounter();
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AscLongDescLongKeyComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AscLongDescLongKeyComparator.java
new file mode 100644
index 0000000..800caf5
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AscLongDescLongKeyComparator.java
@@ -0,0 +1,26 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class AscLongDescLongKeyComparator extends WritableComparator {
+	public AscLongDescLongKeyComparator() {
+		super(AscLongDescLongWritable.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable w1, WritableComparable w2) {
+		AscLongDescLongWritable k1 = (AscLongDescLongWritable) w1;
+		AscLongDescLongWritable k2 = (AscLongDescLongWritable) w2;
+
+		int result = k1.getLeft().compareTo(k2.getLeft());
+		if (0 == result) {
+			result = -1 * k1.getRight().compareTo(k2.getRight());
+		}
+		return result;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AscLongDescLongKeyGroupingComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AscLongDescLongKeyGroupingComparator.java
new file mode 100644
index 0000000..fb57496
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AscLongDescLongKeyGroupingComparator.java
@@ -0,0 +1,22 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class AscLongDescLongKeyGroupingComparator extends WritableComparator {
+	public AscLongDescLongKeyGroupingComparator() {
+		super(AscLongDescLongWritable.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable w1, WritableComparable w2) {
+		AscLongDescLongWritable k1 = (AscLongDescLongWritable) w1;
+		AscLongDescLongWritable k2 = (AscLongDescLongWritable) w2;
+
+		return k1.getLeft().compareTo(k2.getLeft());
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AscLongDescLongWritablePartitioner.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AscLongDescLongWritablePartitioner.java
new file mode 100644
index 0000000..a616047
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/AscLongDescLongWritablePartitioner.java
@@ -0,0 +1,16 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.mapreduce.Partitioner;
+
+@SuppressWarnings("rawtypes")
+public class AscLongDescLongWritablePartitioner extends Partitioner<AscLongDescLongWritable, WritableComparable> {
+
+	@Override
+	public int getPartition(AscLongDescLongWritable key, WritableComparable value, int numPartitions) {
+		return key.getLeft().hashCode() % numPartitions;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/IndifferentKeyGroupingComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/IndifferentKeyGroupingComparator.java
new file mode 100644
index 0000000..a3b98a1
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/IndifferentKeyGroupingComparator.java
@@ -0,0 +1,23 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class IndifferentKeyGroupingComparator extends WritableComparator {
+
+	protected IndifferentKeyGroupingComparator() {
+		super(LongWritable.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable a, WritableComparable b) {
+		return 0;
+	}
+	
+	@Override
+	public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
+		return 0;
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/NewByteBufferOutputFormat.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/NewByteBufferOutputFormat.java
new file mode 100644
index 0000000..02b8a60
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/NewByteBufferOutputFormat.java
@@ -0,0 +1,54 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FSDataOutputStream;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.RecordWriter;
+import org.apache.hadoop.mapreduce.TaskAttemptContext;
+import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
+
+public class NewByteBufferOutputFormat<K, V> extends FileOutputFormat<K, V> {
+
+	protected static class ByteRecordWriter<K, V> extends RecordWriter<K, V> {
+		private DataOutputStream out;
+
+		public ByteRecordWriter(DataOutputStream out) {
+			this.out = out;
+		}
+
+		@SuppressWarnings("deprecation")
+		@Override
+		public void write(K key, V value) throws IOException, InterruptedException {
+			boolean nullValue = value == null || value instanceof NullWritable;
+			if (!nullValue) {
+				BytesWritable bw = (BytesWritable) value;
+				out.write(bw.get(), 0, bw.getSize());
+			}
+		}
+
+		@Override
+		public void close(TaskAttemptContext context) throws IOException, InterruptedException {
+			out.close();
+		}
+
+	}
+
+	@Override
+	public RecordWriter<K, V> getRecordWriter(TaskAttemptContext job) throws IOException, InterruptedException {
+		Configuration conf = job.getConfiguration();
+
+		Path file = getDefaultWorkFile(job, "");
+		FileSystem fs = file.getFileSystem(conf);
+
+		FSDataOutputStream fileOut = fs.create(file, false);
+
+		return new ByteRecordWriter<K, V>(new DataOutputStream(fileOut));
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/PureMRNodesAndEdgesJob.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/PureMRNodesAndEdgesJob.java
new file mode 100644
index 0000000..4c27e75
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/PureMRNodesAndEdgesJob.java
@@ -0,0 +1,414 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+import nl.waredingen.graphs.misc.RowNumberJob;
+import nl.waredingen.graphs.neo.mapreduce.edges.EdgeOutputMapper;
+import nl.waredingen.graphs.neo.mapreduce.edges.EdgeOutputReducer;
+import nl.waredingen.graphs.neo.mapreduce.edges.EdgeOutputRownumPartitioner;
+import nl.waredingen.graphs.neo.mapreduce.edges.surround.EdgeSurroundMapper;
+import nl.waredingen.graphs.neo.mapreduce.edges.surround.EdgeSurroundReducer;
+import nl.waredingen.graphs.neo.mapreduce.edges.surround.join.EdgeWritableKeyComparator;
+import nl.waredingen.graphs.neo.mapreduce.edges.surround.join.EdgeWritableKeyGroupingComparator;
+import nl.waredingen.graphs.neo.mapreduce.edges.surround.join.JoinSurroundingEdgesMapper;
+import nl.waredingen.graphs.neo.mapreduce.edges.surround.join.JoinSurroundingEdgesReducer;
+import nl.waredingen.graphs.neo.mapreduce.group.GroupNodesAndEdgesMapper;
+import nl.waredingen.graphs.neo.mapreduce.group.GroupNodesAndEdgesReducer;
+import nl.waredingen.graphs.neo.mapreduce.group.NodeAndEdgeIdKeyComparator;
+import nl.waredingen.graphs.neo.mapreduce.group.NodeAndEdgeIdKeyGroupingComparator;
+import nl.waredingen.graphs.neo.mapreduce.group.NodeAndEdgeIdKeyPartitioner;
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaDataFromConfigImpl;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.DoubleSurroundingEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgePropertyOutputCountersAndValueWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgePropertiesWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullNodePropertiesWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodePropertyOutputCountersAndValueWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.join.JoinFromEdgesMapper;
+import nl.waredingen.graphs.neo.mapreduce.join.JoinNodesAndEdgesReducer;
+import nl.waredingen.graphs.neo.mapreduce.join.JoinNodesMapper;
+import nl.waredingen.graphs.neo.mapreduce.join.JoinToEdgesMapper;
+import nl.waredingen.graphs.neo.mapreduce.join.NodeAndEdgeKeyComparator;
+import nl.waredingen.graphs.neo.mapreduce.join.NodeAndEdgeKeyPartitioner;
+import nl.waredingen.graphs.neo.mapreduce.join.NodeKeyGroupingComparator;
+import nl.waredingen.graphs.neo.mapreduce.nodes.NodeOutputMapper;
+import nl.waredingen.graphs.neo.mapreduce.nodes.NodeOutputReducer;
+import nl.waredingen.graphs.neo.mapreduce.nodes.NodeOutputRownumPartitioner;
+import nl.waredingen.graphs.neo.mapreduce.properties.ByteMarkerAndIdComparator;
+import nl.waredingen.graphs.neo.mapreduce.properties.EdgePreparePropertiesMapper;
+import nl.waredingen.graphs.neo.mapreduce.properties.EdgePreparePropertiesReducer;
+import nl.waredingen.graphs.neo.mapreduce.properties.EdgePropertyOutputMapper;
+import nl.waredingen.graphs.neo.mapreduce.properties.EdgePropertyOutputPartitioner;
+import nl.waredingen.graphs.neo.mapreduce.properties.EdgePropertyOutputReducer;
+import nl.waredingen.graphs.neo.mapreduce.properties.IndifferentByteMarkerAndIdComparator;
+import nl.waredingen.graphs.neo.mapreduce.properties.NodePreparePropertiesMapper;
+import nl.waredingen.graphs.neo.mapreduce.properties.NodePreparePropertiesReducer;
+import nl.waredingen.graphs.neo.mapreduce.properties.NodePropertyOutputMapper;
+import nl.waredingen.graphs.neo.mapreduce.properties.NodePropertyOutputPartitioner;
+import nl.waredingen.graphs.neo.mapreduce.properties.NodePropertyOutputReducer;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Job;
+import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
+import org.apache.hadoop.mapreduce.lib.input.MultipleInputs;
+import org.apache.hadoop.mapreduce.lib.input.SequenceFileInputFormat;
+import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
+import org.apache.hadoop.mapreduce.lib.output.MultipleOutputs;
+import org.apache.hadoop.mapreduce.lib.output.SequenceFileOutputFormat;
+
+public class PureMRNodesAndEdgesJob {
+
+	public static int run(String nodes, String edges, String output, Configuration conf) {
+		String numberedNodes = output + "/numberednodes";
+		String numberedEdges = output + "/numberededges";
+
+		String temp = output + "/temp";
+		String joined = output + "/joined";
+		String grouped = output + "/grouped";
+		String nodesOutput = output + "/neostore.nodestore.db";
+		String surrounding = output + "/surrounding";
+		String joinededges = output + "/joinededges";
+		String edgesOutput = output + "/neostore.relationshipstore.db";
+		String nodePropertiesPrepareOutput = output +"/nodepropprepared";
+		String edgePropertiesPrepareOutput = output +"/edgepropprepared";
+		String propertiesOutput = output +"/properties";
+		String nodePropertiesOutput = output +"/nodeproperties";
+		String edgePropertiesOutput = output +"/edgeproperties";
+
+		try {
+			long nrOfNodes = RowNumberJob.run(nodes, numberedNodes, conf);
+			long nrOfEdges = RowNumberJob.run(edges, numberedEdges, conf);
+
+			System.out.println("Processing " + nrOfNodes + " nodes and " + nrOfEdges + " edges.");
+			conf.set(AbstractMetaData.METADATA_NUMBER_OF_NODES, "" + nrOfNodes);
+			conf.set(AbstractMetaData.METADATA_NUMBER_OF_EDGES, "" + nrOfEdges);
+			
+			conf.setClass(AbstractMetaData.METADATA_CLASS, MetaDataFromConfigImpl.class, MetaData.class);
+
+			conf.setStrings(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_NAMES, "rekening", "integraalklantnummer", "klantnummer", "cddklasse", "individu_organisatie_code", "naam", "postcode", "woonplaats", "label");
+			conf.set(MetaDataFromConfigImpl.METADATA_NODE_ID_NAME, "rekening");
+			conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "rekening", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "integraalklantnummer", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "klantnummer", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "cddklasse", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "individu_organisatie_code", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "naam", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "postcode", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "woonplaats", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "label", String.class, Object.class);
+
+			conf.setStrings(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_NAMES, "from", "to", "netto", "eerste", "laatste", "aantal");
+			conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "from", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "to", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "netto", Long.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "eerste", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "laatste", String.class, Object.class);
+			conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "aantal", Long.class, Object.class);
+
+			Job nodePropertiesPrepareJob = new Job(conf, "Prepare node properties job.");
+			nodePropertiesPrepareJob.setGroupingComparatorClass(AscLongDescLongKeyGroupingComparator.class);
+			nodePropertiesPrepareJob.setSortComparatorClass(AscLongDescLongKeyComparator.class);
+			nodePropertiesPrepareJob.setPartitionerClass(AscLongDescLongWritablePartitioner.class);
+
+			nodePropertiesPrepareJob.setMapOutputKeyClass(AscLongDescLongWritable.class);
+			nodePropertiesPrepareJob.setMapOutputValueClass(FullNodePropertiesWritable.class);
+
+			nodePropertiesPrepareJob.setMapperClass(NodePreparePropertiesMapper.class);
+			nodePropertiesPrepareJob.setInputFormatClass(SequenceFileInputFormat.class);
+			FileInputFormat.addInputPath(nodePropertiesPrepareJob, new Path(numberedNodes));
+
+			nodePropertiesPrepareJob.setReducerClass(NodePreparePropertiesReducer.class);
+			nodePropertiesPrepareJob.setOutputKeyClass(LongWritable.class);
+			nodePropertiesPrepareJob.setOutputValueClass(FullNodePropertiesWritable.class);
+
+			nodePropertiesPrepareJob.setOutputFormatClass(SequenceFileOutputFormat.class);
+			FileOutputFormat.setOutputPath(nodePropertiesPrepareJob, new Path(nodePropertiesPrepareOutput));
+
+			nodePropertiesPrepareJob.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			nodePropertiesPrepareJob.waitForCompletion(true);
+
+			Job edgePropertiesPrepareJob = new Job(conf, "Prepare edge properties job.");
+			edgePropertiesPrepareJob.setGroupingComparatorClass(AscLongDescLongKeyGroupingComparator.class);
+			edgePropertiesPrepareJob.setSortComparatorClass(AscLongDescLongKeyComparator.class);
+			edgePropertiesPrepareJob.setPartitionerClass(AscLongDescLongWritablePartitioner.class);
+			
+			edgePropertiesPrepareJob.setMapOutputKeyClass(AscLongDescLongWritable.class);
+			edgePropertiesPrepareJob.setMapOutputValueClass(FullEdgePropertiesWritable.class);
+			
+			edgePropertiesPrepareJob.setMapperClass(EdgePreparePropertiesMapper.class);
+			edgePropertiesPrepareJob.setInputFormatClass(SequenceFileInputFormat.class);
+			FileInputFormat.addInputPath(edgePropertiesPrepareJob, new Path(numberedEdges));
+			
+			edgePropertiesPrepareJob.setReducerClass(EdgePreparePropertiesReducer.class);
+			edgePropertiesPrepareJob.setOutputKeyClass(LongWritable.class);
+			edgePropertiesPrepareJob.setOutputValueClass(FullEdgePropertiesWritable.class);
+			
+			edgePropertiesPrepareJob.setOutputFormatClass(SequenceFileOutputFormat.class);
+			FileOutputFormat.setOutputPath(edgePropertiesPrepareJob, new Path(edgePropertiesPrepareOutput));
+			
+			edgePropertiesPrepareJob.setJarByClass(PureMRNodesAndEdgesJob.class);
+			
+			edgePropertiesPrepareJob.waitForCompletion(true);
+			
+			Job nodePropertiesOutputJob = new Job(conf, "Output node properties job.");
+			nodePropertiesOutputJob.setPartitionerClass(NodePropertyOutputPartitioner.class);
+			nodePropertiesOutputJob.setSortComparatorClass(ByteMarkerAndIdComparator.class);
+			nodePropertiesOutputJob.setGroupingComparatorClass(IndifferentByteMarkerAndIdComparator.class);
+
+			nodePropertiesOutputJob.setMapOutputKeyClass(ByteMarkerIdPropIdWritable.class);
+			nodePropertiesOutputJob.setMapOutputValueClass(NodePropertyOutputCountersAndValueWritable.class);
+
+			nodePropertiesOutputJob.setMapperClass(NodePropertyOutputMapper.class);
+			nodePropertiesOutputJob.setInputFormatClass(SequenceFileInputFormat.class);
+			FileInputFormat.addInputPath(nodePropertiesOutputJob, new Path(nodePropertiesPrepareOutput));
+			
+
+			nodePropertiesOutputJob.setReducerClass(NodePropertyOutputReducer.class);
+
+			FileOutputFormat.setOutputPath(nodePropertiesOutputJob, new Path(nodePropertiesOutput + "/propertystore.db"));
+			MultipleOutputs.addNamedOutput(nodePropertiesOutputJob, "nodes", SequenceFileOutputFormat.class, NullWritable.class, BytesWritable.class);
+			MultipleOutputs.addNamedOutput(nodePropertiesOutputJob, "props", NewByteBufferOutputFormat.class, NullWritable.class, BytesWritable.class);
+			MultipleOutputs.addNamedOutput(nodePropertiesOutputJob, "strings", NewByteBufferOutputFormat.class, NullWritable.class, BytesWritable.class);
+
+			MultipleOutputs.setCountersEnabled(nodePropertiesOutputJob, true);
+			
+			nodePropertiesOutputJob.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			nodePropertiesOutputJob.waitForCompletion(true);
+			
+			long nrOfWrittenStringBlocks = nodePropertiesOutputJob.getCounters().findCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "strings.blocks").getValue();
+			long nrOfWrittenNodeProperties = nodePropertiesOutputJob.getCounters().findCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "node.properties").getValue();
+
+			conf.set(AbstractMetaData.METADATA_NUMBER_OF_NODE_PROPERTIES, "" + nrOfWrittenNodeProperties);
+
+			Job edgePropertiesOutputJob = new Job(conf, "Output edge properties job.");
+			edgePropertiesOutputJob.setPartitionerClass(EdgePropertyOutputPartitioner.class);
+			edgePropertiesOutputJob.setSortComparatorClass(ByteMarkerAndIdComparator.class);
+			edgePropertiesOutputJob.setGroupingComparatorClass(IndifferentByteMarkerAndIdComparator.class);
+
+			edgePropertiesOutputJob.setMapOutputKeyClass(ByteMarkerIdPropIdWritable.class);
+			edgePropertiesOutputJob.setMapOutputValueClass(EdgePropertyOutputCountersAndValueWritable.class);
+
+			edgePropertiesOutputJob.setMapperClass(EdgePropertyOutputMapper.class);
+			edgePropertiesOutputJob.setInputFormatClass(SequenceFileInputFormat.class);
+			FileInputFormat.addInputPath(edgePropertiesOutputJob, new Path(edgePropertiesPrepareOutput));
+			
+
+			edgePropertiesOutputJob.setReducerClass(EdgePropertyOutputReducer.class);
+
+			FileOutputFormat.setOutputPath(edgePropertiesOutputJob, new Path(edgePropertiesOutput + "/propertystore.db"));
+			MultipleOutputs.addNamedOutput(edgePropertiesOutputJob, "edges", SequenceFileOutputFormat.class, NullWritable.class, BytesWritable.class);
+			MultipleOutputs.addNamedOutput(edgePropertiesOutputJob, "props", NewByteBufferOutputFormat.class, NullWritable.class, BytesWritable.class);
+			MultipleOutputs.addNamedOutput(edgePropertiesOutputJob, "strings", NewByteBufferOutputFormat.class, NullWritable.class, BytesWritable.class);
+
+			MultipleOutputs.setCountersEnabled(edgePropertiesOutputJob, true);
+			
+			edgePropertiesOutputJob.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			edgePropertiesOutputJob.waitForCompletion(true);
+			
+			nrOfWrittenStringBlocks += edgePropertiesOutputJob.getCounters().findCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "strings.blocks").getValue();
+			long nrOfWrittenEdgeProperties = edgePropertiesOutputJob.getCounters().findCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "edge.properties").getValue();
+
+			Neo4JUtils.writePropertyKeyStore(propertiesOutput, conf);
+
+			Neo4JUtils.writePropertyStoreFooter(propertiesOutput, conf);
+			Neo4JUtils.writePropertyStringStoreHeader(propertiesOutput, conf);
+			Neo4JUtils.writePropertyStringStoreFooter(propertiesOutput, conf);
+
+			Neo4JUtils.writePropertyIds((nrOfWrittenNodeProperties + nrOfWrittenEdgeProperties), propertiesOutput + "/neostore.propertystore.db", conf);
+			Neo4JUtils.writePropertyIds(nrOfWrittenStringBlocks + 1, propertiesOutput + "/neostore.propertystore.db.strings", conf);
+			
+			Neo4JUtils.writeEmptArrayStore(propertiesOutput, conf);
+
+			Job joinFrom = new Job(conf, "Join from nodes and edges job.");
+			joinFrom.setGroupingComparatorClass(NodeKeyGroupingComparator.class);
+			joinFrom.setSortComparatorClass(NodeAndEdgeKeyComparator.class);
+			joinFrom.setPartitionerClass(NodeAndEdgeKeyPartitioner.class);
+
+			joinFrom.setMapOutputKeyClass(Text.class);
+			joinFrom.setMapOutputValueClass(Text.class);
+			
+			MultipleInputs
+					.addInputPath(joinFrom, new Path(nodePropertiesOutput + "/propertystore.db/nodes*"), SequenceFileInputFormat.class, JoinNodesMapper.class);
+			MultipleInputs.addInputPath(joinFrom, new Path(edgePropertiesOutput + "/propertystore.db/edges*"), SequenceFileInputFormat.class,
+					JoinFromEdgesMapper.class);
+
+			joinFrom.setReducerClass(JoinNodesAndEdgesReducer.class);
+			joinFrom.setOutputKeyClass(NullWritable.class);
+			joinFrom.setOutputValueClass(Text.class);
+
+			joinFrom.setOutputFormatClass(SequenceFileOutputFormat.class);
+			FileOutputFormat.setOutputPath(joinFrom, new Path(temp));
+
+			joinFrom.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			joinFrom.waitForCompletion(true);
+
+			Job joinTo = new Job(conf, "Join to nodes and edges job.");
+			joinTo.setGroupingComparatorClass(NodeKeyGroupingComparator.class);
+			joinTo.setSortComparatorClass(NodeAndEdgeKeyComparator.class);
+			joinTo.setPartitionerClass(NodeAndEdgeKeyPartitioner.class);
+
+			joinTo.setMapOutputKeyClass(Text.class);
+			joinTo.setMapOutputValueClass(Text.class);
+
+			MultipleInputs.addInputPath(joinTo, new Path(nodePropertiesOutput + "/propertystore.db/nodes*"), SequenceFileInputFormat.class, JoinNodesMapper.class);
+			MultipleInputs.addInputPath(joinTo, new Path(temp), SequenceFileInputFormat.class, JoinToEdgesMapper.class);
+
+			joinTo.setReducerClass(JoinNodesAndEdgesReducer.class);
+			joinTo.setOutputKeyClass(NullWritable.class);
+			joinTo.setOutputValueClass(Text.class);
+
+			joinTo.setOutputFormatClass(SequenceFileOutputFormat.class);
+			FileOutputFormat.setOutputPath(joinTo, new Path(joined));
+
+			joinTo.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			joinTo.waitForCompletion(true);
+
+			Job groupJob = new Job(conf, "Group nodes and edges job.");
+			groupJob.setGroupingComparatorClass(NodeAndEdgeIdKeyGroupingComparator.class);
+			groupJob.setSortComparatorClass(NodeAndEdgeIdKeyComparator.class);
+			groupJob.setPartitionerClass(NodeAndEdgeIdKeyPartitioner.class);
+
+			groupJob.setMapOutputKeyClass(NodeEdgeIdWritable.class);
+			groupJob.setMapOutputValueClass(EdgeWritable.class);
+
+			groupJob.setMapperClass(GroupNodesAndEdgesMapper.class);
+			groupJob.setInputFormatClass(SequenceFileInputFormat.class);
+			FileInputFormat.addInputPath(groupJob, new Path(joined));
+
+			groupJob.setReducerClass(GroupNodesAndEdgesReducer.class);
+			groupJob.setOutputKeyClass(NullWritable.class);
+			groupJob.setOutputValueClass(NodeEdgeWritable.class);
+
+			groupJob.setOutputFormatClass(SequenceFileOutputFormat.class);
+			FileOutputFormat.setOutputPath(groupJob, new Path(grouped));
+
+			groupJob.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			groupJob.waitForCompletion(true);
+
+			Job nodeOutputJob = new Job(conf, "Output nodes job.");
+			nodeOutputJob.setPartitionerClass(NodeOutputRownumPartitioner.class);
+
+			nodeOutputJob.setMapOutputKeyClass(LongWritable.class);
+			nodeOutputJob.setMapOutputValueClass(EdgeIdPropIdWritable.class);
+
+			nodeOutputJob.setMapperClass(NodeOutputMapper.class);
+			nodeOutputJob.setInputFormatClass(SequenceFileInputFormat.class);
+			FileInputFormat.addInputPath(nodeOutputJob, new Path(grouped));
+
+			nodeOutputJob.setReducerClass(NodeOutputReducer.class);
+//			nodeOutputJob.setReducerClass(NodeOutputAsTextReducer.class);
+			nodeOutputJob.setOutputKeyClass(NullWritable.class);
+			nodeOutputJob.setOutputValueClass(BytesWritable.class);
+//			nodeOutputJob.setOutputValueClass(Text.class);
+
+			nodeOutputJob.setOutputFormatClass(NewByteBufferOutputFormat.class);
+//			nodeOutputJob.setOutputFormatClass(TextOutputFormat.class);
+			FileOutputFormat.setOutputPath(nodeOutputJob, new Path(nodesOutput));
+
+			nodeOutputJob.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			nodeOutputJob.waitForCompletion(true);
+
+			Job edgeSurroundJob = new Job(conf, "Determine surrounding edges job.");
+			edgeSurroundJob.setGroupingComparatorClass(AscLongDescLongKeyGroupingComparator.class);
+			edgeSurroundJob.setSortComparatorClass(AscLongDescLongKeyComparator.class);
+			edgeSurroundJob.setPartitionerClass(AscLongDescLongWritablePartitioner.class);
+
+			edgeSurroundJob.setMapOutputKeyClass(AscLongDescLongWritable.class);
+			edgeSurroundJob.setMapOutputValueClass(EdgeWritable.class);
+
+			edgeSurroundJob.setMapperClass(EdgeSurroundMapper.class);
+			edgeSurroundJob.setInputFormatClass(SequenceFileInputFormat.class);
+			FileInputFormat.addInputPath(edgeSurroundJob, new Path(grouped));
+
+			edgeSurroundJob.setReducerClass(EdgeSurroundReducer.class);
+			edgeSurroundJob.setOutputKeyClass(NullWritable.class);
+			edgeSurroundJob.setOutputValueClass(SurroundingEdgeWritable.class);
+
+			edgeSurroundJob.setOutputFormatClass(SequenceFileOutputFormat.class);
+			FileOutputFormat.setOutputPath(edgeSurroundJob, new Path(surrounding));
+
+			edgeSurroundJob.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			edgeSurroundJob.waitForCompletion(true);
+
+			Job joinSurroundJob = new Job(conf, "Join surrounding edges job.");
+			joinSurroundJob.setGroupingComparatorClass(EdgeWritableKeyGroupingComparator.class);
+			joinSurroundJob.setSortComparatorClass(EdgeWritableKeyComparator.class);
+
+			joinSurroundJob.setMapOutputKeyClass(EdgeWritable.class);
+			joinSurroundJob.setMapOutputValueClass(SurroundingEdgeWritable.class);
+
+			joinSurroundJob.setMapperClass(JoinSurroundingEdgesMapper.class);
+			joinSurroundJob.setInputFormatClass(SequenceFileInputFormat.class);
+			FileInputFormat.addInputPath(joinSurroundJob, new Path(surrounding));
+
+			joinSurroundJob.setReducerClass(JoinSurroundingEdgesReducer.class);
+			joinSurroundJob.setOutputKeyClass(NullWritable.class);
+			joinSurroundJob.setOutputValueClass(DoubleSurroundingEdgeWritable.class);
+
+			joinSurroundJob.setOutputFormatClass(SequenceFileOutputFormat.class);
+			FileOutputFormat.setOutputPath(joinSurroundJob, new Path(joinededges));
+
+			joinSurroundJob.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			joinSurroundJob.waitForCompletion(true);
+
+			Job edgeOutputJob = new Job(conf, "Output edges job.");
+			edgeOutputJob.setPartitionerClass(EdgeOutputRownumPartitioner.class);
+
+			edgeOutputJob.setMapOutputKeyClass(LongWritable.class);
+			edgeOutputJob.setMapOutputValueClass(FullEdgeWritable.class);
+
+			edgeOutputJob.setMapperClass(EdgeOutputMapper.class);
+			edgeOutputJob.setInputFormatClass(SequenceFileInputFormat.class);
+			FileInputFormat.addInputPath(edgeOutputJob, new Path(joinededges));
+
+			edgeOutputJob.setReducerClass(EdgeOutputReducer.class);
+//			edgeOutputJob.setReducerClass(EdgeOutputAsTextReducer.class);
+			edgeOutputJob.setOutputKeyClass(NullWritable.class);
+			edgeOutputJob.setOutputValueClass(BytesWritable.class);
+//			edgeOutputJob.setOutputValueClass(Text.class);
+
+			edgeOutputJob.setOutputFormatClass(NewByteBufferOutputFormat.class);
+//			edgeOutputJob.setOutputFormatClass(TextOutputFormat.class);
+			FileOutputFormat.setOutputPath(edgeOutputJob, new Path(edgesOutput));
+
+			edgeOutputJob.setJarByClass(PureMRNodesAndEdgesJob.class);
+
+			edgeOutputJob.waitForCompletion(true);
+
+			Neo4JUtils.writeNeostore(output, conf);
+			Neo4JUtils.writeNodeIds(nrOfNodes, output, conf);
+			Neo4JUtils.writeEdgeIds(nrOfEdges, output, conf);
+			Neo4JUtils.writeSingleTypeStore("TRANSFER_TO", output, conf);
+
+
+		} catch (Exception e) {
+			System.err.println(e.getMessage());
+			e.printStackTrace(System.err);
+			return 1;
+		}
+
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/RownumPartitioner.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/RownumPartitioner.java
new file mode 100644
index 0000000..e42997f
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/RownumPartitioner.java
@@ -0,0 +1,38 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+
+import org.apache.hadoop.conf.Configurable;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mapreduce.Partitioner;
+
+public class RownumPartitioner<K, V> extends Partitioner<K, V> implements Configurable {
+
+	private long max = 0L;
+	private Configuration conf;
+	
+	@Override
+	public int getPartition(K key, V value, int numPartitions) {
+		double divider = Math.max(1, (double) max / numPartitions);
+
+		return (int) (((LongWritable) key).get() / divider);
+	}
+
+	@Override
+	public void setConf(Configuration conf) {
+		this.conf = conf;
+		configure();
+		
+	}
+
+	private void configure() {
+		this.max = Long.parseLong(getConf().get(AbstractMetaData.METADATA_NUMBER_OF_NODES));
+	}
+
+	@Override
+	public Configuration getConf() {
+		return conf;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/SurroundingContext.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/SurroundingContext.java
new file mode 100644
index 0000000..80f5585
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/SurroundingContext.java
@@ -0,0 +1,10 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+public class SurroundingContext {
+
+	public long nodeid = -1L, from = -1L, to = -1L, edgeid = -1L, edgeprop = -1L, prev = -1L, next = -1L;
+
+	public SurroundingContext() {
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputAsTextReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputAsTextReducer.java
new file mode 100644
index 0000000..10ba16e
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputAsTextReducer.java
@@ -0,0 +1,45 @@
+package nl.waredingen.graphs.neo.mapreduce.edges;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Reducer;
+
+public class EdgeOutputAsTextReducer extends Reducer<LongWritable, Text, NullWritable, Text> {
+	
+	private Text outputValue = new Text();
+	
+	protected void reduce(LongWritable key, Iterable<Text> values, Context context) throws IOException,
+			InterruptedException {
+		Iterator<Text> itr = values.iterator();
+		if (!itr.hasNext()) {
+			return;
+		}
+
+		// only use first record per key. Rest is duplicates from the selfjoin in the previous step
+		Text value = itr.next();
+
+		String[] vals = value.toString().split("\t", 6);
+		long relnum = key.get();
+		long from = Long.parseLong(vals[0]);
+		long to = Long.parseLong(vals[1]);
+		long fromprev = Long.parseLong(vals[2]);
+		long fromnext = Long.parseLong(vals[3]);
+		long toprev = Long.parseLong(vals[4]);
+		long tonext = Long.parseLong(vals[5]);
+		long prop = -1L;
+
+		writeEdge(relnum, from , to, 0, fromprev, fromnext, toprev, tonext, prop, context);
+	}
+
+	private void writeEdge(long relnum, long from, long to, int type, long fromprev, long fromnext, long toprev,
+			long tonext, long prop, Context context) throws IOException, InterruptedException {
+		//byte[] ba = Neo4JUtils.getEdgeAsByteArray(relnum, from, to, type, fromprev, fromnext, toprev, tonext, prop);
+		outputValue.set(relnum + "\t"+from  + "\t"+to + "\t"+type + "\t"+fromprev + "\t"+fromnext + "\t"+toprev + "\t"+tonext + "\t"+prop);
+		context.write(NullWritable.get(), outputValue);
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputMapper.java
new file mode 100644
index 0000000..7a55352
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputMapper.java
@@ -0,0 +1,28 @@
+package nl.waredingen.graphs.neo.mapreduce.edges;
+
+import java.io.IOException;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.DoubleSurroundingEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class EdgeOutputMapper extends Mapper<NullWritable, DoubleSurroundingEdgeWritable, LongWritable, FullEdgeWritable> {
+
+	private LongWritable outputKey = new LongWritable();
+	private FullEdgeWritable outputValue = new FullEdgeWritable();
+
+	protected void map(NullWritable key, DoubleSurroundingEdgeWritable value, Context context) throws IOException, InterruptedException {
+		SurroundingEdgeWritable left = value.getLeft();
+		SurroundingEdgeWritable right = value.getRight();
+		
+		if (left.getNodeId().equals(left.getFromNodeId())) {
+			outputKey.set(value.getLeft().getEdgeId().get());
+			outputValue.set(left.getFromNodeId(), left.getToNodeId(), left.getEdgePropId(), left.getEdgePrev(), left.getEdgeNext(), right.getEdgePrev(), right.getEdgeNext());
+			context.write(outputKey, outputValue);
+		}
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputReducer.java
new file mode 100644
index 0000000..289d47e
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputReducer.java
@@ -0,0 +1,49 @@
+package nl.waredingen.graphs.neo.mapreduce.edges;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgeWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.Reducer;
+
+public class EdgeOutputReducer extends Reducer<LongWritable, FullEdgeWritable, NullWritable, BytesWritable> {
+	
+	private BytesWritable outputValue = new BytesWritable();
+	
+	@Override
+	protected void reduce(LongWritable key, Iterable<FullEdgeWritable> values, Context context) throws IOException,
+			InterruptedException {
+		Iterator<FullEdgeWritable> itr = values.iterator();
+		if (!itr.hasNext()) {
+			return;
+		}
+
+		// only use first record per key. Rest is duplicates from the selfjoin in the previous step
+		FullEdgeWritable value = itr.next();
+
+		long relnum = key.get();
+
+		long from = value.getFromNodeId().get();
+		long to = value.getToNodeId().get();
+		long fromprev = value.getFromPrev().get();
+		long fromnext = value.getFromNext().get();
+		long toprev = value.getToPrev().get();
+		long tonext = value.getToNext().get();
+		long prop = value.getEdgeProp().get();
+
+		writeEdge(relnum, from , to, 0, fromprev, fromnext, toprev, tonext, prop, context);
+	}
+
+	private void writeEdge(long relnum, long from, long to, int type, long fromprev, long fromnext, long toprev,
+			long tonext, long prop, Context context) throws IOException, InterruptedException {
+		byte[] ba = Neo4JUtils.getEdgeAsByteArray(relnum, from, to, type, fromprev, fromnext, toprev, tonext, prop);
+		outputValue.set(ba, 0, ba.length);
+		context.write(NullWritable.get(), outputValue);
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputRownumPartitioner.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputRownumPartitioner.java
new file mode 100644
index 0000000..eccde69
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputRownumPartitioner.java
@@ -0,0 +1,13 @@
+package nl.waredingen.graphs.neo.mapreduce.edges;
+
+import nl.waredingen.graphs.neo.mapreduce.AbstractRownumPartitioner;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+public class EdgeOutputRownumPartitioner<K, V> extends AbstractRownumPartitioner<K, V> {
+
+	@Override
+	public long getMaxCounter() {
+		return Neo4JUtils.getMetaData(conf).getNumberOfEdges();
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundMapper.java
new file mode 100644
index 0000000..6f776de
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundMapper.java
@@ -0,0 +1,23 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround;
+
+import java.io.IOException;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class EdgeSurroundMapper extends Mapper<NullWritable, NodeEdgeWritable, AscLongDescLongWritable, EdgeWritable> {
+
+	private AscLongDescLongWritable outputKey = new AscLongDescLongWritable();
+
+	@Override
+	protected void map(NullWritable key, NodeEdgeWritable value, Context context) throws IOException, InterruptedException {
+		outputKey.setLeft(value.getNode().getNodeId());
+		outputKey.setRight(value.getEdge().getEdgeId());
+
+		context.write(outputKey, value.getEdge());
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundReducer.java
new file mode 100644
index 0000000..6d62834
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundReducer.java
@@ -0,0 +1,70 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import nl.waredingen.graphs.neo.mapreduce.SurroundingContext;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.Reducer;
+
+public class EdgeSurroundReducer extends Reducer<AscLongDescLongWritable, EdgeWritable, NullWritable, SurroundingEdgeWritable> {
+
+	private SurroundingEdgeWritable outputValue = new SurroundingEdgeWritable();
+
+	@Override
+	protected void reduce(AscLongDescLongWritable key, Iterable<EdgeWritable> values, Context context) throws IOException ,InterruptedException {
+		Iterator<EdgeWritable> iter = values.iterator();
+		
+		SurroundingContext edge = new SurroundingContext();
+		
+		while (iter.hasNext()) {
+			EdgeWritable value = iter.next();
+			
+			long id = key.getLeft().get();
+			long from = value.getFromNodeId().get();
+			long to = value.getToNodeId().get();
+			long relnum = value.getEdgeId().get();
+			long prop = value.getEdgePropId().get();
+			if (edge.nodeid == -1L) {
+				// first call, so set current fields
+				edge.nodeid = id;
+				edge.from = from;
+				edge.to = to;
+				edge.edgeid = relnum;
+				edge.edgeprop = prop;
+				edge.prev = -1L; // don't know yet
+				edge.next = -1L; // first call, relationships ordered descending, so last rel, so no next available
+
+			} else if (edge.prev == -1L) {
+				// not the first so current relationship will become prev in
+				// context and context can be emitted and refilled with
+				// current
+				edge.prev = relnum;
+
+				outputValue.set(edge.nodeid, edge.edgeid, edge.from, edge.to, edge.edgeprop, edge.prev, edge.next);
+				context.write(NullWritable.get(), outputValue);
+
+				long next = edge.edgeid;
+				edge.nodeid = id;
+				edge.from = from;
+				edge.to = to;
+				edge.edgeid = relnum;
+				edge.edgeprop = prop;
+				edge.prev = -1L; // don't know yet
+				edge.next = next;
+
+			}
+
+		}
+
+		// write out last context
+		outputValue.set(edge.nodeid, edge.edgeid, edge.from, edge.to, edge.edgeprop, edge.prev, edge.next);
+		context.write(NullWritable.get(), outputValue);
+
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeWritableKeyComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeWritableKeyComparator.java
new file mode 100644
index 0000000..0db45c1
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeWritableKeyComparator.java
@@ -0,0 +1,22 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround.join;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class EdgeWritableKeyComparator extends WritableComparator {
+	protected EdgeWritableKeyComparator() {
+		super(EdgeWritable.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable w1, WritableComparable w2) {
+		EdgeWritable k1 = (EdgeWritable) w1;
+		EdgeWritable k2 = (EdgeWritable) w2;
+
+		return k1.compareTo(k2);
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeWritableKeyGroupingComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeWritableKeyGroupingComparator.java
new file mode 100644
index 0000000..2d14236
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeWritableKeyGroupingComparator.java
@@ -0,0 +1,22 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround.join;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class EdgeWritableKeyGroupingComparator extends WritableComparator {
+	protected EdgeWritableKeyGroupingComparator() {
+		super(EdgeWritable.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable w1, WritableComparable w2) {
+		EdgeWritable k1 = (EdgeWritable) w1;
+		EdgeWritable k2 = (EdgeWritable) w2;
+
+		return k1.compareTo(k2);
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesMapper.java
new file mode 100644
index 0000000..96aaf88
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesMapper.java
@@ -0,0 +1,22 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround.join;
+
+import java.io.IOException;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class JoinSurroundingEdgesMapper extends Mapper<NullWritable, SurroundingEdgeWritable, EdgeWritable, SurroundingEdgeWritable> {
+
+	private EdgeWritable outputKey = new EdgeWritable();
+	private SurroundingEdgeWritable outputValue = new SurroundingEdgeWritable();
+
+	@Override
+	protected void map(NullWritable key, SurroundingEdgeWritable value, Context context) throws IOException, InterruptedException {
+		outputKey.set(value.getEdgeId(), value.getFromNodeId(), value.getToNodeId(), value.getEdgePropId());
+		outputValue.set(value.getNodeId(), value.getEdgeId(), value.getFromNodeId(), value.getToNodeId(), value.getEdgePropId(), value.getEdgePrev(), value.getEdgeNext());
+		context.write(outputKey, outputValue);
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesReducer.java
new file mode 100644
index 0000000..7e379a2
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesReducer.java
@@ -0,0 +1,42 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround.join;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.DoubleSurroundingEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.Reducer;
+
+public class JoinSurroundingEdgesReducer extends Reducer<EdgeWritable, SurroundingEdgeWritable, NullWritable, DoubleSurroundingEdgeWritable> {
+
+	private DoubleSurroundingEdgeWritable outputValue = new DoubleSurroundingEdgeWritable();
+
+	@Override
+	protected void reduce(EdgeWritable key, Iterable<SurroundingEdgeWritable> values, Context context) throws IOException, InterruptedException {
+		
+		Iterator<SurroundingEdgeWritable> iter = values.iterator();
+		if (!iter.hasNext()) {
+			return;
+		}
+
+		//Deep copy this to don't run into the pitfall of the hadoop iterable optimalization to reuse the next object
+		SurroundingEdgeWritable left = new SurroundingEdgeWritable(iter.next());
+
+		if (iter.hasNext()) {
+			SurroundingEdgeWritable right = new SurroundingEdgeWritable(iter.next());
+
+			if (!left.equals(right)) {
+				outputValue.set(left,right);
+
+				context.write(NullWritable.get(), outputValue);
+				outputValue.set(right,left);
+
+				context.write(NullWritable.get(), outputValue);
+			}
+		}
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesMapper.java
new file mode 100644
index 0000000..f842d7e
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesMapper.java
@@ -0,0 +1,43 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import java.io.IOException;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class GroupNodesAndEdgesMapper extends Mapper<NullWritable, Text, NodeEdgeIdWritable, EdgeWritable> {
+
+	private NodeEdgeIdWritable outputKey = new NodeEdgeIdWritable();
+	private EdgeWritable outputValue = new EdgeWritable();
+	private LongWritable edgeId = new LongWritable();
+	private LongWritable fromNodeId = new LongWritable();
+	private LongWritable toNodeId = new LongWritable();
+	private LongWritable edgePropId = new LongWritable();
+	private LongWritable fromPropId = new LongWritable();
+	private LongWritable toPropId = new LongWritable();
+
+	@Override
+	protected void map(NullWritable key, Text value, Context context) throws IOException ,InterruptedException {
+		//edgeid	fromnode	tonode	edgePropId	fromnodeid	fromPropId	tonodeid toPropId
+		String[] values = value.toString().split("\t", 8);
+
+		edgeId.set(Long.parseLong(values[0]));
+		edgePropId.set(Long.parseLong(values[3]));
+		fromNodeId.set(Long.parseLong(values[4]));
+		fromPropId.set(Long.parseLong(values[5]));
+		toNodeId.set(Long.parseLong(values[6]));
+		toPropId.set(Long.parseLong(values[7]));
+		outputValue.set(edgeId, fromNodeId, toNodeId, edgePropId);
+
+		outputKey.set(fromNodeId, fromPropId, edgeId);
+		context.write(outputKey, outputValue);
+		
+		outputKey.set(toNodeId, toPropId, edgeId);
+		context.write(outputKey, outputValue);
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesReducer.java
new file mode 100644
index 0000000..1b03ffb
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesReducer.java
@@ -0,0 +1,23 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import java.io.IOException;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.Reducer;
+
+public class GroupNodesAndEdgesReducer extends Reducer<NodeEdgeIdWritable, EdgeWritable, NullWritable, NodeEdgeWritable> {
+
+	private NodeEdgeWritable outputValue = new NodeEdgeWritable();
+	
+	@Override
+	protected void reduce(NodeEdgeIdWritable key, Iterable<EdgeWritable> values, Context context) throws IOException ,InterruptedException {
+		for (EdgeWritable value : values) {
+			outputValue.set(key.getNodeId().get(), key.getPropId().get(), value.getEdgeId().get(), value.getFromNodeId().get(), value.getToNodeId().get(), value.getEdgePropId().get());
+			context.write(NullWritable.get(), outputValue);
+		}
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyComparator.java
new file mode 100644
index 0000000..afc1772
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyComparator.java
@@ -0,0 +1,22 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class NodeAndEdgeIdKeyComparator extends WritableComparator {
+	protected NodeAndEdgeIdKeyComparator() {
+		super(NodeEdgeIdWritable.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable w1, WritableComparable w2) {
+		NodeEdgeIdWritable k1 = (NodeEdgeIdWritable) w1;
+		NodeEdgeIdWritable k2 = (NodeEdgeIdWritable) w2;
+
+		return k1.compareTo(k2);
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyGroupingComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyGroupingComparator.java
new file mode 100644
index 0000000..7cddacd
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyGroupingComparator.java
@@ -0,0 +1,22 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class NodeAndEdgeIdKeyGroupingComparator extends WritableComparator {
+	protected NodeAndEdgeIdKeyGroupingComparator() {
+		super(NodeEdgeIdWritable.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable w1, WritableComparable w2) {
+		NodeEdgeIdWritable k1 = (NodeEdgeIdWritable) w1;
+		NodeEdgeIdWritable k2 = (NodeEdgeIdWritable) w2;
+
+		return k1.getNodeId().compareTo(k2.getNodeId());
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyPartitioner.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyPartitioner.java
new file mode 100644
index 0000000..a323539
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyPartitioner.java
@@ -0,0 +1,15 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+
+import org.apache.hadoop.mapreduce.Partitioner;
+
+public class NodeAndEdgeIdKeyPartitioner extends Partitioner<NodeEdgeIdWritable, EdgeWritable> {
+
+	@Override
+	public int getPartition(NodeEdgeIdWritable key, EdgeWritable val, int numPartitions) {
+		return (key.getNodeId().hashCode() & Integer.MAX_VALUE) % numPartitions;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/AbstractMetaData.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/AbstractMetaData.java
new file mode 100644
index 0000000..e7a2415
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/AbstractMetaData.java
@@ -0,0 +1,116 @@
+package nl.waredingen.graphs.neo.mapreduce.input;
+
+import org.apache.hadoop.conf.Configuration;
+
+public abstract class AbstractMetaData implements MetaData {
+
+	public static final String METADATA_NUMBER_OF_NODES = "neo.db.creation.metadata.node.count";
+	public static final String METADATA_NUMBER_OF_NODE_PROPERTIES = "neo.db.creation.metadata.node.property.count";
+	public static final String METADATA_NUMBER_OF_EDGES = "neo.db.creation.metadata.edge.count";
+	public static final String METADATA_CLASS = "neo.db.creation.metadata.class";
+
+	private long numberOfNodes;
+	private long numberOfNodeProperties;
+	private long numberOfEdges;
+
+	public AbstractMetaData(Configuration conf) {
+		numberOfNodes = conf.getLong(METADATA_NUMBER_OF_NODES, 0L);
+		numberOfNodeProperties = conf.getLong(METADATA_NUMBER_OF_NODE_PROPERTIES, 0L);
+		numberOfEdges = conf.getLong(METADATA_NUMBER_OF_EDGES, 0L);
+	}
+	
+
+	public AbstractMetaData() {
+	}
+
+	public long getNumberOfNodes() {
+		return numberOfNodes;
+	}
+
+	public long getNumberOfNodeProperties() {
+		return numberOfNodeProperties;
+	}
+	
+	public long getNumberOfEdges() {
+		return numberOfEdges;
+	}
+
+	@Override
+	public int getNodePropertySize() {
+		return getNodeTypeNames().length;
+	}
+
+	@Override
+	public int getNodePropertyIndexForName(String name) {
+		return getPropertyIndexForName(name, getNodeTypeNames());
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public Class getNodePropertyTypeForName(String name) {
+		int nodePropertyIndexForName = getNodePropertyIndexForName(name);
+		if (nodePropertyIndexForName >= 0) {
+			return getNodeTypes()[nodePropertyIndexForName];
+		} else {
+			return String.class;
+		}
+	}
+
+	@Override
+	public int getNodeIdIndex() {
+		return getNodePropertyIndexForName(getNodeIdIdentifier());
+	}
+
+	@Override
+	public String[] getNodePropertyNames() {
+		return getNodeTypeNames();
+	}
+
+	@Override
+	public int getEdgePropertySize() {
+		return getEdgeTypeNames().length;
+	}
+
+	@Override
+	public int getEdgePropertyIndexForName(String name) {
+		return getPropertyIndexForName(name, getEdgeTypeNames());
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public Class getEdgePropertyTypeForName(String name) {
+		int edgePropertyIndexForName = getEdgePropertyIndexForName(name);
+		if (edgePropertyIndexForName >= 0) {
+			return getEdgeTypes()[edgePropertyIndexForName];
+		} else {
+			return String.class;
+		}
+	}
+
+	@Override
+	public int getEdgeFromNodeIdIndex() {
+		return getEdgePropertyIndexForName("from");
+	}
+
+	@Override
+	public int getEdgeToNodeIdIndex() {
+		return getEdgePropertyIndexForName("to");
+	}
+
+	@Override
+	public String[] getEdgePropertyNames() {
+		return getEdgeTypeNames();
+	}
+
+	private int getPropertyIndexForName(String name, String[] array) {
+		int result = -1;
+		for (int i = 0; i < array.length; i++) {
+			if (array[i] != null && array[i].equals(name)) {
+				result = i;
+			}
+		}
+		return result;
+	}
+
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/HardCodedMetaDataImpl.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/HardCodedMetaDataImpl.java
new file mode 100644
index 0000000..08330cb
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/HardCodedMetaDataImpl.java
@@ -0,0 +1,51 @@
+package nl.waredingen.graphs.neo.mapreduce.input;
+
+import org.apache.hadoop.conf.Configuration;
+
+
+public class HardCodedMetaDataImpl extends AbstractMetaData {
+
+	private final String[] nodeTypeNames = { "identifier", "name" };
+	@SuppressWarnings("rawtypes")
+	private final Class[] nodeTypes = { Long.class, String.class };
+	private final String[] edgeTypeNames = { "from", "to" };
+	@SuppressWarnings("rawtypes")
+	private final Class[] edgeTypes = { Long.class, Long.class };
+
+	public HardCodedMetaDataImpl(Configuration conf) {
+		super(conf);
+	}
+	
+	@Override
+	public boolean isDynamicTyping() {
+		return false;
+	}
+
+	@Override
+	public String[] getNodeTypeNames() {
+		return nodeTypeNames;
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public Class[] getNodeTypes() {
+		return nodeTypes;
+	}
+
+	@Override
+	public String[] getEdgeTypeNames() {
+		return edgeTypeNames;
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public Class[] getEdgeTypes() {
+		return edgeTypes;
+	}
+
+	@Override
+	public String getNodeIdIdentifier() {
+		return "identifier";
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/MetaData.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/MetaData.java
new file mode 100644
index 0000000..bebb2ab
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/MetaData.java
@@ -0,0 +1,49 @@
+package nl.waredingen.graphs.neo.mapreduce.input;
+
+public interface MetaData {
+	
+	public abstract boolean isDynamicTyping();
+	
+	public abstract String[] getNodeTypeNames();
+
+	@SuppressWarnings("rawtypes")
+	public abstract Class[] getNodeTypes();
+
+	public abstract String[] getEdgeTypeNames();
+	
+	@SuppressWarnings("rawtypes")
+	public abstract Class[] getEdgeTypes();
+	
+	public abstract String getNodeIdIdentifier();
+	
+	public int getNodePropertySize();
+
+	public int getNodePropertyIndexForName(String name);
+
+	@SuppressWarnings("rawtypes")
+	public Class getNodePropertyTypeForName(String name);
+	
+	public int getNodeIdIndex();
+
+	public String[] getNodePropertyNames();
+	
+	public int getEdgePropertySize();
+
+	public int getEdgePropertyIndexForName(String name);
+	
+	@SuppressWarnings("rawtypes")
+	public Class getEdgePropertyTypeForName(String name);
+	
+	public int getEdgeFromNodeIdIndex();
+
+	public int getEdgeToNodeIdIndex();
+	
+	public String[] getEdgePropertyNames();
+
+	public long getNumberOfNodes();
+
+	public long getNumberOfEdges();
+
+	public abstract long getNumberOfNodeProperties();
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/MetaDataFromConfigImpl.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/MetaDataFromConfigImpl.java
new file mode 100644
index 0000000..bd4008a
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/MetaDataFromConfigImpl.java
@@ -0,0 +1,80 @@
+package nl.waredingen.graphs.neo.mapreduce.input;
+
+import org.apache.hadoop.conf.Configuration;
+
+public class MetaDataFromConfigImpl extends AbstractMetaData {
+
+	public static final String METADATA_NODE_ID_NAME = "neo.db.creation.metadata.node.id.name";
+	public static final String METADATA_NODE_PROPERTY_NAMES = "neo.db.creation.metadata.node.property.names";
+	public static final String METADATA_NODE_PROPERTY_TYPE_PREFIX = "neo.db.creation.metadata.node.property.type.";
+	public static final String METADATA_EDGE_PROPERTY_TYPE_PREFIX = "neo.db.creation.metadata.edge.property.type.";
+	public static final String METADATA_EDGE_PROPERTY_NAMES = "neo.db.creation.metadata.edge.property.names";
+
+	private final String[] nodeTypeNames;
+	@SuppressWarnings("rawtypes")
+	private final Class[] nodeTypes;
+	private final String[] edgeTypeNames;
+	@SuppressWarnings("rawtypes")
+	private final Class[] edgeTypes;
+	private String nodeIdName;
+
+	public MetaDataFromConfigImpl(Configuration conf) {
+		super(conf);
+		nodeTypeNames = conf.getStrings(METADATA_NODE_PROPERTY_NAMES);
+		nodeIdName = conf.get(METADATA_NODE_ID_NAME);
+		nodeTypes = getNodeTypesFromConfig(conf);
+		edgeTypeNames = conf.getStrings(METADATA_EDGE_PROPERTY_NAMES);
+		edgeTypes = getEdgeTypesFromConfig(conf);
+	}
+	
+	@SuppressWarnings("rawtypes")
+	private Class[] getEdgeTypesFromConfig(Configuration conf) {
+		Class[] result = new Class[getEdgeTypeNames().length];
+		for (int i = 0; i < getEdgeTypeNames().length; i++) {
+			result[i] = conf.getClass(METADATA_EDGE_PROPERTY_TYPE_PREFIX+getEdgeTypeNames()[i], String.class);
+		}
+		return result;
+	}
+
+	@SuppressWarnings("rawtypes")
+	private Class[] getNodeTypesFromConfig(Configuration conf) {
+		Class[] result = new Class[getNodeTypeNames().length];
+		for (int i = 0; i < getNodeTypeNames().length; i++) {
+			result[i] = conf.getClass(METADATA_NODE_PROPERTY_TYPE_PREFIX+getNodeTypeNames()[i], String.class);
+		}
+		return result;
+	}
+
+	@Override
+	public boolean isDynamicTyping() {
+		return false;
+	}
+
+	@Override
+	public String[] getNodeTypeNames() {
+		return nodeTypeNames;
+	}
+
+	@Override
+	public String getNodeIdIdentifier() {
+		return nodeIdName;
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public Class[] getNodeTypes() {
+		return nodeTypes;
+	}
+
+	@Override
+	public String[] getEdgeTypeNames() {
+		return edgeTypeNames;
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public Class[] getEdgeTypes() {
+		return edgeTypes;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/AscLongDescLongWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/AscLongDescLongWritable.java
new file mode 100644
index 0000000..51aa2f2
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/AscLongDescLongWritable.java
@@ -0,0 +1,99 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class AscLongDescLongWritable implements WritableComparable {
+
+	private LongWritable left = new LongWritable();
+	private LongWritable right = new LongWritable();
+	
+	public AscLongDescLongWritable() {
+		
+	}
+	
+	public AscLongDescLongWritable(LongWritable left, LongWritable right) {
+		this.left = left;
+		this.right = right;
+	}
+	
+	public void setLeft(LongWritable left) {
+		this.left = left;
+	}
+	
+	public void setRight(LongWritable right) {
+		this.right = right;
+	}
+	
+	public LongWritable getLeft() {
+		return left;
+	}
+	
+	public LongWritable getRight() {
+		return right;
+	}
+	
+	@Override
+	public void write(DataOutput out) throws IOException {
+		left.write(out);
+		right.write(out);
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		left.readFields(in);
+		right.readFields(in);		
+	}
+
+	@Override
+	public int compareTo(Object obj) {
+		AscLongDescLongWritable other = (AscLongDescLongWritable) obj;
+		int leftDiff = left.compareTo(other.left);
+		// sort on left and descending on right
+		return (leftDiff == 0) ? -1 * right.compareTo(other.right) : leftDiff;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((left == null) ? 0 : left.hashCode());
+		result = prime * result + ((right == null) ? 0 : right.hashCode());
+		return result;
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		AscLongDescLongWritable other = (AscLongDescLongWritable) obj;
+		if (left == null) {
+			if (other.left != null)
+				return false;
+		} else if (!left.equals(other.left))
+			return false;
+		if (right == null) {
+			if (other.right != null)
+				return false;
+		} else if (!right.equals(other.right))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "AscLongDescLongWritable [left=" + left + ", right=" + right + "]";
+	}
+	
+
+}
+
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/ByteMarkerIdPropIdWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/ByteMarkerIdPropIdWritable.java
new file mode 100644
index 0000000..dadfdc8
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/ByteMarkerIdPropIdWritable.java
@@ -0,0 +1,115 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.ByteWritable;
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class ByteMarkerIdPropIdWritable implements WritableComparable {
+
+	private ByteWritable marker = new ByteWritable();
+	private LongWritable id = new LongWritable();
+	private IntWritable propId = new IntWritable();
+	
+	public ByteMarkerIdPropIdWritable() {
+		
+	}
+	
+	public ByteMarkerIdPropIdWritable(ByteWritable marker, LongWritable id, IntWritable propId) {
+		this.marker = marker;
+		this.id = id;
+		this.propId = propId;
+	}
+	
+	public void setMarker(ByteWritable marker) {
+		this.marker = marker;
+	}
+	
+	public void setIds(LongWritable id, IntWritable propId) {
+		this.id = id;
+		this.propId = propId;
+	}
+	
+	public ByteWritable getMarker() {
+		return marker;
+	}
+	
+	public LongWritable getId() {
+		return id;
+	}
+	
+	public IntWritable getPropId() {
+		return propId;
+	}
+	
+	@Override
+	public void write(DataOutput out) throws IOException {
+		marker.write(out);
+		id.write(out);
+		propId.write(out);
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		marker.readFields(in);
+		id.readFields(in);		
+		propId.readFields(in);		
+	}
+
+	@Override
+	public int compareTo(Object obj) {
+		ByteMarkerIdPropIdWritable other = (ByteMarkerIdPropIdWritable) obj;
+		int markerDiff = marker.compareTo(other.marker);
+		int nodeDiff = id.compareTo(other.id);
+		// sort on marker and then on nodeId and propertyId
+		return (markerDiff == 0) ?  (nodeDiff == 0) ? propId.compareTo(other.propId) : nodeDiff: markerDiff;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((id == null) ? 0 : id.hashCode());
+		result = prime * result + ((propId == null) ? 0 : propId.hashCode());
+		result = prime * result + ((marker == null) ? 0 : marker.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		ByteMarkerIdPropIdWritable other = (ByteMarkerIdPropIdWritable) obj;
+		if (id == null) {
+			if (other.id != null)
+				return false;
+		} else if (!id.equals(other.id))
+			return false;
+		if (propId == null) {
+			if (other.propId != null)
+				return false;
+		} else if (!propId.equals(other.propId))
+			return false;
+		if (marker == null) {
+			if (other.marker != null)
+				return false;
+		} else if (!marker.equals(other.marker))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "ByteMarkerIdPropIdWritable [marker=" + marker + ", id=" + id +  ", propId=" + propId + "]";
+	}
+
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/DoubleSurroundingEdgeWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/DoubleSurroundingEdgeWritable.java
new file mode 100644
index 0000000..d14b7aa
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/DoubleSurroundingEdgeWritable.java
@@ -0,0 +1,92 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class DoubleSurroundingEdgeWritable  implements WritableComparable {
+
+	private SurroundingEdgeWritable left = new SurroundingEdgeWritable();
+	private SurroundingEdgeWritable right = new SurroundingEdgeWritable();
+
+	public DoubleSurroundingEdgeWritable() {
+		
+	}
+
+	public DoubleSurroundingEdgeWritable(SurroundingEdgeWritable left, SurroundingEdgeWritable right) {
+		this.left = left;
+		this.right = right;
+	}
+	
+	public SurroundingEdgeWritable getLeft() {
+		return left;
+	}
+
+	public SurroundingEdgeWritable getRight() {
+		return right;
+	}
+
+	public void set(SurroundingEdgeWritable left, SurroundingEdgeWritable right) {
+		this.left = left;
+		this.right = right;
+	}
+	
+	@Override
+	public void write(DataOutput out) throws IOException {
+		left.write(out);
+		right.write(out);
+	}
+	
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		left.readFields(in);
+		right.readFields(in);
+	}
+	
+	@Override
+	public int compareTo(Object obj) {
+		DoubleSurroundingEdgeWritable other = (DoubleSurroundingEdgeWritable) obj;
+		int leftDiff = left.compareTo(other.left);
+		return (leftDiff == 0) ? right.compareTo(other.right): leftDiff; 
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((left == null) ? 0 : left.hashCode());
+		result = prime * result + ((right == null) ? 0 : right.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		DoubleSurroundingEdgeWritable other = (DoubleSurroundingEdgeWritable) obj;
+		if (left == null) {
+			if (other.left != null)
+				return false;
+		} else if (!left.equals(other.left))
+			return false;
+		if (right == null) {
+			if (other.right != null)
+				return false;
+		} else if (!right.equals(other.right))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "DoubleSurroundingEdgeWritable [left=" + left + ", right=" + right + "]";
+	}
+	
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/EdgeIdPropIdWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/EdgeIdPropIdWritable.java
new file mode 100644
index 0000000..b7a9838
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/EdgeIdPropIdWritable.java
@@ -0,0 +1,94 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class EdgeIdPropIdWritable implements WritableComparable {
+
+	private LongWritable edgeId = new LongWritable();
+	private LongWritable propId = new LongWritable();
+	
+	public EdgeIdPropIdWritable() {
+		
+	}
+	
+	public EdgeIdPropIdWritable(long edgeId, long propId) {
+		this.edgeId = new LongWritable(edgeId);
+		this.propId = new LongWritable(propId);
+	}
+	
+	public void set(LongWritable edgeId, LongWritable propId) {
+		this.edgeId = edgeId;
+		this.propId = propId;
+	}
+	
+	public LongWritable getEdgeId() {
+		return edgeId;
+	}
+
+	public LongWritable getPropId() {
+		return propId;
+	}
+
+	@Override
+	public void write(DataOutput out) throws IOException {
+		edgeId.write(out);
+		propId.write(out);
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		edgeId.readFields(in);
+		propId.readFields(in);		
+	}
+
+	@Override
+	public int compareTo(Object obj) {
+		EdgeIdPropIdWritable other = (EdgeIdPropIdWritable) obj;
+		int edgeDiff = edgeId.compareTo(other.edgeId);
+		return (edgeDiff == 0) ? propId.compareTo(other.edgeId) : edgeDiff;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((propId == null) ? 0 : propId.hashCode());
+		result = prime * result + ((edgeId == null) ? 0 : edgeId.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		EdgeIdPropIdWritable other = (EdgeIdPropIdWritable) obj;
+		if (propId == null) {
+			if (other.propId != null)
+				return false;
+		} else if (!propId.equals(other.propId))
+			return false;
+		if (edgeId == null) {
+			if (other.edgeId != null)
+				return false;
+		} else if (!edgeId.equals(other.edgeId))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "EdgeIdPropIdWritable [edgeId=" + edgeId + ", propId=" + propId + "]";
+	}
+
+}
+
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/EdgePropertyOutputCountersAndValueWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/EdgePropertyOutputCountersAndValueWritable.java
new file mode 100644
index 0000000..e497be5
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/EdgePropertyOutputCountersAndValueWritable.java
@@ -0,0 +1,136 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Writable;
+
+public class EdgePropertyOutputCountersAndValueWritable  implements Writable {
+	private LongWritable id;
+	private FullEdgePropertiesWritable value;
+	private long countBlockOffset;
+	private long countIdOffset;
+	private int partition;
+	
+	public static final FullEdgePropertiesWritable EMPTY_VAL = new FullEdgePropertiesWritable(-1, null, null, -1, -1, -1, -1, -1, "");
+	public static final LongWritable EMPTY_ID = new LongWritable(Long.MIN_VALUE);
+	
+	public void setValues(LongWritable id, FullEdgePropertiesWritable value) {
+		this.id = id;
+		this.value = value;
+		this.countBlockOffset = -1L;
+		this.countIdOffset = -1L;
+		this.partition = -1;
+	}
+	
+	public void setCounter(int partition, long blockCount, long idOffsetCount) {
+		this.id = EMPTY_ID;
+		this.value = EMPTY_VAL;
+		this.partition = partition;
+		this.countBlockOffset = blockCount;
+		this.countIdOffset = idOffsetCount;
+	}
+	
+	public long getBlockOffset() {
+		return countBlockOffset;
+	}
+
+	public long getIdOffset() {
+		return countIdOffset;
+	}
+	
+	public int getPartition() {
+		return partition;
+	}
+	
+	public FullEdgePropertiesWritable getValue() {
+		return value;
+	}
+	
+	public LongWritable getId() {
+		return id;
+	}
+	
+	@Override
+	public void write(DataOutput out) throws IOException {
+		id.write(out);
+		value.write(out);
+		if (id.equals(EMPTY_ID)) {
+			out.writeInt(partition);
+			out.writeLong(countBlockOffset);
+			out.writeLong(countIdOffset);
+		}
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		if (id == null) {
+			id = new LongWritable();
+		}
+		id.readFields(in);
+		if (value == null) {
+			value = new FullEdgePropertiesWritable();
+		}
+		value.readFields(in);
+		
+		if (id.equals(EMPTY_ID)) {
+			partition = in.readInt();
+			countBlockOffset = in.readLong();
+			countIdOffset = in.readLong();
+		} else {
+			partition = -1;
+			countBlockOffset = -1L;
+			countIdOffset = -1L;
+		}
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + (int) (countBlockOffset ^ (countBlockOffset >>> 32));
+		result = prime * result + (int) (countIdOffset ^ (countIdOffset >>> 32));
+		result = prime * result + ((id == null) ? 0 : id.hashCode());
+		result = prime * result + partition;
+		result = prime * result + ((value == null) ? 0 : value.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		EdgePropertyOutputCountersAndValueWritable other = (EdgePropertyOutputCountersAndValueWritable) obj;
+		if (countBlockOffset != other.countBlockOffset)
+			return false;
+		if (countIdOffset != other.countIdOffset)
+			return false;
+		if (id == null) {
+			if (other.id != null)
+				return false;
+		} else if (!id.equals(other.id))
+			return false;
+		if (partition != other.partition)
+			return false;
+		if (value == null) {
+			if (other.value != null)
+				return false;
+		} else if (!value.equals(other.value))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "EdgePropertyOutputCountersAndValueWritable [id=" + id + ", value=" + value + ", countBlockOffset=" + countBlockOffset + ", countIdOffset="
+				+ countIdOffset + ", partition=" + partition + "]";
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/EdgeWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/EdgeWritable.java
new file mode 100644
index 0000000..67221c3
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/EdgeWritable.java
@@ -0,0 +1,127 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class EdgeWritable  implements WritableComparable {
+
+	private LongWritable edgeId = new LongWritable();
+	private LongWritable fromNodeId = new LongWritable();
+	private LongWritable toNodeId = new LongWritable();
+	private LongWritable edgePropId = new LongWritable();
+
+	public EdgeWritable() {
+		
+	}
+
+	public EdgeWritable(long edgeId, long from, long to, long prop) {
+		this.edgeId = new LongWritable(edgeId);
+		this.fromNodeId = new LongWritable(from);
+		this.toNodeId = new LongWritable(to);
+		this.edgePropId = new LongWritable(prop);
+	}
+
+	public void set(LongWritable edgeId, LongWritable fromNodeId, LongWritable toNodeId, LongWritable prop) {
+		this.edgeId = edgeId;
+		this.fromNodeId = fromNodeId;
+		this.toNodeId = toNodeId;
+		this.edgePropId = prop;
+	}
+	
+	public LongWritable getEdgeId() {
+		return edgeId;
+	}
+	
+	public LongWritable getFromNodeId() {
+		return fromNodeId;
+	}
+
+	public LongWritable getToNodeId() {
+		return toNodeId;
+	}
+
+	public LongWritable getEdgePropId() {
+		return edgePropId;
+	}
+	
+	@Override
+	public void write(DataOutput out) throws IOException {
+		edgeId.write(out);
+		fromNodeId.write(out);
+		toNodeId.write(out);
+		edgePropId.write(out);
+	}
+	
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		edgeId.readFields(in);		
+		fromNodeId.readFields(in);		
+		toNodeId.readFields(in);
+		edgePropId.readFields(in);
+	}
+	
+	@Override
+	public int compareTo(Object obj) {
+		EdgeWritable other = (EdgeWritable) obj;
+		int edgeDiff = edgeId.compareTo(other.edgeId);
+		int fromDiff = fromNodeId.compareTo(other.fromNodeId);
+		int toDiff = toNodeId.compareTo(other.toNodeId);
+		int propDiff = edgePropId.compareTo(other.edgePropId);
+		return (edgeDiff == 0) ? (fromDiff == 0) ? (toDiff ==0) ? propDiff : toDiff: fromDiff : edgeDiff;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((edgeId == null) ? 0 : edgeId.hashCode());
+		result = prime * result + ((fromNodeId == null) ? 0 : fromNodeId.hashCode());
+		result = prime * result + ((toNodeId == null) ? 0 : toNodeId.hashCode());
+		result = prime * result + ((edgePropId == null) ? 0 : edgePropId.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		EdgeWritable other = (EdgeWritable) obj;
+		if (edgeId == null) {
+			if (other.edgeId != null)
+				return false;
+		} else if (!edgeId.equals(other.edgeId))
+			return false;
+		if (fromNodeId == null) {
+			if (other.fromNodeId != null)
+				return false;
+		} else if (!fromNodeId.equals(other.fromNodeId))
+			return false;
+		if (toNodeId == null) {
+			if (other.toNodeId != null)
+				return false;
+		} else if (!toNodeId.equals(other.toNodeId))
+			return false;
+		if (edgePropId == null) {
+			if (other.edgePropId != null)
+				return false;
+		} else if (!edgePropId.equals(other.edgePropId))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "EdgeWritable [edgeId=" + edgeId + ", fromNodeId=" + fromNodeId + ", toNodeId=" + toNodeId  + ", edgePropId=" + edgePropId+ "]";
+	}
+
+	
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/FullEdgePropertiesWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/FullEdgePropertiesWritable.java
new file mode 100644
index 0000000..228f5d3
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/FullEdgePropertiesWritable.java
@@ -0,0 +1,207 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class FullEdgePropertiesWritable  implements WritableComparable {
+
+	private LongWritable edgeId = new LongWritable();
+	private Text fromNodeIdentifier = new Text();
+	private Text toNodeIdentifier = new Text();
+	private IntWritable propertyIndex = new IntWritable();
+	private LongWritable blockCount = new LongWritable();
+	private PropertyListWritable properties = new PropertyListWritable();
+	private LongWritable prevProp = new LongWritable();
+	private LongWritable nextProp = new LongWritable();
+
+	public FullEdgePropertiesWritable() {
+		
+	}
+	
+	public FullEdgePropertiesWritable(long edgeId, String fromNode, String toNode, int propIndex, long blockCount, long prevProp, long nextProp, int propKeyIndex, String val) {
+		this.set(edgeId, fromNode, toNode, propIndex, blockCount, prevProp, nextProp, propKeyIndex, val);
+	}
+
+	public void set(FullEdgePropertiesWritable other) {
+		String[] props = other.getProperties().valuesToArray();
+		int[] keys = other.getProperties().keysToArray();
+		for (int i=0; i < props.length; i++) {
+			if (i ==0 ) {
+			this.set(other.getEdgeId().get(), other.getFromNodeIdentifier().toString(), other.getToNodeIdentifier().toString(), other.getPropertyIndex().get(), other.getBlockCount().get(), other.getPrevProp().get(), other.getNextProp().get(), keys[i], props[i] );
+			} else {
+				this.add(keys[i], props[i], 0);
+			}
+		}
+	}
+	
+	public void set(long edgeId, String fromNode, String toNode, int propIndex, long blockCount, long prevProp, long nextProp, int propKeyIndex, String val) {
+		this.edgeId = new LongWritable(edgeId);
+		if (fromNode != null) this.fromNodeIdentifier = new Text(fromNode);
+		if (toNode != null) this.toNodeIdentifier = new Text(toNode);
+		this.propertyIndex = new IntWritable(propIndex);
+		this.blockCount = new LongWritable(blockCount);
+		this.prevProp = new LongWritable(prevProp);
+		this.nextProp = new LongWritable(nextProp);
+		this.properties = new PropertyListWritable();
+		this.properties.add(propKeyIndex, val);
+		
+	}
+
+	public void add(int propKeyIndex, String string, int blockCount) {
+		this.properties.add(propKeyIndex, string);
+		this.blockCount = new LongWritable(blockCount + this.blockCount.get());
+	}
+	
+	public LongWritable getEdgeId() {
+		return edgeId;
+	}
+
+	public Text getFromNodeIdentifier() {
+		return fromNodeIdentifier;
+	}
+
+	public Text getToNodeIdentifier() {
+		return toNodeIdentifier;
+	}
+
+	public IntWritable getPropertyIndex() {
+		return propertyIndex;
+	}
+
+	public LongWritable getBlockCount() {
+		return blockCount;
+	}
+
+	public PropertyListWritable getProperties() {
+		return properties;
+	}
+
+	public LongWritable getPrevProp() {
+		return prevProp;
+	}
+
+	public LongWritable getNextProp() {
+		return nextProp;
+	}
+
+	@Override
+	public void write(DataOutput out) throws IOException {
+		edgeId.write(out);
+		fromNodeIdentifier.write(out);
+		toNodeIdentifier.write(out);
+		propertyIndex.write(out);
+		blockCount.write(out);
+		properties.write(out);
+		prevProp.write(out);
+		nextProp.write(out);		
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		edgeId.readFields(in);
+		fromNodeIdentifier.readFields(in);
+		toNodeIdentifier.readFields(in);
+		propertyIndex.readFields(in);
+		blockCount.readFields(in);
+		properties.readFields(in);
+		prevProp.readFields(in);
+		nextProp.readFields(in);
+	}
+
+	@Override
+	public int compareTo(Object o) {
+		FullEdgePropertiesWritable obj = (FullEdgePropertiesWritable) o;
+		int edgeDiff = edgeId.compareTo(obj.edgeId);
+		int fromDiff = fromNodeIdentifier.compareTo(obj.fromNodeIdentifier);
+		int toDiff = toNodeIdentifier.compareTo(obj.toNodeIdentifier);
+		int indexDiff = propertyIndex.compareTo(obj.propertyIndex);
+		int cntDiff = blockCount.compareTo(obj.blockCount);
+		int propDiff = properties.compareTo(obj.properties);
+		int prevDiff = prevProp.compareTo(obj.prevProp);
+		int nextDiff = nextProp.compareTo(obj.nextProp);
+		return (edgeDiff == 0) ? (fromDiff == 0) ? (toDiff == 0) ? (indexDiff == 0) ? (cntDiff == 0) ? (propDiff == 0) ? (prevDiff == 0) ? nextDiff : prevDiff : propDiff : cntDiff : indexDiff : toDiff : fromDiff: edgeDiff;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((blockCount == null) ? 0 : blockCount.hashCode());
+		result = prime * result + ((edgeId == null) ? 0 : edgeId.hashCode());
+		result = prime * result + ((fromNodeIdentifier == null) ? 0 : fromNodeIdentifier.hashCode());
+		result = prime * result + ((nextProp == null) ? 0 : nextProp.hashCode());
+		result = prime * result + ((prevProp == null) ? 0 : prevProp.hashCode());
+		result = prime * result + ((properties == null) ? 0 : properties.hashCode());
+		result = prime * result + ((propertyIndex == null) ? 0 : propertyIndex.hashCode());
+		result = prime * result + ((toNodeIdentifier == null) ? 0 : toNodeIdentifier.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		FullEdgePropertiesWritable other = (FullEdgePropertiesWritable) obj;
+		if (blockCount == null) {
+			if (other.blockCount != null)
+				return false;
+		} else if (!blockCount.equals(other.blockCount))
+			return false;
+		if (edgeId == null) {
+			if (other.edgeId != null)
+				return false;
+		} else if (!edgeId.equals(other.edgeId))
+			return false;
+		if (fromNodeIdentifier == null) {
+			if (other.fromNodeIdentifier != null)
+				return false;
+		} else if (!fromNodeIdentifier.equals(other.fromNodeIdentifier))
+			return false;
+		if (nextProp == null) {
+			if (other.nextProp != null)
+				return false;
+		} else if (!nextProp.equals(other.nextProp))
+			return false;
+		if (prevProp == null) {
+			if (other.prevProp != null)
+				return false;
+		} else if (!prevProp.equals(other.prevProp))
+			return false;
+		if (properties == null) {
+			if (other.properties != null)
+				return false;
+		} else if (!properties.equals(other.properties))
+			return false;
+		if (propertyIndex == null) {
+			if (other.propertyIndex != null)
+				return false;
+		} else if (!propertyIndex.equals(other.propertyIndex))
+			return false;
+		if (toNodeIdentifier == null) {
+			if (other.toNodeIdentifier != null)
+				return false;
+		} else if (!toNodeIdentifier.equals(other.toNodeIdentifier))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "FullEdgePropertiesWritable [edgeId=" + edgeId + ", fromNodeIdentifier=" + fromNodeIdentifier + ", toNodeIdentifier=" + toNodeIdentifier
+				+ ", propertyIndex=" + propertyIndex + ", blockCount=" + blockCount + ", properties=" + properties + ", prevProp=" + prevProp + ", nextProp="
+				+ nextProp + "]";
+	}
+
+	
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/FullEdgeWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/FullEdgeWritable.java
new file mode 100644
index 0000000..d0d6287
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/FullEdgeWritable.java
@@ -0,0 +1,180 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class FullEdgeWritable  implements WritableComparable {
+
+	private LongWritable fromNodeId = new LongWritable();
+	private LongWritable toNodeId = new LongWritable();
+	private LongWritable fromPrev = new LongWritable();
+	private LongWritable fromNext = new LongWritable();
+	private LongWritable toPrev = new LongWritable();
+	private LongWritable toNext = new LongWritable();
+	private LongWritable edgeProp = new LongWritable();
+
+	public FullEdgeWritable() {
+		
+	}
+	
+	public FullEdgeWritable(long fromNode, long toNode, long edgeProp, long fromPrev, long fromNext, long toPrev, long toNext) {
+		this.set(fromNode, toNode, edgeProp, fromPrev, fromNext, toPrev, toNext);
+	}
+	
+	public LongWritable getFromNodeId() {
+		return fromNodeId;
+	}
+
+	public LongWritable getToNodeId() {
+		return toNodeId;
+	}
+
+	public LongWritable getEdgeProp() {
+		return edgeProp;
+	}
+	
+	public LongWritable getFromPrev() {
+		return fromPrev;
+	}
+
+	public LongWritable getFromNext() {
+		return fromNext;
+	}
+
+	public LongWritable getToPrev() {
+		return toPrev;
+	}
+
+	public LongWritable getToNext() {
+		return toNext;
+	}
+
+	public void set(long fromNode, long toNode, long edgeProp, long fromPrev, long fromNext, long toPrev, long toNext) {
+		this.fromNodeId = new LongWritable(fromNode);
+		this.toNodeId = new LongWritable(toNode);
+		this.edgeProp = new LongWritable(edgeProp);
+		this.fromPrev = new LongWritable(fromPrev);
+		this.fromNext = new LongWritable(fromNext);
+		this.toPrev = new LongWritable(toPrev);
+		this.toNext = new LongWritable(toNext);
+	}
+	
+	public void set(LongWritable fromNode, LongWritable toNode, LongWritable edgeProp, LongWritable fromPrev, LongWritable fromNext, LongWritable toPrev, LongWritable toNext) {
+		this.fromNodeId = fromNode;
+		this.toNodeId = toNode;
+		this.edgeProp = edgeProp;
+		this.fromPrev = fromPrev;
+		this.fromNext = fromNext;
+		this.toPrev = toPrev;
+		this.toNext = toNext;
+	}
+	
+	@Override
+	public void write(DataOutput out) throws IOException {
+		fromNodeId.write(out);
+		toNodeId.write(out);
+		edgeProp.write(out);
+		fromPrev.write(out);
+		fromNext.write(out);
+		toPrev.write(out);
+		toNext.write(out);
+	}
+	
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		fromNodeId.readFields(in);
+		toNodeId.readFields(in);
+		edgeProp.readFields(in);
+		fromPrev.readFields(in);
+		fromNext.readFields(in);
+		toPrev.readFields(in);
+		toNext.readFields(in);
+	}
+	
+	@Override
+	public int compareTo(Object obj) {
+		FullEdgeWritable other = (FullEdgeWritable) obj;
+		int nodeDiff = fromPrev.compareTo(other.fromPrev);
+		int edgeDiff = fromNext.compareTo(other.fromNext);
+		int propDiff = edgeProp.compareTo(other.edgeProp);
+		int fromDiff = fromNodeId.compareTo(other.fromNodeId);
+		int toDiff = toNodeId.compareTo(other.toNodeId);
+		int prevDiff = toPrev.compareTo(other.toPrev);
+		int nextDiff = toNext.compareTo(other.toNext);
+		return (nodeDiff == 0) ? (edgeDiff == 0) ? (propDiff == 0) ? (fromDiff == 0) ? (toDiff == 0) ? (prevDiff == 0) ? nextDiff: prevDiff : toDiff : fromDiff : propDiff : edgeDiff : nodeDiff;
+	}
+	
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((fromNext == null) ? 0 : fromNext.hashCode());
+		result = prime * result + ((toNext == null) ? 0 : toNext.hashCode());
+		result = prime * result + ((toPrev == null) ? 0 : toPrev.hashCode());
+		result = prime * result + ((fromNodeId == null) ? 0 : fromNodeId.hashCode());
+		result = prime * result + ((fromPrev == null) ? 0 : fromPrev.hashCode());
+		result = prime * result + ((toNodeId == null) ? 0 : toNodeId.hashCode());
+		result = prime * result + ((edgeProp == null) ? 0 : edgeProp.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		FullEdgeWritable other = (FullEdgeWritable) obj;
+		if (fromNext == null) {
+			if (other.fromNext != null)
+				return false;
+		} else if (!fromNext.equals(other.fromNext))
+			return false;
+		if (toNext == null) {
+			if (other.toNext != null)
+				return false;
+		} else if (!toNext.equals(other.toNext))
+			return false;
+		if (toPrev == null) {
+			if (other.toPrev != null)
+				return false;
+		} else if (!toPrev.equals(other.toPrev))
+			return false;
+		if (fromNodeId == null) {
+			if (other.fromNodeId != null)
+				return false;
+		} else if (!fromNodeId.equals(other.fromNodeId))
+			return false;
+		if (fromPrev == null) {
+			if (other.fromPrev != null)
+				return false;
+		} else if (!fromPrev.equals(other.fromPrev))
+			return false;
+		if (toNodeId == null) {
+			if (other.toNodeId != null)
+				return false;
+		} else if (!toNodeId.equals(other.toNodeId))
+			return false;
+		if (edgeProp == null) {
+			if (other.edgeProp != null)
+				return false;
+		} else if (!edgeProp.equals(other.edgeProp))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "FullEdgeWritable [fromNodeId=" + fromNodeId + ", toNodeId=" + toNodeId + ", edgeProp=" + edgeProp + ", fromPrev=" + fromPrev + ", fromNext=" + fromNext + ", toPrev="
+				+ toPrev + ", toNext=" + toNext + "]";
+	}
+
+
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/FullNodePropertiesWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/FullNodePropertiesWritable.java
new file mode 100644
index 0000000..f106a85
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/FullNodePropertiesWritable.java
@@ -0,0 +1,191 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class FullNodePropertiesWritable  implements WritableComparable {
+
+	private LongWritable nodeId = new LongWritable();
+	private Text nodeIdentifier = new Text();
+	private IntWritable propertyIndex = new IntWritable();
+	private LongWritable blockCount = new LongWritable();
+	private PropertyListWritable properties = new PropertyListWritable();
+	private LongWritable prevProp = new LongWritable();
+	private LongWritable nextProp = new LongWritable();
+
+	public FullNodePropertiesWritable() {
+		
+	}
+	
+	public FullNodePropertiesWritable(long nodeId, String node, int propIndex, long blockCount, long prevProp, long nextProp, int propKeyIndex, String val) {
+		this.set(nodeId, node, propIndex, blockCount, prevProp, nextProp, propKeyIndex, val);
+	}
+
+	public void set(FullNodePropertiesWritable other) {
+		String[] props = other.getProperties().valuesToArray();
+		int[] keys = other.getProperties().keysToArray();
+		for (int i=0; i < props.length; i++) {
+			if (i==0) {
+				this.set(other.getNodeId().get(), other.getNodeIdentifier().toString(), other.getPropertyIndex().get(), other.getBlockCount().get(), other.getPrevProp().get(), other.getNextProp().get(), keys[i], props[i]);
+			} else {
+				this.add(keys[i], props[i], 0);
+			}
+		}
+	}
+	
+	public void set(long nodeId, String node, int propIndex, long blockCount, long prevProp, long nextProp, int propKeyIndex, String val) {
+		this.nodeId = new LongWritable(nodeId);
+		if (node != null) this.nodeIdentifier = new Text(node);
+		this.propertyIndex = new IntWritable(propIndex);
+		this.blockCount = new LongWritable(blockCount);
+		this.prevProp = new LongWritable(prevProp);
+		this.nextProp = new LongWritable(nextProp);
+		this.properties = new PropertyListWritable();
+		this.properties.add(propKeyIndex, val);
+	}
+
+	public void add(int propKeyIndex, String string, int blockCount) {
+		this.properties.add(propKeyIndex, string);
+		this.blockCount = new LongWritable(blockCount + this.blockCount.get());
+	}
+	
+	public LongWritable getNodeId() {
+		return nodeId;
+	}
+
+	public Text getNodeIdentifier() {
+		return nodeIdentifier;
+	}
+
+	public IntWritable getPropertyIndex() {
+		return propertyIndex;
+	}
+
+	public LongWritable getBlockCount() {
+		return blockCount;
+	}
+
+	public PropertyListWritable getProperties() {
+		return properties;
+	}
+
+	public LongWritable getPrevProp() {
+		return prevProp;
+	}
+
+	public LongWritable getNextProp() {
+		return nextProp;
+	}
+
+	@Override
+	public void write(DataOutput out) throws IOException {
+		nodeId.write(out);
+		nodeIdentifier.write(out);
+		propertyIndex.write(out);
+		blockCount.write(out);
+		properties.write(out);
+		prevProp.write(out);
+		nextProp.write(out);		
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		nodeId.readFields(in);
+		nodeIdentifier.readFields(in);
+		propertyIndex.readFields(in);
+		blockCount.readFields(in);
+		properties.readFields(in);
+		prevProp.readFields(in);
+		nextProp.readFields(in);
+	}
+
+	@Override
+	public int compareTo(Object o) {
+		FullNodePropertiesWritable obj = (FullNodePropertiesWritable) o;
+		int nodeDiff = nodeId.compareTo(obj.nodeId);
+		int fromDiff = nodeIdentifier.compareTo(obj.nodeIdentifier);
+		int indexDiff = propertyIndex.compareTo(obj.propertyIndex);
+		int cntDiff = blockCount.compareTo(obj.blockCount);
+		int propDiff = properties.compareTo(obj.properties);
+		int prevDiff = prevProp.compareTo(obj.prevProp);
+		int nextDiff = nextProp.compareTo(obj.nextProp);
+		return (nodeDiff == 0) ? (fromDiff == 0) ? (indexDiff == 0) ? (cntDiff == 0) ? (propDiff == 0) ? (prevDiff == 0) ? nextDiff : prevDiff : propDiff : cntDiff : indexDiff : fromDiff: nodeDiff;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((blockCount == null) ? 0 : blockCount.hashCode());
+		result = prime * result + ((nodeId == null) ? 0 : nodeId.hashCode());
+		result = prime * result + ((nodeIdentifier == null) ? 0 : nodeIdentifier.hashCode());
+		result = prime * result + ((nextProp == null) ? 0 : nextProp.hashCode());
+		result = prime * result + ((prevProp == null) ? 0 : prevProp.hashCode());
+		result = prime * result + ((properties == null) ? 0 : properties.hashCode());
+		result = prime * result + ((propertyIndex == null) ? 0 : propertyIndex.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		FullNodePropertiesWritable other = (FullNodePropertiesWritable) obj;
+		if (blockCount == null) {
+			if (other.blockCount != null)
+				return false;
+		} else if (!blockCount.equals(other.blockCount))
+			return false;
+		if (nodeId == null) {
+			if (other.nodeId != null)
+				return false;
+		} else if (!nodeId.equals(other.nodeId))
+			return false;
+		if (nodeIdentifier == null) {
+			if (other.nodeIdentifier != null)
+				return false;
+		} else if (!nodeIdentifier.equals(other.nodeIdentifier))
+			return false;
+		if (nextProp == null) {
+			if (other.nextProp != null)
+				return false;
+		} else if (!nextProp.equals(other.nextProp))
+			return false;
+		if (prevProp == null) {
+			if (other.prevProp != null)
+				return false;
+		} else if (!prevProp.equals(other.prevProp))
+			return false;
+		if (properties == null) {
+			if (other.properties != null)
+				return false;
+		} else if (!properties.equals(other.properties))
+			return false;
+		if (propertyIndex == null) {
+			if (other.propertyIndex != null)
+				return false;
+		} else if (!propertyIndex.equals(other.propertyIndex))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "FullNodePropertiesWritable [nodeId=" + nodeId + ", nodeIdentifier=" + nodeIdentifier 
+				+ ", propertyIndex=" + propertyIndex + ", blockCount=" + blockCount + ", properties=" + properties + ", prevProp=" + prevProp + ", nextProp="
+				+ nextProp + "]";
+	}
+
+	
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodeEdgeIdWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodeEdgeIdWritable.java
new file mode 100644
index 0000000..d664618
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodeEdgeIdWritable.java
@@ -0,0 +1,110 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class NodeEdgeIdWritable implements WritableComparable {
+
+	private LongWritable nodeId = new LongWritable();
+	private LongWritable propId = new LongWritable();
+	private LongWritable edgeId = new LongWritable();
+	
+	public NodeEdgeIdWritable() {
+		
+	}
+	
+	public NodeEdgeIdWritable(long nodeId, long propId, long edgeId) {
+		this.nodeId = new LongWritable(nodeId);
+		this.propId = new LongWritable(propId);
+		this.edgeId = new LongWritable(edgeId);
+	}
+	
+	public void set(LongWritable nodeId, LongWritable propId, LongWritable edgeId) {
+		this.nodeId = nodeId;
+		this.propId = propId;
+		this.edgeId = edgeId;
+	}
+	
+	public LongWritable getNodeId() {
+		return nodeId;
+	}
+
+	public LongWritable getPropId() {
+		return propId;
+	}
+	
+	public LongWritable getEdgeId() {
+		return edgeId;
+	}
+
+	@Override
+	public void write(DataOutput out) throws IOException {
+		nodeId.write(out);
+		propId.write(out);
+		edgeId.write(out);
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		nodeId.readFields(in);
+		propId.readFields(in);
+		edgeId.readFields(in);		
+	}
+
+	@Override
+	public int compareTo(Object obj) {
+		NodeEdgeIdWritable other = (NodeEdgeIdWritable) obj;
+		int nodeDiff = nodeId.compareTo(other.nodeId);
+		return (nodeDiff == 0) ? edgeId.compareTo(other.edgeId) : nodeDiff;
+	}
+
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((edgeId == null) ? 0 : edgeId.hashCode());
+		result = prime * result + ((nodeId == null) ? 0 : nodeId.hashCode());
+		result = prime * result + ((propId == null) ? 0 : propId.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		NodeEdgeIdWritable other = (NodeEdgeIdWritable) obj;
+		if (edgeId == null) {
+			if (other.edgeId != null)
+				return false;
+		} else if (!edgeId.equals(other.edgeId))
+			return false;
+		if (nodeId == null) {
+			if (other.nodeId != null)
+				return false;
+		} else if (!nodeId.equals(other.nodeId))
+			return false;
+		if (propId == null) {
+			if (other.propId != null)
+				return false;
+		} else if (!propId.equals(other.propId))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "NodeEdgeIdWritable [nodeId=" + nodeId + ", propId=" + propId + ", edgeId=" + edgeId + "]";
+	}
+
+}
+
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodeEdgeWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodeEdgeWritable.java
new file mode 100644
index 0000000..1e7e540
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodeEdgeWritable.java
@@ -0,0 +1,92 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class NodeEdgeWritable  implements WritableComparable {
+
+	private NodeWritable node = new NodeWritable();
+	private EdgeWritable edge = new EdgeWritable();
+
+	public NodeEdgeWritable() {
+
+	}
+	
+	public NodeEdgeWritable(long nodeId, long nodePropId, long edgeId, long from, long to, long edgePropId) {
+		this.set(nodeId, nodePropId, edgeId, from, to, edgePropId);
+	}
+
+	public NodeWritable getNode() {
+		return node;
+	}
+
+	public EdgeWritable getEdge() {
+		return edge;
+	}
+	
+	public void set(long nodeId, long nodePropId, long edgeId, long from, long to, long edgePropId) {
+		this.node = new NodeWritable(nodeId, nodePropId);
+		this.edge = new EdgeWritable(edgeId, from , to, edgePropId);
+	}
+	
+	@Override
+	public void write(DataOutput out) throws IOException {
+		node.write(out);
+		edge.write(out);
+	}
+	
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		node.readFields(in);		
+		edge.readFields(in);		
+	}
+	
+	@Override
+	public int compareTo(Object obj) {
+		NodeEdgeWritable other = (NodeEdgeWritable) obj;
+		int nodeDiff = node.compareTo(other.node);
+		int edgeDiff = edge.compareTo(other.edge);
+		return (nodeDiff == 0) ? edgeDiff : nodeDiff;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((edge == null) ? 0 : edge.hashCode());
+		result = prime * result + ((node == null) ? 0 : node.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		NodeEdgeWritable other = (NodeEdgeWritable) obj;
+		if (edge == null) {
+			if (other.edge != null)
+				return false;
+		} else if (!edge.equals(other.edge))
+			return false;
+		if (node == null) {
+			if (other.node != null)
+				return false;
+		} else if (!node.equals(other.node))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "NodeEdgeWritable [node=" + node + ", edge=" + edge + "]";
+	}
+
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodePropertyOutputCountersAndValueWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodePropertyOutputCountersAndValueWritable.java
new file mode 100644
index 0000000..5a95e70
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodePropertyOutputCountersAndValueWritable.java
@@ -0,0 +1,136 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Writable;
+
+public class NodePropertyOutputCountersAndValueWritable  implements Writable {
+	private LongWritable id;
+	private FullNodePropertiesWritable value;
+	private long countBlockOffset;
+	private long countIdOffset;
+	private int partition;
+	
+	public static final FullNodePropertiesWritable EMPTY_VAL = new FullNodePropertiesWritable(-1, null, -1, -1, -1, -1, -1, "");
+	public static final LongWritable EMPTY_ID = new LongWritable(Long.MIN_VALUE);
+	
+	public void setValues(LongWritable id, FullNodePropertiesWritable value) {
+		this.id = id;
+		this.value = value;
+		this.countBlockOffset = -1L;
+		this.countIdOffset = -1L;
+		this.partition = -1;
+	}
+	
+	public void setCounter(int partition, long blockCount, long idOffsetCount) {
+		this.id = EMPTY_ID;
+		this.value = EMPTY_VAL;
+		this.partition = partition;
+		this.countBlockOffset = blockCount;
+		this.countIdOffset = idOffsetCount;
+	}
+	
+	public long getBlockOffset() {
+		return countBlockOffset;
+	}
+
+	public long getIdOffset() {
+		return countIdOffset;
+	}
+	
+	public int getPartition() {
+		return partition;
+	}
+	
+	public FullNodePropertiesWritable getValue() {
+		return value;
+	}
+	
+	public LongWritable getId() {
+		return id;
+	}
+	
+	@Override
+	public void write(DataOutput out) throws IOException {
+		id.write(out);
+		value.write(out);
+		if (id.equals(EMPTY_ID)) {
+			out.writeInt(partition);
+			out.writeLong(countBlockOffset);
+			out.writeLong(countIdOffset);
+		}
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		if (id == null) {
+			id = new LongWritable();
+		}
+		id.readFields(in);
+		if (value == null) {
+			value = new FullNodePropertiesWritable();
+		}
+		value.readFields(in);
+		
+		if (id.equals(EMPTY_ID)) {
+			partition = in.readInt();
+			countBlockOffset = in.readLong();
+			countIdOffset = in.readLong();
+		} else {
+			partition = -1;
+			countBlockOffset = -1L;
+			countIdOffset = -1L;
+		}
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + (int) (countBlockOffset ^ (countBlockOffset >>> 32));
+		result = prime * result + (int) (countIdOffset ^ (countIdOffset >>> 32));
+		result = prime * result + ((id == null) ? 0 : id.hashCode());
+		result = prime * result + partition;
+		result = prime * result + ((value == null) ? 0 : value.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		NodePropertyOutputCountersAndValueWritable other = (NodePropertyOutputCountersAndValueWritable) obj;
+		if (countBlockOffset != other.countBlockOffset)
+			return false;
+		if (countIdOffset != other.countIdOffset)
+			return false;
+		if (id == null) {
+			if (other.id != null)
+				return false;
+		} else if (!id.equals(other.id))
+			return false;
+		if (partition != other.partition)
+			return false;
+		if (value == null) {
+			if (other.value != null)
+				return false;
+		} else if (!value.equals(other.value))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "NodePropertyOutputCountersAndValueWritable [id=" + id + ", value=" + value + ", countBlockOffset=" + countBlockOffset + ", countIdOffset="
+				+ countIdOffset + ", partition=" + partition + "]";
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodeWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodeWritable.java
new file mode 100644
index 0000000..b0d2223
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/NodeWritable.java
@@ -0,0 +1,98 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class NodeWritable implements WritableComparable {
+
+	private LongWritable nodeId = new LongWritable();
+	private LongWritable propId = new LongWritable();
+	
+	public NodeWritable() {
+		
+	}
+	
+	public NodeWritable(long nodeId, long propId) {
+		this.set(nodeId, propId);
+	}
+	
+	public void set(long nodeId, long propId) {
+		this.nodeId = new LongWritable(nodeId);
+		this.propId = new LongWritable(propId);
+	}
+	
+	public void set(LongWritable nodeId, LongWritable propId) {
+		this.nodeId = nodeId;
+		this.propId = propId;
+	}
+	
+	public LongWritable getNodeId() {
+		return nodeId;
+	}
+
+	public LongWritable getPropId() {
+		return propId;
+	}
+
+	@Override
+	public void write(DataOutput out) throws IOException {
+		nodeId.write(out);
+		propId.write(out);
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		nodeId.readFields(in);
+		propId.readFields(in);		
+	}
+
+	@Override
+	public int compareTo(Object obj) {
+		NodeWritable other = (NodeWritable) obj;
+		int nodeDiff = nodeId.compareTo(other.nodeId);
+		return (nodeDiff == 0) ? propId.compareTo(other.propId) : nodeDiff;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((propId == null) ? 0 : propId.hashCode());
+		result = prime * result + ((nodeId == null) ? 0 : nodeId.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		NodeWritable other = (NodeWritable) obj;
+		if (propId == null) {
+			if (other.propId != null)
+				return false;
+		} else if (!propId.equals(other.propId))
+			return false;
+		if (nodeId == null) {
+			if (other.nodeId != null)
+				return false;
+		} else if (!nodeId.equals(other.nodeId))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "NodeIdPropIdWritable [nodeId=" + nodeId + ", propId=" + propId + "]";
+	}
+
+}
+
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/PropertyListWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/PropertyListWritable.java
new file mode 100644
index 0000000..39e5a1d
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/PropertyListWritable.java
@@ -0,0 +1,193 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class PropertyListWritable implements WritableComparable {
+
+	private ArrayList<IntWritable> propertyIndexKeys = new ArrayList<IntWritable>();
+	private ArrayList<Text> properties = new ArrayList<Text>();
+
+	public PropertyListWritable() {
+
+	}
+
+	public PropertyListWritable(PropertyListWritable other) {
+		for (Text text : other.getProperties()) {
+			properties.add(new Text(text.toString()));
+		}
+		for (IntWritable key : other.getPropertyIndexKeys()) {
+			propertyIndexKeys.add(new IntWritable(key.get()));
+		}
+	}
+
+	public void setValues(String... vals) {
+		for (String string : vals) {
+			Text val = new Text();
+			val.set(string);
+			this.properties.add(val);
+		}
+	}
+
+	public void setKeys(int... vals) {
+		for (int key : vals) {
+			IntWritable val = new IntWritable();
+			val.set(key);
+			this.propertyIndexKeys.add(val);
+		}
+	}
+
+	public ArrayList<Text> getProperties() {
+		return this.properties;
+	}
+
+	public ArrayList<IntWritable> getPropertyIndexKeys() {
+		return this.propertyIndexKeys;
+	}
+
+	public String[] valuesToArray() {
+		String[] result = new String[this.properties.size()];
+		for (int i = 0; i < properties.size(); i++) {
+			result[i] = properties.get(i).toString();
+		}
+		return result;
+	}
+
+	public int[] keysToArray() {
+		int[] result = new int[this.propertyIndexKeys.size()];
+		for (int i = 0; i < propertyIndexKeys.size(); i++) {
+			result[i] = propertyIndexKeys.get(i).get();
+		}
+		return result;
+	}
+
+	@Override
+	public void write(DataOutput out) throws IOException {
+		out.writeInt(properties.size());
+		for (IntWritable value : propertyIndexKeys) {
+			value.write(out);
+		}
+		for (Text value : properties) {
+			value.write(out);
+		}
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		int size = in.readInt();
+		propertyIndexKeys = new ArrayList<IntWritable>(size);
+		for (int i = 0; i < size; i++) {
+			IntWritable value = new IntWritable();
+			value.readFields(in);
+			propertyIndexKeys.add(value);
+		}
+		properties = new ArrayList<Text>(size);
+		for (int i = 0; i < size; i++) {
+			Text value = new Text();
+			value.readFields(in);
+			properties.add(value);
+		}
+
+	}
+
+	@Override
+	public int compareTo(Object o) {
+		PropertyListWritable obj = (PropertyListWritable) o;
+		if (this.properties.equals(obj.properties) && this.propertyIndexKeys.equals(obj.propertyIndexKeys)) {
+			return 0;
+		} else {
+			int propDiff = comparePropertiesTo(obj.properties);
+			if (propDiff == 0) {
+				return comparePropertyIndexesTo(obj.propertyIndexKeys);
+			} else {
+				return propDiff;
+			}
+		}
+	}
+
+	private int comparePropertiesTo(ArrayList<Text> other) {
+		int result = 0;
+		int sizeDiff = this.properties.size() - other.size();
+		if (sizeDiff == 0) {
+			for (int i = 0; i < this.properties.size(); i++) {
+				result = this.properties.get(i).compareTo(other.get(i));
+				if (result != 0)
+					break;
+			}
+		} else {
+			result = sizeDiff;
+		}
+		return result;
+	}
+
+	private int comparePropertyIndexesTo(ArrayList<IntWritable> other) {
+		int result = 0;
+		int sizeDiff = this.propertyIndexKeys.size() - other.size();
+		if (sizeDiff == 0) {
+			for (int i = 0; i < this.propertyIndexKeys.size(); i++) {
+				result = this.propertyIndexKeys.get(i).compareTo(other.get(i));
+				if (result != 0)
+					break;
+			}
+		} else {
+			result = sizeDiff;
+		}
+		return result;
+	}
+
+	public void add(int index, String prop) {
+		Text val = new Text();
+		val.set(prop);
+		this.properties.add(val);
+		IntWritable key = new IntWritable(index);
+		this.propertyIndexKeys.add(key);
+	}
+
+	public int getLength() {
+		return this.properties.size();
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((properties == null) ? 0 : properties.hashCode());
+		result = prime * result + ((propertyIndexKeys == null) ? 0 : propertyIndexKeys.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		PropertyListWritable other = (PropertyListWritable) obj;
+		if (properties == null) {
+			if (other.properties != null)
+				return false;
+		} else if (!properties.equals(other.properties))
+			return false;
+		if (propertyIndexKeys == null) {
+			if (other.propertyIndexKeys != null)
+				return false;
+		} else if (!propertyIndexKeys.equals(other.propertyIndexKeys))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "PropertyListWritable [propertyIndexKeys=" + propertyIndexKeys + ", properties=" + properties + "]";
+	}
+
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/SurroundingEdgeWritable.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/SurroundingEdgeWritable.java
new file mode 100644
index 0000000..3eb3a51
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/input/writables/SurroundingEdgeWritable.java
@@ -0,0 +1,186 @@
+package nl.waredingen.graphs.neo.mapreduce.input.writables;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.WritableComparable;
+
+@SuppressWarnings("rawtypes")
+public class SurroundingEdgeWritable implements WritableComparable {
+
+	private LongWritable nodeId = new LongWritable();
+	private LongWritable edgeId = new LongWritable();
+	private LongWritable fromNodeId = new LongWritable();
+	private LongWritable toNodeId = new LongWritable();
+	private LongWritable edgePropId = new LongWritable();
+	private LongWritable edgePrev = new LongWritable();
+	private LongWritable edgeNext = new LongWritable();
+
+	public SurroundingEdgeWritable() {
+
+	}
+
+	public SurroundingEdgeWritable(long nodeId, long edgeId, long fromNode, long toNode, long edgeProp, long prev, long next) {
+		this.set(nodeId, edgeId, fromNode, toNode, edgeProp, prev, next);
+	}
+
+	public SurroundingEdgeWritable(SurroundingEdgeWritable other) {
+		this.set(other.getNodeId().get(), other.getEdgeId().get(), other.getFromNodeId().get(), other.getToNodeId().get(), other.getEdgePropId().get(), other
+				.getEdgePrev().get(), other.getEdgeNext().get());
+	}
+
+	public LongWritable getNodeId() {
+		return nodeId;
+	}
+
+	public LongWritable getEdgeId() {
+		return edgeId;
+	}
+
+	public LongWritable getFromNodeId() {
+		return fromNodeId;
+	}
+
+	public LongWritable getToNodeId() {
+		return toNodeId;
+	}
+
+	public LongWritable getEdgePropId() {
+		return edgePropId;
+	}
+	
+	public LongWritable getEdgePrev() {
+		return edgePrev;
+	}
+
+	public LongWritable getEdgeNext() {
+		return edgeNext;
+	}
+
+	public void set(long nodeId, long edgeId, long fromNode, long toNode, long edgeProp, long prev, long next) {
+		this.nodeId = new LongWritable(nodeId);
+		this.edgeId = new LongWritable(edgeId);
+		this.fromNodeId = new LongWritable(fromNode);
+		this.toNodeId = new LongWritable(toNode);
+		this.edgePropId = new LongWritable(edgeProp);
+		this.edgePrev = new LongWritable(prev);
+		this.edgeNext = new LongWritable(next);
+	}
+
+	public void set(LongWritable nodeId, LongWritable edgeId, LongWritable fromNodeId, LongWritable toNodeId, LongWritable edgeProp, LongWritable edgePrev,
+			LongWritable edgeNext) {
+		this.nodeId = nodeId;
+		this.edgeId = edgeId;
+		this.fromNodeId = fromNodeId;
+		this.toNodeId = toNodeId;
+		this.edgePropId = edgeProp;
+		this.edgePrev = edgePrev;
+		this.edgeNext = edgeNext;
+	}
+
+	@Override
+	public void write(DataOutput out) throws IOException {
+		nodeId.write(out);
+		edgeId.write(out);
+		fromNodeId.write(out);
+		toNodeId.write(out);
+		edgePropId.write(out);
+		edgePrev.write(out);
+		edgeNext.write(out);
+	}
+
+	@Override
+	public void readFields(DataInput in) throws IOException {
+		nodeId.readFields(in);
+		edgeId.readFields(in);
+		fromNodeId.readFields(in);
+		toNodeId.readFields(in);
+		edgePropId.readFields(in);
+		edgePrev.readFields(in);
+		edgeNext.readFields(in);
+	}
+
+	@Override
+	public int compareTo(Object obj) {
+		SurroundingEdgeWritable other = (SurroundingEdgeWritable) obj;
+		int nodeDiff = nodeId.compareTo(other.nodeId);
+		int edgeDiff = edgeId.compareTo(other.edgeId);
+		int fromDiff = fromNodeId.compareTo(other.fromNodeId);
+		int toDiff = toNodeId.compareTo(other.toNodeId);
+		int propDiff = edgePropId.compareTo(other.edgePropId);
+		int prevDiff = edgePrev.compareTo(other.edgePrev);
+		int nextDiff = edgeNext.compareTo(other.edgeNext);
+		return (nodeDiff == 0) ? (edgeDiff == 0) ? (fromDiff == 0) ? (toDiff == 0) ? (propDiff == 0) ? (prevDiff == 0) ? nextDiff : prevDiff : propDiff
+				: toDiff : fromDiff : edgeDiff : nodeDiff;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((edgeId == null) ? 0 : edgeId.hashCode());
+		result = prime * result + ((edgeNext == null) ? 0 : edgeNext.hashCode());
+		result = prime * result + ((edgePrev == null) ? 0 : edgePrev.hashCode());
+		result = prime * result + ((edgePropId == null) ? 0 : edgePropId.hashCode());
+		result = prime * result + ((fromNodeId == null) ? 0 : fromNodeId.hashCode());
+		result = prime * result + ((nodeId == null) ? 0 : nodeId.hashCode());
+		result = prime * result + ((toNodeId == null) ? 0 : toNodeId.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		SurroundingEdgeWritable other = (SurroundingEdgeWritable) obj;
+		if (edgeId == null) {
+			if (other.edgeId != null)
+				return false;
+		} else if (!edgeId.equals(other.edgeId))
+			return false;
+		if (edgeNext == null) {
+			if (other.edgeNext != null)
+				return false;
+		} else if (!edgeNext.equals(other.edgeNext))
+			return false;
+		if (edgePrev == null) {
+			if (other.edgePrev != null)
+				return false;
+		} else if (!edgePrev.equals(other.edgePrev))
+			return false;
+		if (edgePropId == null) {
+			if (other.edgePropId != null)
+				return false;
+		} else if (!edgePropId.equals(other.edgePropId))
+			return false;
+		if (fromNodeId == null) {
+			if (other.fromNodeId != null)
+				return false;
+		} else if (!fromNodeId.equals(other.fromNodeId))
+			return false;
+		if (nodeId == null) {
+			if (other.nodeId != null)
+				return false;
+		} else if (!nodeId.equals(other.nodeId))
+			return false;
+		if (toNodeId == null) {
+			if (other.toNodeId != null)
+				return false;
+		} else if (!toNodeId.equals(other.toNodeId))
+			return false;
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "SurroundingEdgeWritable [nodeId=" + nodeId + ", edgeId=" + edgeId + ", fromNodeId=" + fromNodeId + ", toNodeId=" + toNodeId + ", edgePropId="
+				+ edgePropId + ", edgePrev=" + edgePrev + ", edgeNext=" + edgeNext + "]";
+	}
+
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinFromEdgesMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinFromEdgesMapper.java
new file mode 100644
index 0000000..f168bc9
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinFromEdgesMapper.java
@@ -0,0 +1,26 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import java.io.IOException;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class JoinFromEdgesMapper extends Mapper<NullWritable, BytesWritable, Text, Text> {
+
+	private Text outputKey = new Text();
+	private Text outputValue = new Text();
+	private Text valAsText = new Text();
+
+	@Override
+	protected void map(NullWritable key, BytesWritable value, Context context) throws IOException ,InterruptedException {
+		valAsText.set(value.getBytes(), 0, value.getLength());
+		String[] values = valAsText.toString().split("\t", 4);
+
+		outputKey.set("E"+values[1]);
+		outputValue.set(StringUtils.join(values, "\t", 0, 4));
+		context.write(outputKey, outputValue);
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesAndEdgesReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesAndEdgesReducer.java
new file mode 100644
index 0000000..a3178c6
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesAndEdgesReducer.java
@@ -0,0 +1,32 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Reducer;
+
+public class JoinNodesAndEdgesReducer extends Reducer<Text, Text, NullWritable, Text> {
+
+	private Text outputValue = new Text();
+	
+	@Override
+	protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
+		Iterator<Text> iter = values.iterator();
+		if (!iter.hasNext()) {
+			return;
+		}
+		
+		String node = iter.next().toString();
+
+		while (iter.hasNext()) {
+			Text value = iter.next();
+			outputValue.set(value.toString() + "\t" + node);
+			
+			context.write(NullWritable.get(), outputValue);
+		}
+
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesMapper.java
new file mode 100644
index 0000000..06283c8
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesMapper.java
@@ -0,0 +1,24 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import java.io.IOException;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class JoinNodesMapper extends Mapper<NullWritable, BytesWritable, Text, Text> {
+
+	private Text outputKey = new Text();
+	private Text outputValue = new Text();
+	private Text valAsText = new Text();
+
+	@Override
+	protected void map(NullWritable key, BytesWritable value, Context context) throws IOException, InterruptedException {
+		valAsText.set(value.getBytes(), 0, value.getLength());
+		String[] values = valAsText.toString().split("\t", 3);
+		outputKey.set("N" + values[1]);
+		outputValue.set(values[0] + "\t" + values[2]);
+		context.write(outputKey, outputValue);
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinToEdgesMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinToEdgesMapper.java
new file mode 100644
index 0000000..ca6dc39
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/JoinToEdgesMapper.java
@@ -0,0 +1,19 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import java.io.IOException;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class JoinToEdgesMapper extends Mapper<NullWritable, Text, Text, Text> {
+
+	private Text outputKey = new Text();
+	
+	@Override
+	protected void map(NullWritable key, Text value, Context context) throws IOException ,InterruptedException {
+		String[] values = value.toString().split("\t", 6);
+		outputKey.set("E"+values[2]);
+		context.write(outputKey, value);
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyComparator.java
new file mode 100644
index 0000000..db29017
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyComparator.java
@@ -0,0 +1,28 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class NodeAndEdgeKeyComparator extends WritableComparator {
+	protected NodeAndEdgeKeyComparator() {
+		super(Text.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable w1, WritableComparable w2) {
+		Text k1 = (Text) w1;
+		Text k2 = (Text) w2;
+
+		String identifier1 = k1.toString().substring(0,1);
+		String identifier2 = k2.toString().substring(0,1);
+		
+		int result = k1.toString().substring(1).compareTo(k2.toString().substring(1));
+		if (0 == result) {
+			result = -1 * identifier1.compareTo(identifier2);
+		}
+		return result;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyPartitioner.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyPartitioner.java
new file mode 100644
index 0000000..aa1c51a
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyPartitioner.java
@@ -0,0 +1,14 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Partitioner;
+
+public class NodeAndEdgeKeyPartitioner extends Partitioner<Text, Text> {
+
+	@Override
+	public int getPartition(Text key, Text val, int numPartitions) {
+		int hash = key.toString().substring(1).hashCode();
+		return (hash & Integer.MAX_VALUE) % numPartitions;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/NodeKeyGroupingComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/NodeKeyGroupingComparator.java
new file mode 100644
index 0000000..a3da8f1
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/join/NodeKeyGroupingComparator.java
@@ -0,0 +1,21 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class NodeKeyGroupingComparator extends WritableComparator {
+	protected NodeKeyGroupingComparator() {
+		super(Text.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable w1, WritableComparable w2) {
+		Text k1 = (Text) w1;
+		Text k2 = (Text) w2;
+
+		return k1.toString().substring(1).compareTo(k2.toString().substring(1));
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputAsTextReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputAsTextReducer.java
new file mode 100644
index 0000000..529068e
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputAsTextReducer.java
@@ -0,0 +1,51 @@
+package nl.waredingen.graphs.neo.mapreduce.nodes;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Reducer;
+import org.neo4j.kernel.impl.nioneo.store.Record;
+
+public class NodeOutputAsTextReducer extends Reducer<LongWritable, Text, NullWritable, Text> {
+	private Text outputValue = new Text();
+
+	protected void reduce(LongWritable key, Iterable<Text> values, Context context) throws IOException,
+			InterruptedException {
+		Iterator<Text> itr = values.iterator();
+		if (!itr.hasNext()) {
+			return;
+		}
+
+		long id = key.get();
+
+		// walk through values and pick the smallest relnum and propid
+		long relnum = Long.MAX_VALUE;
+		long propnum = Long.MAX_VALUE;
+		while (itr.hasNext()) {
+			Text value = itr.next();
+			String[] vals = value.toString().split("\t",2);
+			relnum = Math.min(relnum, Long.parseLong(vals[0]));
+			propnum = Math.min(propnum, Long.parseLong(vals[1]));
+		}
+
+		if (relnum == Long.MAX_VALUE) relnum = -1L;
+		if (propnum == Long.MAX_VALUE) propnum = -1L;
+		
+		if (id == 0L) {
+			// write a rootnode once
+			writeNode(id, Record.NO_NEXT_RELATIONSHIP.intValue(), Record.NO_NEXT_PROPERTY.intValue(), context);
+		}
+
+		writeNode(id + 1L, relnum, propnum, context);
+	}
+
+	private void writeNode(long id, long relnum, long prop, Context context) throws IOException, InterruptedException {
+		//byte[] ba = Neo4JUtils.getNodeAsByteArray(id, relnum, prop);
+		outputValue.set(id +"\t"+relnum+"\t"+prop);
+		context.write(NullWritable.get(), outputValue);
+	}
+
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputMapper.java
new file mode 100644
index 0000000..717c1ea
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputMapper.java
@@ -0,0 +1,24 @@
+package nl.waredingen.graphs.neo.mapreduce.nodes;
+
+import java.io.IOException;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class NodeOutputMapper extends Mapper<NullWritable, NodeEdgeWritable, LongWritable, EdgeIdPropIdWritable> {
+
+	private LongWritable outputKey = new LongWritable();
+	private EdgeIdPropIdWritable outputValue = new EdgeIdPropIdWritable();
+
+	@Override
+	protected void map(NullWritable key, NodeEdgeWritable value, Context context) throws IOException, InterruptedException {
+		outputKey.set(value.getNode().getNodeId().get());
+
+		outputValue.set(value.getEdge().getEdgeId(), value.getNode().getPropId());
+		context.write(outputKey, outputValue);
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputReducer.java
new file mode 100644
index 0000000..4f2d15a
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputReducer.java
@@ -0,0 +1,54 @@
+package nl.waredingen.graphs.neo.mapreduce.nodes;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeIdPropIdWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mapreduce.Reducer;
+import org.neo4j.kernel.impl.nioneo.store.Record;
+
+public class NodeOutputReducer extends Reducer<LongWritable, EdgeIdPropIdWritable, NullWritable, BytesWritable> {
+	private BytesWritable outputValue = new BytesWritable();
+
+	@Override
+	protected void reduce(LongWritable key, Iterable<EdgeIdPropIdWritable> values, Context context) throws IOException,
+			InterruptedException {
+		Iterator<EdgeIdPropIdWritable> itr = values.iterator();
+		if (!itr.hasNext()) {
+			return;
+		}
+
+		long id = key.get();
+
+		// walk through values and pick the smallest relnum and propid
+		long relnum = Long.MAX_VALUE;
+		long propnum = Long.MAX_VALUE;
+		while (itr.hasNext()) {
+			EdgeIdPropIdWritable value = itr.next();
+			relnum = Math.min(relnum, value.getEdgeId().get());
+			propnum = Math.min(propnum, value.getPropId().get());
+		}
+
+		if (relnum == Long.MAX_VALUE) relnum = -1L;
+		if (propnum == Long.MAX_VALUE) propnum = -1L;
+
+		if (id == 0L) {
+			// write a rootnode once
+			writeNode(id, Record.NO_NEXT_RELATIONSHIP.intValue(), Record.NO_NEXT_PROPERTY.intValue(), context);
+		}
+
+		writeNode(id + 1L, relnum, propnum, context);
+	}
+
+	private void writeNode(long id, long relnum, long prop, Context context) throws IOException, InterruptedException {
+		byte[] ba = Neo4JUtils.getNodeAsByteArray(id, relnum, prop);
+		outputValue.set(ba, 0, ba.length);
+		context.write(NullWritable.get(), outputValue);
+	}
+
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputRownumPartitioner.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputRownumPartitioner.java
new file mode 100644
index 0000000..4c2b3ae
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputRownumPartitioner.java
@@ -0,0 +1,13 @@
+package nl.waredingen.graphs.neo.mapreduce.nodes;
+
+import nl.waredingen.graphs.neo.mapreduce.AbstractRownumPartitioner;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+public class NodeOutputRownumPartitioner<K, V> extends AbstractRownumPartitioner<K, V> {
+
+	@Override
+	public long getMaxCounter() {
+		return Neo4JUtils.getMetaData(conf).getNumberOfNodes();
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/ByteMarkerAndIdComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/ByteMarkerAndIdComparator.java
new file mode 100644
index 0000000..6aa02d3
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/ByteMarkerAndIdComparator.java
@@ -0,0 +1,29 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+
+import org.apache.hadoop.io.WritableComparable;
+import org.apache.hadoop.io.WritableComparator;
+
+public class ByteMarkerAndIdComparator extends WritableComparator {
+	protected ByteMarkerAndIdComparator() {
+		super(ByteMarkerIdPropIdWritable.class, true);
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public int compare(WritableComparable w1, WritableComparable w2) {
+		ByteMarkerIdPropIdWritable k1 = (ByteMarkerIdPropIdWritable) w1;
+		ByteMarkerIdPropIdWritable k2 = (ByteMarkerIdPropIdWritable) w2;
+
+		int result = k1.getMarker().compareTo(k2.getMarker());
+		if (0 == result) {
+			result = k1.getId().compareTo(k2.getId());
+			if (0 == result) {
+				result = k1.getPropId().compareTo(k2.getPropId());
+			}
+		}
+		return result;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesMapper.java
new file mode 100644
index 0000000..0834ce3
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesMapper.java
@@ -0,0 +1,103 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgePropertiesWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Mapper;
+import org.neo4j.kernel.impl.nioneo.store.PropertyBlock;
+import org.neo4j.kernel.impl.nioneo.store.PropertyRecord;
+import org.neo4j.kernel.impl.nioneo.store.PropertyType;
+
+public class EdgePreparePropertiesMapper extends Mapper<Text, Text, AscLongDescLongWritable, FullEdgePropertiesWritable> {
+	private AscLongDescLongWritable outputKey = new AscLongDescLongWritable();
+	private FullEdgePropertiesWritable outputValue = new FullEdgePropertiesWritable();
+	private MetaData metaData;
+	
+	@Override
+	protected void setup(Context context) throws IOException ,InterruptedException {
+		metaData = Neo4JUtils.getMetaData(context.getConfiguration());
+	}
+
+	@Override
+	protected void map(Text key, Text value, Context context) throws IOException, InterruptedException {
+		String[] values = value.toString().split("\t", metaData.getEdgePropertySize());
+		long edgeId = Long.parseLong(key.toString());
+		int propId = 0;
+		List<PropertyRecord> propRecords = new ArrayList<PropertyRecord>();
+		Map<Integer,String> props = new HashMap<Integer, String>();
+		PropertyRecord record = new PropertyRecord(propId);
+		record.setInUse(true);
+		record.setCreated();
+		propRecords.add(record);
+		for (int i = 0; i < values.length-2; i++) {
+			String property = values[i+2].trim();
+			int propertyKey = i + metaData.getNodePropertySize();
+			props.put(propertyKey, property);
+			Object propertyObj = getValueAsPropertyTypedClass(propertyKey, property);
+			PropertyBlock propertyBlock = getPropertyBlock(propertyKey, propertyObj);
+			if (record.size() + propertyBlock.getSize() > PropertyType.getPayloadSize()) {
+				PropertyRecord prevRecord = record;
+				record = new PropertyRecord(++propId);
+				record.setInUse(true);
+				record.setCreated();
+				prevRecord.setNextProp(propId);
+				record.setPrevProp(prevRecord.getId());
+				propRecords.add(record);
+			}
+			record.addPropertyBlock(propertyBlock);
+		}
+
+		for (PropertyRecord rec : propRecords) {
+			outputKey.setLeft(new LongWritable(edgeId));
+			outputKey.setRight(new LongWritable(rec.getId()));
+			boolean first = true;
+			for (PropertyBlock block : rec.getPropertyBlocks()) {
+				if (first) {
+					outputValue.set(edgeId, values[metaData.getEdgeFromNodeIdIndex()], values[metaData.getEdgeToNodeIdIndex()], (int) rec.getId(), getBlockCount(block), -1L, -1L, block.getKeyIndexId(),
+							props.get(block.getKeyIndexId()));
+					first = false;
+				} else {
+					outputValue.add(block.getKeyIndexId(), props.get(block.getKeyIndexId()), getBlockCount(block));
+				}
+			}
+			context.write(outputKey, outputValue);
+		}
+	}
+
+	private int getBlockCount(PropertyBlock block) {
+		return block.getValueRecords().size();
+	}
+
+	private PropertyBlock getPropertyBlock(int propertyKey, Object property) {
+		PropertyBlock block = new PropertyBlock();
+		Neo4JUtils.encodeValue(block, propertyKey, property, 0L);
+		return block;
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private Object getValueAsPropertyTypedClass(int propIndex, String property) {
+		Class type = null;
+		try {
+			if (propIndex - metaData.getNodePropertySize() + 2 < metaData.getEdgePropertySize()) {
+				type = metaData.getEdgeTypes()[propIndex - metaData.getNodePropertySize() + 2];
+			}
+			if (type != null) {
+				return type.getConstructor(String.class).newInstance(property);
+			} else {
+				return property;
+			}
+		} catch (Exception e) {
+			return property;
+		}
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesReducer.java
new file mode 100644
index 0000000..89a9cb3
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesReducer.java
@@ -0,0 +1,84 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgePropertiesWritable;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mapreduce.Reducer;
+
+public class EdgePreparePropertiesReducer extends Reducer<AscLongDescLongWritable, FullEdgePropertiesWritable, LongWritable, FullEdgePropertiesWritable> {
+
+	private LongWritable outputKey = new LongWritable();
+	private FullEdgePropertiesWritable outputValue = new FullEdgePropertiesWritable();
+
+	protected void reduce(AscLongDescLongWritable key, Iterable<FullEdgePropertiesWritable> values, Context context) throws IOException, InterruptedException {
+		Iterator<FullEdgePropertiesWritable> iter = values.iterator();
+
+		SurroundingPropertyContext ctx = new SurroundingPropertyContext();
+
+		while (iter.hasNext()) {
+			FullEdgePropertiesWritable value = iter.next();
+
+			long nodeId = key.getLeft().get();
+			if (ctx.nodeId == -1L) {
+				// first call, so set current fields
+				ctx.nodeId = nodeId;
+				ctx.index = value.getPropertyIndex().get();
+				ctx.nodeIdentifier = value.getFromNodeIdentifier().toString();
+				ctx.toNodeIdentifier = value.getToNodeIdentifier().toString();
+				ctx.propertyIndexes = value.getProperties().keysToArray();
+				ctx.properties = value.getProperties().valuesToArray();
+				ctx.count = value.getBlockCount().get();
+				ctx.prev = -1L; // don't know yet
+				ctx.next = -1L; // first call, relationships ordered descending,
+								// so last rel, so no next available
+
+			} else if (ctx.prev == -1L) {
+				// not the first so current relationship will become prev in
+				// context and context can be emitted and refilled with
+				// current
+				ctx.prev = value.getPropertyIndex().get();
+
+				outputKey.set(ctx.nodeId);
+				for (int i = 0; i < ctx.properties.length; i++) {
+					if (i == 0) {
+						outputValue.set(ctx.nodeId, ctx.nodeIdentifier, ctx.toNodeIdentifier, ctx.index, ctx.count, ctx.prev, ctx.next, ctx.propertyIndexes[i],
+								ctx.properties[i]);
+					} else {
+						outputValue.add(ctx.propertyIndexes[i], ctx.properties[i], 0);
+					}
+				}
+				context.write(outputKey, outputValue);
+
+				long next = ctx.index;
+				ctx.nodeId = nodeId;
+				ctx.index = value.getPropertyIndex().get();
+				ctx.nodeIdentifier = value.getFromNodeIdentifier().toString();
+				ctx.toNodeIdentifier = value.getToNodeIdentifier().toString();
+				ctx.propertyIndexes = value.getProperties().keysToArray();
+				ctx.properties = value.getProperties().valuesToArray();
+				ctx.count = value.getBlockCount().get();
+				ctx.prev = -1L; // don't know yet
+				ctx.next = next;
+
+			}
+
+		}
+
+		// write out last context
+		outputKey.set(ctx.nodeId);
+		for (int i = 0; i < ctx.properties.length; i++) {
+			if (i == 0) {
+				outputValue.set(ctx.nodeId, ctx.nodeIdentifier, ctx.toNodeIdentifier, ctx.index, ctx.count, ctx.prev, ctx.next, ctx.propertyIndexes[i],
+						ctx.properties[i]);
+			} else {
+				outputValue.add(ctx.propertyIndexes[i], ctx.properties[i], 0);
+			}
+		}
+		context.write(outputKey, outputValue);
+
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertyOutputMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertyOutputMapper.java
new file mode 100644
index 0000000..ac518c1
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertyOutputMapper.java
@@ -0,0 +1,59 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import java.io.IOException;
+
+import nl.waredingen.graphs.misc.RowNumberJob;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgePropertyOutputCountersAndValueWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgePropertiesWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.ByteWritable;
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class EdgePropertyOutputMapper extends
+		Mapper<LongWritable, FullEdgePropertiesWritable, ByteMarkerIdPropIdWritable, EdgePropertyOutputCountersAndValueWritable> {
+
+	private ByteMarkerIdPropIdWritable outputKey = new ByteMarkerIdPropIdWritable();
+	private EdgePropertyOutputCountersAndValueWritable outputValue = new EdgePropertyOutputCountersAndValueWritable();
+	private long[] blockCountCounters;
+	private long[] propertyIdCounters;
+	private int numReduceTasks;
+	private long maxIds;
+	private MetaData metaData;
+
+	@Override
+	protected void setup(Context context) throws IOException, InterruptedException {
+		metaData = Neo4JUtils.getMetaData(context.getConfiguration());
+		numReduceTasks = context.getNumReduceTasks();
+		maxIds = metaData.getNumberOfEdges();
+
+		blockCountCounters = new long[numReduceTasks];
+		propertyIdCounters = new long[numReduceTasks];
+		outputKey.setMarker(new ByteWritable(RowNumberJob.VALUE_MARKER));
+	}
+
+	@Override
+	protected void map(LongWritable key, FullEdgePropertiesWritable value, Context context) throws IOException, InterruptedException {
+		outputKey.setIds(value.getEdgeId(), value.getPropertyIndex());
+		outputValue.setValues(value.getEdgeId(), value);
+		blockCountCounters[EdgePropertyOutputPartitioner.partitionForValue(outputValue, numReduceTasks, maxIds)] += value.getBlockCount().get();
+		propertyIdCounters[EdgePropertyOutputPartitioner.partitionForValue(outputValue, numReduceTasks, maxIds)]++;
+		context.write(outputKey, outputValue);
+	}
+
+	@Override
+	protected void cleanup(Context context) throws IOException, InterruptedException {
+		outputKey.setMarker(new ByteWritable(RowNumberJob.COUNTER_MARKER));
+		outputKey.setIds(new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE));
+		for (int c = 0; c < blockCountCounters.length - 1; c++) {
+			outputValue.setCounter(c + 1, blockCountCounters[c], propertyIdCounters[c]);
+			context.write(outputKey, outputValue);
+			blockCountCounters[c + 1] += blockCountCounters[c];
+			propertyIdCounters[c + 1] += propertyIdCounters[c];
+		}
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertyOutputPartitioner.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertyOutputPartitioner.java
new file mode 100644
index 0000000..e0f3c63
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertyOutputPartitioner.java
@@ -0,0 +1,50 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import nl.waredingen.graphs.misc.RowNumberJob;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgePropertyOutputCountersAndValueWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.conf.Configurable;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.mapreduce.Partitioner;
+
+public class EdgePropertyOutputPartitioner extends Partitioner<ByteMarkerIdPropIdWritable, EdgePropertyOutputCountersAndValueWritable> implements Configurable {
+
+	private long max = 0L;
+	private Configuration conf;
+	
+	@Override
+	public int getPartition(ByteMarkerIdPropIdWritable key, EdgePropertyOutputCountersAndValueWritable value, int numPartitions) {
+
+		if (key.getMarker().get() == (byte) RowNumberJob.COUNTER_MARKER) {
+			return value.getPartition();
+		} else {
+			return EdgePropertyOutputPartitioner.partitionForValue(value, numPartitions, max);
+		}
+	}
+	
+	public static int partitionForValue(EdgePropertyOutputCountersAndValueWritable value, int numPartitions, long maximumIds) {
+		double divider = Math.max(1, (double) maximumIds / numPartitions);
+		return (int) (value.getId().get() / divider);
+	}
+
+	@Override
+	public void setConf(Configuration conf) {
+		this.conf = conf;
+		configure();
+		
+	}
+
+	private void configure() {
+		MetaData metaData = Neo4JUtils.getMetaData(conf);
+		this.max = metaData.getNumberOfEdges();
+	}
+
+	@Override
+	public Configuration getConf() {
+		return conf;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertyOutputReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertyOutputReducer.java
new file mode 100644
index 0000000..a60b3cc
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertyOutputReducer.java
@@ -0,0 +1,155 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgePropertyOutputCountersAndValueWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgePropertiesWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Reducer;
+import org.apache.hadoop.mapreduce.lib.output.MultipleOutputs;
+import org.neo4j.kernel.impl.nioneo.store.PropertyBlock;
+import org.neo4j.kernel.impl.nioneo.store.PropertyRecord;
+
+public class EdgePropertyOutputReducer extends Reducer<ByteMarkerIdPropIdWritable, EdgePropertyOutputCountersAndValueWritable, NullWritable, BytesWritable> {
+
+	private MultipleOutputs<NullWritable, BytesWritable> mos;
+	private BytesWritable outputValue = new BytesWritable();
+	private MetaData metaData;
+
+	protected void setup(Context context) throws IOException, InterruptedException {
+		mos = new MultipleOutputs<NullWritable, BytesWritable>(context);
+		metaData = Neo4JUtils.getMetaData(context.getConfiguration());
+	}
+
+	protected void reduce(ByteMarkerIdPropIdWritable key, Iterable<EdgePropertyOutputCountersAndValueWritable> values, Context context) throws IOException,
+			InterruptedException {
+		Iterator<EdgePropertyOutputCountersAndValueWritable> itr = values.iterator();
+		if (!itr.hasNext()) {
+			return;
+		}
+
+		long blockCountOffset = 1;
+		long propCountOffset = metaData.getNumberOfNodeProperties();
+		EdgePropertyOutputCountersAndValueWritable value = itr.next();
+		while (itr.hasNext() && value.getBlockOffset() != -1L && value.getIdOffset() != -1L) {
+			blockCountOffset += value.getBlockOffset();
+			propCountOffset += value.getIdOffset();
+			value = itr.next();
+		}
+
+		long blocksProcessed = 0L;
+		long edgeId = -1L;
+		if (!value.getValue().equals(EdgePropertyOutputCountersAndValueWritable.EMPTY_VAL)) {
+			if (edgeId != value.getValue().getEdgeId().get()) {
+				Text edgeText = new Text();
+				edgeText.set(value.getValue().getEdgeId().get() + "\t" + value.getValue().getFromNodeIdentifier().toString() + "\t" + value.getValue().getToNodeIdentifier().toString() + "\t" + propCountOffset);
+				byte[] ba = edgeText.getBytes();
+				outputValue.set(ba, 0, edgeText.getLength());
+				mos.write("edges", NullWritable.get(), outputValue);
+				edgeId = value.getValue().getEdgeId().get();
+			}
+			blocksProcessed = processValue(value, blockCountOffset, propCountOffset++);
+			blockCountOffset += blocksProcessed;
+			context.getCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "strings.blocks").increment(blocksProcessed);
+			context.getCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "edge.properties").increment(1);
+		}
+		while (itr.hasNext()) {
+			value = itr.next();
+			if (!value.getValue().equals(EdgePropertyOutputCountersAndValueWritable.EMPTY_VAL)) {
+				if (edgeId != value.getValue().getEdgeId().get()) {
+					Text edgeText = new Text();
+					edgeText.set(value.getValue().getEdgeId().get() + "\t" + value.getValue().getFromNodeIdentifier().toString() + "\t" + value.getValue().getToNodeIdentifier().toString() + "\t" + propCountOffset);
+					byte[] ba = edgeText.getBytes();
+					outputValue.set(ba, 0, edgeText.getLength());
+					mos.write("edges", NullWritable.get(), outputValue);
+					edgeId = value.getValue().getEdgeId().get();
+				}
+				blocksProcessed = processValue(value, blockCountOffset, propCountOffset++);
+				blockCountOffset += blocksProcessed;
+				context.getCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "strings.blocks").increment(blocksProcessed);
+				context.getCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "edge.properties").increment(1);
+			}
+		}
+	}
+
+	private long processValue(EdgePropertyOutputCountersAndValueWritable value, long blockCountOffset, long propOffset) throws IOException,
+			InterruptedException {
+
+		FullEdgePropertiesWritable propHolder = value.getValue();
+		int propIndex = propHolder.getPropertyIndex().get();
+
+		PropertyRecord record = new PropertyRecord(propOffset);
+		record.setInUse(true);
+		record.setCreated();
+		record.setInUse(true);
+		long prev = propHolder.getPrevProp().get();
+		long next = propHolder.getNextProp().get();
+		if (prev != -1L) {
+			prev = (prev - propIndex) + propOffset;
+		}
+		if (next != -1L) {
+			next = (next - propIndex) + propOffset;
+		}
+		record.setPrevProp(prev);
+		record.setNextProp(next);
+
+		String[] properties = propHolder.getProperties().valuesToArray();
+		int[] propertyKeyIndexes = propHolder.getProperties().keysToArray();
+
+		for (int i = 0; i < properties.length; i++) {
+			Object propertyObj = getValueAsPropertyTypedClass(propertyKeyIndexes[i], properties[i]);
+			PropertyBlock propertyBlock = getPropertyBlock(propertyKeyIndexes[i], propertyObj, blockCountOffset);
+			record.addPropertyBlock(propertyBlock);
+		}
+
+		byte[] ba = Neo4JUtils.getPropertyReferenceAsByteArray(record);
+		outputValue.set(ba, 0, ba.length);
+		mos.write("props", NullWritable.get(), outputValue);
+
+		for (PropertyBlock block : record.getPropertyBlocks()) {
+
+			if (block.getValueRecords().size() > 0) {
+				ba = Neo4JUtils.getDynamicRecordsAsByteArray(block.getValueRecords(), 128);
+				outputValue.set(ba, 0, ba.length);
+				mos.write("strings", NullWritable.get(), outputValue);
+			}
+		}
+
+		return propHolder.getBlockCount().get();
+
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private Object getValueAsPropertyTypedClass(int propIndex, String property) {
+		Class type = null;
+		try {
+			if (propIndex - metaData.getNodePropertySize() + 2 < metaData.getEdgePropertySize()) {
+				type = metaData.getEdgeTypes()[propIndex - metaData.getNodePropertySize() + 2];
+			}
+			if (type != null) {
+				return type.getConstructor(String.class).newInstance(property);
+			} else {
+				return property;
+			}
+		} catch (Exception e) {
+			return property;
+		}
+	}
+
+	private PropertyBlock getPropertyBlock(int propertyKey, Object property, long blockOffset) {
+		PropertyBlock block = new PropertyBlock();
+		Neo4JUtils.encodeValue(block, propertyKey, property, blockOffset);
+		return block;
+	}
+
+	protected void cleanup(Context context) throws IOException, InterruptedException {
+		mos.close();
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/IndifferentByteMarkerAndIdComparator.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/IndifferentByteMarkerAndIdComparator.java
new file mode 100644
index 0000000..46cf5a3
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/IndifferentByteMarkerAndIdComparator.java
@@ -0,0 +1,17 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+
+import org.apache.hadoop.io.RawComparator;
+
+public class IndifferentByteMarkerAndIdComparator implements RawComparator<ByteMarkerIdPropIdWritable> {
+	@Override
+	public int compare(ByteMarkerIdPropIdWritable left, ByteMarkerIdPropIdWritable right) {
+		return 0;
+	}
+
+	@Override
+	public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesMapper.java
new file mode 100644
index 0000000..8c72a70
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesMapper.java
@@ -0,0 +1,102 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullNodePropertiesWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Mapper;
+import org.neo4j.kernel.impl.nioneo.store.PropertyBlock;
+import org.neo4j.kernel.impl.nioneo.store.PropertyRecord;
+import org.neo4j.kernel.impl.nioneo.store.PropertyType;
+
+public class NodePreparePropertiesMapper extends Mapper<Text, Text, AscLongDescLongWritable, FullNodePropertiesWritable> {
+	private AscLongDescLongWritable outputKey = new AscLongDescLongWritable();
+	private FullNodePropertiesWritable outputValue = new FullNodePropertiesWritable();
+	private MetaData metaData;
+
+	@Override
+	protected void setup(Context context) throws IOException, InterruptedException {
+		metaData = Neo4JUtils.getMetaData(context.getConfiguration());
+	}
+
+	@Override
+	protected void map(Text key, Text value, Context context) throws IOException, InterruptedException {
+		String[] values = value.toString().split("\t", metaData.getNodePropertySize());
+		long nodeId = Long.parseLong(key.toString());
+		int propId = 0;
+		List<PropertyRecord> propRecords = new ArrayList<PropertyRecord>();
+		Map<Integer,String> props = new HashMap<Integer, String>();
+		PropertyRecord record = new PropertyRecord(propId);
+		record.setInUse(true);
+		record.setCreated();
+		propRecords.add(record);
+		for (int i = 0; i < values.length; i++) {
+			String property = values[i].trim();
+			int propertyKey = i;
+			props.put(propertyKey, property);
+			Object propertyObj = getValueAsPropertyTypedClass(propertyKey, property);
+			PropertyBlock propertyBlock = getPropertyBlock(propertyKey, propertyObj);
+			if (record.size() + propertyBlock.getSize() > PropertyType.getPayloadSize()) {
+				PropertyRecord prevRecord = record; 
+				record = new PropertyRecord(++propId);
+				record.setInUse(true);
+				record.setCreated();
+				prevRecord.setNextProp(propId);
+				record.setPrevProp(prevRecord.getId());
+				propRecords.add(record);
+			}
+			record.addPropertyBlock(propertyBlock);
+		}
+
+		for (PropertyRecord rec : propRecords) {
+			outputKey.setLeft(new LongWritable(nodeId));
+			outputKey.setRight(new LongWritable(rec.getId()));
+			boolean first = true;
+			for (PropertyBlock block : rec.getPropertyBlocks()) {
+				if (first) {
+					outputValue.set(nodeId, values[metaData.getNodeIdIndex()], (int)rec.getId(), getBlockCount(block), -1L, -1L, block.getKeyIndexId(), props.get(block.getKeyIndexId()));
+				first = false;
+				} else {
+					outputValue.add(block.getKeyIndexId(), props.get(block.getKeyIndexId()), getBlockCount(block));
+				}
+			}
+			context.write(outputKey, outputValue);
+		}
+	}
+
+	private int getBlockCount(PropertyBlock block) {
+		return block.getValueRecords().size();
+	}
+
+	private PropertyBlock getPropertyBlock(int propertyKey, Object property) {
+		PropertyBlock block = new PropertyBlock();
+		Neo4JUtils.encodeValue(block, propertyKey, property, 0L);
+		return block;
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private Object getValueAsPropertyTypedClass(int propIndex, String property) {
+		Class type = null;
+		try {
+			if (propIndex < metaData.getNodePropertySize()) {
+				type = metaData.getNodeTypes()[propIndex];
+			}
+			if (type != null) {
+				return type.getConstructor(String.class).newInstance(property);
+			} else {
+				return property;
+			}
+		} catch (Exception e) {
+			return property;
+		}
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesReducer.java
new file mode 100644
index 0000000..2c0ecd6
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesReducer.java
@@ -0,0 +1,81 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullNodePropertiesWritable;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mapreduce.Reducer;
+
+public class NodePreparePropertiesReducer extends Reducer<AscLongDescLongWritable, FullNodePropertiesWritable, LongWritable, FullNodePropertiesWritable> {
+
+	private LongWritable outputKey = new LongWritable();
+	private FullNodePropertiesWritable outputValue = new FullNodePropertiesWritable();
+
+	protected void reduce(AscLongDescLongWritable key, Iterable<FullNodePropertiesWritable> values, Context context) throws IOException ,InterruptedException {
+			Iterator<FullNodePropertiesWritable> iter = values.iterator();
+			
+			SurroundingPropertyContext ctx = new SurroundingPropertyContext();
+			
+			while (iter.hasNext()) {
+				FullNodePropertiesWritable value = iter.next();
+				
+				long nodeId = key.getLeft().get();
+				if (ctx.nodeId == -1L) {
+					// first call, so set current fields
+					ctx.nodeId = nodeId;
+					ctx.index = value.getPropertyIndex().get();
+					ctx.nodeIdentifier = value.getNodeIdentifier().toString();
+					ctx.propertyIndexes = value.getProperties().keysToArray();
+					ctx.properties = value.getProperties().valuesToArray();
+					ctx.count = value.getBlockCount().get();
+					ctx.prev = -1L; // don't know yet
+					ctx.next = -1L; // first call, relationships ordered descending, so last rel, so no next available
+
+				} else if (ctx.prev == -1L) {
+					// not the first so current relationship will become prev in
+					// context and context can be emitted and refilled with
+					// current
+					ctx.prev = value.getPropertyIndex().get();
+
+					outputKey.set(ctx.nodeId);
+					for (int i = 0; i < ctx.properties.length; i++) {
+						if (i == 0) {
+							outputValue.set(ctx.nodeId, ctx.nodeIdentifier, ctx.index, ctx.count, ctx.prev, ctx.next, ctx.propertyIndexes[i],
+									ctx.properties[i]);
+						} else {
+							outputValue.add(ctx.propertyIndexes[i], ctx.properties[i], 0);
+						}
+					}
+					context.write(outputKey, outputValue);
+
+					long next = ctx.index;
+					ctx.nodeId = nodeId;
+					ctx.index = value.getPropertyIndex().get();
+					ctx.nodeIdentifier = value.getNodeIdentifier().toString();
+					ctx.propertyIndexes = value.getProperties().keysToArray();
+					ctx.properties = value.getProperties().valuesToArray();
+					ctx.count = value.getBlockCount().get();
+					ctx.prev = -1L; // don't know yet
+					ctx.next = next;
+
+				}
+
+			}
+
+			// write out last context
+			outputKey.set(ctx.nodeId);
+			for (int i = 0; i < ctx.properties.length; i++) {
+				if (i == 0) {
+					outputValue.set(ctx.nodeId, ctx.nodeIdentifier, ctx.index, ctx.count, ctx.prev, ctx.next, ctx.propertyIndexes[i],
+							ctx.properties[i]);
+				} else {
+					outputValue.add(ctx.propertyIndexes[i], ctx.properties[i], 0);
+				}
+			}
+			context.write(outputKey, outputValue);
+
+		}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertyOutputMapper.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertyOutputMapper.java
new file mode 100644
index 0000000..4b58673
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertyOutputMapper.java
@@ -0,0 +1,59 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import java.io.IOException;
+
+import nl.waredingen.graphs.misc.RowNumberJob;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullNodePropertiesWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodePropertyOutputCountersAndValueWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.ByteWritable;
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mapreduce.Mapper;
+
+public class NodePropertyOutputMapper extends
+		Mapper<LongWritable, FullNodePropertiesWritable, ByteMarkerIdPropIdWritable, NodePropertyOutputCountersAndValueWritable> {
+
+	private ByteMarkerIdPropIdWritable outputKey = new ByteMarkerIdPropIdWritable();
+	private NodePropertyOutputCountersAndValueWritable outputValue = new NodePropertyOutputCountersAndValueWritable();
+	private long[] blockCountCounters;
+	private long[] propertyIdCounters;
+	private int numReduceTasks;
+	private long maxIds;
+	private MetaData metaData;
+
+	@Override
+	protected void setup(Context context) throws IOException, InterruptedException {
+		metaData = Neo4JUtils.getMetaData(context.getConfiguration());
+		numReduceTasks = context.getNumReduceTasks();
+		maxIds = metaData.getNumberOfNodes();
+
+		blockCountCounters = new long[numReduceTasks];
+		propertyIdCounters = new long[numReduceTasks];
+		outputKey.setMarker(new ByteWritable(RowNumberJob.VALUE_MARKER));
+	}
+
+	@Override
+	protected void map(LongWritable key, FullNodePropertiesWritable value, Context context) throws IOException, InterruptedException {
+		outputKey.setIds(value.getNodeId(), value.getPropertyIndex());
+		outputValue.setValues(value.getNodeId(), value);
+		blockCountCounters[NodePropertyOutputPartitioner.partitionForValue(outputValue, numReduceTasks, maxIds)] += value.getBlockCount().get();
+		propertyIdCounters[NodePropertyOutputPartitioner.partitionForValue(outputValue, numReduceTasks, maxIds)]++;
+		context.write(outputKey, outputValue);
+	}
+
+	@Override
+	protected void cleanup(Context context) throws IOException, InterruptedException {
+		outputKey.setMarker(new ByteWritable(RowNumberJob.COUNTER_MARKER));
+		outputKey.setIds(new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE));
+		for (int c = 0; c < blockCountCounters.length - 1; c++) {
+			outputValue.setCounter(c + 1, blockCountCounters[c], propertyIdCounters[c]);
+			context.write(outputKey, outputValue);
+			blockCountCounters[c + 1] += blockCountCounters[c];
+			propertyIdCounters[c + 1] += propertyIdCounters[c];
+		}
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertyOutputPartitioner.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertyOutputPartitioner.java
new file mode 100644
index 0000000..5c0a7bb
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertyOutputPartitioner.java
@@ -0,0 +1,50 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import nl.waredingen.graphs.misc.RowNumberJob;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodePropertyOutputCountersAndValueWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.conf.Configurable;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.mapreduce.Partitioner;
+
+public class NodePropertyOutputPartitioner extends Partitioner<ByteMarkerIdPropIdWritable, NodePropertyOutputCountersAndValueWritable> implements Configurable {
+
+	private long max = 0L;
+	private Configuration conf;
+	
+	@Override
+	public int getPartition(ByteMarkerIdPropIdWritable key, NodePropertyOutputCountersAndValueWritable value, int numPartitions) {
+
+		if (key.getMarker().get() == (byte) RowNumberJob.COUNTER_MARKER) {
+			return value.getPartition();
+		} else {
+			return NodePropertyOutputPartitioner.partitionForValue(value, numPartitions, max);
+		}
+	}
+	
+	public static int partitionForValue(NodePropertyOutputCountersAndValueWritable value, int numPartitions, long maximumIds) {
+		double divider = Math.max(1, (double) maximumIds / numPartitions);
+		return (int) (value.getId().get() / divider);
+	}
+
+	@Override
+	public void setConf(Configuration conf) {
+		this.conf = conf;
+		configure();
+		
+	}
+
+	private void configure() {
+		MetaData metaData = Neo4JUtils.getMetaData(conf);
+		this.max = metaData.getNumberOfNodes();
+	}
+
+	@Override
+	public Configuration getConf() {
+		return conf;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertyOutputReducer.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertyOutputReducer.java
new file mode 100644
index 0000000..ecabf3e
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertyOutputReducer.java
@@ -0,0 +1,155 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullNodePropertiesWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodePropertyOutputCountersAndValueWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Reducer;
+import org.apache.hadoop.mapreduce.lib.output.MultipleOutputs;
+import org.neo4j.kernel.impl.nioneo.store.PropertyBlock;
+import org.neo4j.kernel.impl.nioneo.store.PropertyRecord;
+
+public class NodePropertyOutputReducer extends Reducer<ByteMarkerIdPropIdWritable, NodePropertyOutputCountersAndValueWritable, NullWritable, BytesWritable> {
+
+	private MultipleOutputs<NullWritable, BytesWritable> mos;
+	private BytesWritable outputValue = new BytesWritable();
+	private MetaData metaData;
+
+	protected void setup(Context context) throws IOException, InterruptedException {
+		mos = new MultipleOutputs<NullWritable, BytesWritable>(context);
+		metaData = Neo4JUtils.getMetaData(context.getConfiguration());
+	}
+
+	protected void reduce(ByteMarkerIdPropIdWritable key, Iterable<NodePropertyOutputCountersAndValueWritable> values, Context context) throws IOException,
+			InterruptedException {
+		Iterator<NodePropertyOutputCountersAndValueWritable> itr = values.iterator();
+		if (!itr.hasNext()) {
+			return;
+		}
+
+		long blockCountOffset = 1;
+		long propCountOffset = 0;
+		NodePropertyOutputCountersAndValueWritable value = itr.next();
+		while (itr.hasNext() && value.getBlockOffset() != -1L && value.getIdOffset() != -1L) {
+			blockCountOffset += value.getBlockOffset();
+			propCountOffset += value.getIdOffset();
+			value = itr.next();
+		}
+
+		long blocksProcessed = 0L;
+		long nodeId = -1L;
+		if (!value.getValue().equals(NodePropertyOutputCountersAndValueWritable.EMPTY_VAL)) {
+			if (nodeId != value.getValue().getNodeId().get()) {
+				Text nodeText = new Text();
+				nodeText.set(value.getValue().getNodeId().get() + "\t" + value.getValue().getNodeIdentifier().toString() + "\t" + propCountOffset);
+				byte[] ba = nodeText.getBytes();
+				outputValue.set(ba, 0, nodeText.getLength());
+				mos.write("nodes", NullWritable.get(), outputValue);
+				nodeId = value.getValue().getNodeId().get();
+			}
+			blocksProcessed = processValue(value, blockCountOffset, propCountOffset++);
+			blockCountOffset += blocksProcessed;
+			context.getCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "strings.blocks").increment(blocksProcessed);
+			context.getCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "node.properties").increment(1);
+		}
+		while (itr.hasNext()) {
+			value = itr.next();
+			if (!value.getValue().equals(NodePropertyOutputCountersAndValueWritable.EMPTY_VAL)) {
+				if (nodeId != value.getValue().getNodeId().get()) {
+					Text nodeText = new Text();
+					nodeText.set(value.getValue().getNodeId().get() + "\t" + value.getValue().getNodeIdentifier().toString() + "\t" + propCountOffset);
+					byte[] ba = nodeText.getBytes();
+					outputValue.set(ba, 0, nodeText.getLength());
+					mos.write("nodes", NullWritable.get(), outputValue);
+					nodeId = value.getValue().getNodeId().get();
+				}
+				blocksProcessed = processValue(value, blockCountOffset, propCountOffset++);
+				blockCountOffset += blocksProcessed;
+				context.getCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "strings.blocks").increment(blocksProcessed);
+				context.getCounter("org.apache.hadoop.mapreduce.lib.output.MultipleOutputs", "node.properties").increment(1);
+			}
+		}
+	}
+
+	private long processValue(NodePropertyOutputCountersAndValueWritable value, long blockCountOffset, long propOffset) throws IOException,
+			InterruptedException {
+
+		FullNodePropertiesWritable propHolder = value.getValue();
+		int propIndex = propHolder.getPropertyIndex().get();
+
+		PropertyRecord record = new PropertyRecord(propOffset);
+		record.setInUse(true);
+		record.setCreated();
+		record.setInUse(true);
+		long prev = propHolder.getPrevProp().get();
+		long next = propHolder.getNextProp().get();
+		if (prev != -1L) {
+			prev = (prev - propIndex) + propOffset;
+		}
+		if (next != -1L) {
+			next = (next - propIndex) + propOffset;
+		}
+		record.setPrevProp(prev);
+		record.setNextProp(next);
+
+		String[] properties = propHolder.getProperties().valuesToArray();
+		int[] propertyKeyIndexes = propHolder.getProperties().keysToArray();
+
+		for (int i = 0; i < properties.length; i++) {
+			Object propertyObj = getValueAsPropertyTypedClass(propertyKeyIndexes[i], properties[i]);
+			PropertyBlock propertyBlock = getPropertyBlock(propertyKeyIndexes[i], propertyObj, blockCountOffset);
+			record.addPropertyBlock(propertyBlock);
+		}
+
+		byte[] ba = Neo4JUtils.getPropertyReferenceAsByteArray(record);
+		outputValue.set(ba, 0, ba.length);
+		mos.write("props", NullWritable.get(), outputValue);
+
+		for (PropertyBlock block : record.getPropertyBlocks()) {
+
+			if (block.getValueRecords().size() > 0) {
+				ba = Neo4JUtils.getDynamicRecordsAsByteArray(block.getValueRecords(), 128);
+				outputValue.set(ba, 0, ba.length);
+				mos.write("strings", NullWritable.get(), outputValue);
+			}
+		}
+
+		return propHolder.getBlockCount().get();
+
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private Object getValueAsPropertyTypedClass(int propIndex, String property) {
+		Class type = null;
+		try {
+			if (propIndex < metaData.getNodePropertySize()) {
+				type = metaData.getNodeTypes()[propIndex];
+			}
+			if (type != null) {
+				return type.getConstructor(String.class).newInstance(property);
+			} else {
+				return property;
+			}
+		} catch (Exception e) {
+			return property;
+		}
+	}
+
+	private PropertyBlock getPropertyBlock(int propertyKey, Object property, long blockOffset) {
+		PropertyBlock block = new PropertyBlock();
+		Neo4JUtils.encodeValue(block, propertyKey, property, blockOffset);
+		return block;
+	}
+
+	protected void cleanup(Context context) throws IOException, InterruptedException {
+		mos.close();
+	}
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/SurroundingPropertyContext.java b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/SurroundingPropertyContext.java
new file mode 100644
index 0000000..34bcfa7
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/mapreduce/properties/SurroundingPropertyContext.java
@@ -0,0 +1,15 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+public class SurroundingPropertyContext {
+
+	public long nodeId = -1L, count = -1L, prev = -1L, next = -1L;
+	public int index = -1; 
+	public String nodeIdentifier = null;
+	public String toNodeIdentifier = null;
+	public String[] properties = null;
+	public int[] propertyIndexes = null;
+
+	public SurroundingPropertyContext() {
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/neo4j/Neo4JUtils.java b/job/src/main/java/nl/waredingen/graphs/neo/neo4j/Neo4JUtils.java
new file mode 100644
index 0000000..b74418f
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/neo4j/Neo4JUtils.java
@@ -0,0 +1,703 @@
+package nl.waredingen.graphs.neo.neo4j;
+
+import static java.lang.System.arraycopy;
+
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.HardCodedMetaDataImpl;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FSDataOutputStream;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.neo4j.helpers.UTF8;
+import org.neo4j.kernel.impl.nioneo.store.AbstractDynamicStore;
+import org.neo4j.kernel.impl.nioneo.store.AbstractNameStore;
+import org.neo4j.kernel.impl.nioneo.store.CommonAbstractStore;
+import org.neo4j.kernel.impl.nioneo.store.DynamicArrayStore;
+import org.neo4j.kernel.impl.nioneo.store.DynamicRecord;
+import org.neo4j.kernel.impl.nioneo.store.DynamicStringStore;
+import org.neo4j.kernel.impl.nioneo.store.LongerShortString;
+import org.neo4j.kernel.impl.nioneo.store.NeoStore;
+import org.neo4j.kernel.impl.nioneo.store.NodeRecord;
+import org.neo4j.kernel.impl.nioneo.store.PropertyBlock;
+import org.neo4j.kernel.impl.nioneo.store.PropertyIndexStore;
+import org.neo4j.kernel.impl.nioneo.store.PropertyRecord;
+import org.neo4j.kernel.impl.nioneo.store.PropertyStore;
+import org.neo4j.kernel.impl.nioneo.store.PropertyType;
+import org.neo4j.kernel.impl.nioneo.store.Record;
+import org.neo4j.kernel.impl.nioneo.store.RelationshipRecord;
+import org.neo4j.kernel.impl.nioneo.store.RelationshipTypeStore;
+import org.neo4j.kernel.impl.nioneo.store.StoreId;
+import org.neo4j.kernel.impl.util.Bits;
+
+public class Neo4JUtils {
+
+	public static void writeNeostore(String output, Configuration conf) throws IOException {
+		String neoOutput = output + "/neostore";
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream ndos = fs.create(new Path(neoOutput));
+
+		StoreId store = new StoreId();
+		ByteBuffer buffer = ByteBuffer.allocate(54);
+		buffer.put(Record.IN_USE.byteValue()).putLong(store.getCreationTime());
+		buffer.put(Record.IN_USE.byteValue()).putLong(store.getRandomId());
+		buffer.put(Record.IN_USE.byteValue()).putLong(0);
+		buffer.put(Record.IN_USE.byteValue()).putLong(1);
+		buffer.put(Record.IN_USE.byteValue()).putLong(store.getStoreVersion());
+		buffer.put(Record.IN_USE.byteValue()).putLong(-1);
+		buffer.flip();
+		ndos.write(buffer.array());
+
+		String type = NeoStore.TYPE_DESCRIPTOR + " " + CommonAbstractStore.ALL_STORES_VERSION;
+		ByteBuffer tailBuffer = ByteBuffer.allocate(type.length());
+		tailBuffer.put(type.getBytes(Charset.forName("UTF-8")));
+		tailBuffer.flip();
+		ndos.write(tailBuffer.array());
+		ndos.close();
+
+		writeNeostoreId(output, conf);
+	}
+
+	private static void writeNeostoreId(String output, Configuration conf) throws IOException {
+		String storeIdOutput = output + "/neostore.id";
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream ndos = fs.create(new Path(storeIdOutput));
+
+		ByteBuffer nodeBuffer = ByteBuffer.allocate(9);
+		nodeBuffer.put((byte) 0).putLong(6);
+		nodeBuffer.flip();
+		ndos.write(nodeBuffer.array());
+
+		ndos.close();
+	}
+
+	public static void writeNodeIds(long lastNodeId, String output, Configuration conf) throws IOException {
+		String nodeIdsOutput = output + "/neostore.nodestore.db.id";
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream ndos = fs.create(new Path(nodeIdsOutput));
+
+		ByteBuffer nodeBuffer = ByteBuffer.allocate(9);
+		nodeBuffer.put((byte) 0).putLong(lastNodeId);
+		nodeBuffer.flip();
+		ndos.write(nodeBuffer.array());
+
+		ndos.close();
+	}
+
+	public static void writeEdgeIds(long lastEdgeId, String output, Configuration conf) throws IOException {
+		String edgeIdsOutput = output + "/neostore.relationshipstore.db.id";
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream edos = fs.create(new Path(edgeIdsOutput));
+
+		ByteBuffer edgeBuffer = ByteBuffer.allocate(9);
+		edgeBuffer.put((byte) 0).putLong(lastEdgeId);
+		edgeBuffer.flip();
+		edos.write(edgeBuffer.array());
+
+		edos.close();
+
+	}
+
+	public static void writeSingleTypeStore(String typeName, String output, Configuration conf) throws IOException {
+		String typesOutput = output + "/neostore.relationshiptypestore.db";
+		String typeNamesOutput = output + "/neostore.relationshiptypestore.db.names";
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream tdos = fs.create(new Path(typesOutput));
+
+		tdos.write(getTypeRecordAsByteArray(1));
+
+		String type = RelationshipTypeStore.TYPE_DESCRIPTOR + " " + CommonAbstractStore.ALL_STORES_VERSION;
+		ByteBuffer tailBuffer = ByteBuffer.allocate(type.length());
+		tailBuffer.put(type.getBytes(Charset.forName("UTF-8")));
+		tailBuffer.flip();
+		tdos.write(tailBuffer.array());
+
+		tdos.close();
+
+		writeTypeIds(1L, output, conf);
+
+		FSDataOutputStream tndos = fs.create(new Path(typeNamesOutput));
+
+		type = DynamicStringStore.VERSION;
+		int blockSize = AbstractNameStore.NAME_STORE_BLOCK_SIZE + AbstractDynamicStore.BLOCK_HEADER_SIZE;
+
+		ByteBuffer headBuffer = ByteBuffer.allocate(blockSize);
+		headBuffer.putInt(blockSize);
+		// headBuffer.flip();
+		tndos.write(headBuffer.array());
+
+		tndos.write(getStringRecordAsByteArray(1L, typeName.getBytes(), blockSize));
+
+		type = DynamicStringStore.TYPE_DESCRIPTOR + " " + CommonAbstractStore.ALL_STORES_VERSION;
+		tailBuffer = ByteBuffer.allocate(type.length());
+		tailBuffer.put(type.getBytes(Charset.forName("UTF-8")));
+		tailBuffer.flip();
+		tndos.write(tailBuffer.array());
+
+		tndos.close();
+
+		writeTypeNameIds(2L, output, conf);
+	}
+
+	public static void writeTypeIds(long lastTypeId, String output, Configuration conf) throws IOException {
+		String typeIdsOutput = output + "/neostore.relationshiptypestore.db.id";
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream tdos = fs.create(new Path(typeIdsOutput));
+
+		ByteBuffer typeBuffer = ByteBuffer.allocate(9);
+		typeBuffer.put((byte) 0).putLong(lastTypeId);
+		typeBuffer.flip();
+		tdos.write(typeBuffer.array());
+
+		tdos.close();
+
+	}
+
+	public static void writeTypeNameIds(long lastTypeNameId, String output, Configuration conf) throws IOException {
+		String typeNamesOutput = output + "/neostore.relationshiptypestore.db.names.id";
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream tdos = fs.create(new Path(typeNamesOutput));
+
+		ByteBuffer typeNameBuffer = ByteBuffer.allocate(9);
+		typeNameBuffer.put((byte) 0).putLong(lastTypeNameId);
+		typeNameBuffer.flip();
+		tdos.write(typeNameBuffer.array());
+
+		tdos.close();
+
+	}
+
+	public static byte[] getNodeAsByteArray(long id, long relnum, long prop) {
+		ByteBuffer buffer = ByteBuffer.allocate(9);
+
+		NodeRecord nr = new NodeRecord(id, relnum, prop);
+		nr.setInUse(true);
+		nr.setCreated();
+
+		// LOG.debug(nr.toString());
+
+		long nextRel = nr.getNextRel();
+		long nextProp = nr.getNextProp();
+
+		short relModifier = nextRel == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0
+				: (short) ((nextRel & 0x700000000L) >> 31);
+		short propModifier = nextProp == Record.NO_NEXT_PROPERTY.intValue() ? 0
+				: (short) ((nextProp & 0xF00000000L) >> 28);
+
+		// [ , x] in use bit
+		// [ ,xxx ] higher bits for rel id
+		// [xxxx, ] higher bits for prop id
+		short inUseUnsignedByte = (nr.inUse() ? Record.IN_USE : Record.NOT_IN_USE).byteValue();
+		inUseUnsignedByte = (short) (inUseUnsignedByte | relModifier | propModifier);
+
+		buffer.put((byte) inUseUnsignedByte).putInt((int) nextRel).putInt((int) nextProp);
+		return buffer.array();
+
+	}
+
+	public static byte[] getEdgeAsByteArray(long relnum, long fromnode, long tonode, int type, long fromprev,
+			long fromnext, long toprev, long tonext, long prop) {
+
+		// TODO adjust nodeid's to match 1 more b/o root node!!
+		// now doing it here
+		long from = fromnode + 1L;
+		long to = tonode + 1L;
+		ByteBuffer buffer = ByteBuffer.allocate(33);
+
+		RelationshipRecord rr = new RelationshipRecord(relnum, from, to, type);
+		rr.setInUse(true);
+		rr.setCreated();
+
+		// LOG.debug(rr.toString());
+
+		short fromMod = (short) ((from & 0x700000000L) >> 31);
+		long toMod = (to & 0x700000000L) >> 4;
+		long fromPrevRelMod = fromprev == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (fromprev & 0x700000000L) >> 7;
+		long fromNextRelMod = fromnext == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (fromnext & 0x700000000L) >> 10;
+		long toPrevRelMod = toprev == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (toprev & 0x700000000L) >> 13;
+		long toNextRelMod = tonext == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (tonext & 0x700000000L) >> 16;
+		long propMod = prop == Record.NO_NEXT_PROPERTY.intValue() ? 0 : (prop & 0xF00000000L) >> 28;
+
+		// [ , x] in use flag
+		// [ ,xxx ] first node high order bits
+		// [xxxx, ] next prop high order bits
+		short inUseUnsignedByte = (short) ((rr.inUse() ? Record.IN_USE : Record.NOT_IN_USE).byteValue() | fromMod | propMod);
+
+		// [ xxx, ][ , ][ , ][ , ] second node high order bits, 0x70000000
+		// [ ,xxx ][ , ][ , ][ , ] first prev rel high order bits, 0xE000000
+		// [ , x][xx , ][ , ][ , ] first next rel high order bits, 0x1C00000
+		// [ , ][ xx,x ][ , ][ , ] second prev rel high order bits, 0x380000
+		// [ , ][ , xxx][ , ][ , ] second next rel high order bits, 0x70000
+		// [ , ][ , ][xxxx,xxxx][xxxx,xxxx] type
+		int typeInt = (int) (rr.getType() | toMod | fromPrevRelMod | fromNextRelMod | toPrevRelMod | toNextRelMod);
+
+		buffer.put((byte) inUseUnsignedByte).putInt((int) from).putInt((int) to).putInt(typeInt).putInt((int) fromprev)
+				.putInt((int) fromnext).putInt((int) toprev).putInt((int) tonext).putInt((int) prop);
+		return buffer.array();
+
+	}
+
+	public static byte[] getTypeRecordAsByteArray(int id) {
+		ByteBuffer buffer = ByteBuffer.allocate(5);
+		buffer.put(Record.IN_USE.byteValue()).putInt(id);
+		buffer.flip();
+
+		return buffer.array();
+	}
+
+	public static byte[] getStringRecordAsByteArray(long id, byte[] name, int blockSize) {
+		List<DynamicRecord> recordList = new LinkedList<DynamicRecord>();
+
+		long nextBlock = id;
+		int srcOffset = 0;
+		int dataSize = blockSize - DynamicStringStore.BLOCK_HEADER_SIZE;
+		do {
+			DynamicRecord record = new DynamicRecord(nextBlock);
+			record.setCreated();
+			record.setInUse(true);
+			if (name.length - srcOffset > dataSize) {
+				byte data[] = new byte[dataSize];
+				System.arraycopy(name, srcOffset, data, 0, dataSize);
+				record.setData(data);
+				record.setNextBlock(++nextBlock);
+				srcOffset += dataSize;
+			} else {
+				byte data[] = new byte[name.length - srcOffset];
+				System.arraycopy(name, srcOffset, data, 0, data.length);
+				record.setData(data);
+				nextBlock = Record.NO_NEXT_BLOCK.intValue();
+				record.setNextBlock(nextBlock);
+			}
+			recordList.add(record);
+		} while (nextBlock != Record.NO_NEXT_BLOCK.intValue());
+
+		return getDynamicRecordsAsByteArray(recordList, blockSize);
+	}
+
+	public static byte[] getDynamicRecordsAsByteArray(List<DynamicRecord> recordList, int blockSize) {
+		ByteBuffer buffer = ByteBuffer.allocate(blockSize * recordList.size());
+
+		for (DynamicRecord dynamicRecord : recordList) {
+
+			long nextProp = dynamicRecord.getNextBlock();
+			int nextModifier = nextProp == Record.NO_NEXT_BLOCK.intValue() ? 0 : (int) ((nextProp & 0xF00000000L) >> 8);
+			nextModifier |= (Record.IN_USE.byteValue() << 28);
+
+			/*
+			 * 
+			 * [ x, ][ , ][ , ][ , ] inUse [ ,xxxx][ , ][ , ][ , ] high next
+			 * block bits [ , ][xxxx,xxxx][xxxx,xxxx][xxxx,xxxx] nr of bytes
+			 */
+			int mostlyNrOfBytesInt = dynamicRecord.getLength();
+			assert mostlyNrOfBytesInt < (1 << 24) - 1;
+
+			mostlyNrOfBytesInt |= nextModifier;
+
+			buffer.putInt(mostlyNrOfBytesInt).putInt((int) nextProp);
+			if (!dynamicRecord.isLight()) {
+				buffer.put(dynamicRecord.getData());
+			}
+		}
+
+		buffer.flip();
+		return buffer.array();
+	}
+
+	public static void encodeValue(PropertyBlock block, int keyId, Object value, long stringBlockId) {
+		if (value instanceof String) { // Try short string first, i.e. inlined
+										// in the property block
+			String string = (String) value;
+			if (LongerShortString.encode(keyId, string, block, PropertyType.getPayloadSize()))
+				return;
+
+			// Fall back to dynamic string store
+			//long stringBlockId = 0L;// nextStringBlockId();
+			setSingleBlockValue(block, keyId, PropertyType.STRING, stringBlockId);
+			byte[] encodedString = encodeString(string);
+			Collection<DynamicRecord> valueRecords = allocateRecords(stringBlockId, encodedString);
+			for (DynamicRecord valueRecord : valueRecords) {
+				valueRecord.setType(PropertyType.STRING.intValue());
+				block.addValueRecord(valueRecord);
+			}
+		} else if (value instanceof Integer)
+			setSingleBlockValue(block, keyId, PropertyType.INT, ((Integer) value).longValue());
+		else if (value instanceof Boolean)
+			setSingleBlockValue(block, keyId, PropertyType.BOOL, (((Boolean) value).booleanValue() ? 1L : 0L));
+		else if (value instanceof Float)
+			setSingleBlockValue(block, keyId, PropertyType.FLOAT, Float.floatToRawIntBits(((Float) value).floatValue()));
+		else if (value instanceof Long) {
+			long keyAndType = keyId | (((long) PropertyType.LONG.intValue()) << 24);
+			if (ShortArray.LONG.getRequiredBits((Long) value) <= 35) { // We
+																		// only
+																		// need
+																		// one
+																		// block
+																		// for
+																		// this
+																		// value,
+																		// special
+																		// layout
+																		// compared
+																		// to,
+																		// say,
+																		// an
+																		// integer
+				block.setSingleBlock(keyAndType | (1L << 28) | (((Long) value).longValue() << 29));
+			} else { // We need two blocks for this value
+				block.setValueBlocks(new long[] { keyAndType, ((Long) value).longValue() });
+			}
+		} else if (value instanceof Double)
+			block.setValueBlocks(new long[] { keyId | (((long) PropertyType.DOUBLE.intValue()) << 24),
+					Double.doubleToRawLongBits(((Double) value).doubleValue()) });
+		else if (value instanceof Byte)
+			setSingleBlockValue(block, keyId, PropertyType.BYTE, ((Byte) value).longValue());
+		else if (value instanceof Character)
+			setSingleBlockValue(block, keyId, PropertyType.CHAR, ((Character) value).charValue());
+		else if (value instanceof Short)
+			setSingleBlockValue(block, keyId, PropertyType.SHORT, ((Short) value).longValue());
+		else if (value.getClass().isArray()) { // Try short array first, i.e.
+												// inlined in the property block
+			if (ShortArray.encode(keyId, value, block, PropertyType.getPayloadSize()))
+				return;
+
+			// Fall back to dynamic array store
+			long arrayBlockId = 0L;// nextArrayBlockId();
+			setSingleBlockValue(block, keyId, PropertyType.ARRAY, arrayBlockId);
+			Collection<DynamicRecord> arrayRecords = allocateArrayRecords(arrayBlockId, value);
+			for (DynamicRecord valueRecord : arrayRecords) {
+				valueRecord.setType(PropertyType.ARRAY.intValue());
+				block.addValueRecord(valueRecord);
+			}
+		} else {
+			throw new IllegalArgumentException("Unknown property type on: " + value + ", " + value.getClass());
+		}
+	}
+
+	private static void setSingleBlockValue(PropertyBlock block, int keyId, PropertyType type, long longValue) {
+		block.setSingleBlock(keyId | (((long) type.intValue()) << 24) | (longValue << 28));
+	}
+
+	private static byte[] encodeString(String string) {
+		return UTF8.encode(string);
+	}
+
+	private static Collection<DynamicRecord> allocateRecords(long startBlock, byte src[]) {
+
+		List<DynamicRecord> recordList = new LinkedList<DynamicRecord>();
+		long nextBlock = startBlock;
+		int srcOffset = 0;
+		int dataSize = 128 - AbstractDynamicStore.BLOCK_HEADER_SIZE;
+		do {
+			DynamicRecord record = new DynamicRecord(nextBlock);
+			record.setCreated();
+			record.setInUse(true);
+			if (src.length - srcOffset > dataSize) {
+				byte data[] = new byte[dataSize];
+				System.arraycopy(src, srcOffset, data, 0, dataSize);
+				record.setData(data);
+				nextBlock++;// = nextBlockId();
+				record.setNextBlock(nextBlock);
+				srcOffset += dataSize;
+			} else {
+				byte data[] = new byte[src.length - srcOffset];
+				System.arraycopy(src, srcOffset, data, 0, data.length);
+				record.setData(data);
+				nextBlock = Record.NO_NEXT_BLOCK.intValue();
+				record.setNextBlock(nextBlock);
+			}
+			recordList.add(record);
+		} while (nextBlock != Record.NO_NEXT_BLOCK.intValue());
+		return recordList;
+	}
+
+	private static Collection<DynamicRecord> allocateFromNumbers(long startBlock, Object array) {
+		Class<?> componentType = array.getClass().getComponentType();
+		boolean isPrimitiveByteArray = componentType.equals(Byte.TYPE);
+		boolean isByteArray = componentType.equals(Byte.class) || isPrimitiveByteArray;
+		byte[] bytes = null;
+		ShortArray type = ShortArray.typeOf(array);
+		if (type == null)
+			throw new IllegalArgumentException(array + " not a valid array type.");
+
+		int arrayLength = Array.getLength(array);
+		int requiredBits = isByteArray ? Byte.SIZE : type.calculateRequiredBitsForArray(array, arrayLength);
+		int totalBits = requiredBits * arrayLength;
+		int numberOfBytes = (totalBits - 1) / 8 + 1;
+		int bitsUsedInLastByte = totalBits % 8;
+		bitsUsedInLastByte = bitsUsedInLastByte == 0 ? 8 : bitsUsedInLastByte;
+		numberOfBytes += 3;// DynamicArrayStore.NUMBER_HEADER_SIZE; // type +
+							// rest + requiredBits header. TODO no need to use
+							// full bytes
+		int length = arrayLength;
+		if (isByteArray) {
+			bytes = new byte[3/* DynamicArrayStore.NUMBER_HEADER_SIZE */+ length];
+			bytes[0] = (byte) type.intValue();
+			bytes[1] = (byte) bitsUsedInLastByte;
+			bytes[2] = (byte) requiredBits;
+			if (isPrimitiveByteArray)
+				arraycopy((byte[]) array, 0, bytes, 3/*
+													 * DynamicArrayStore.
+													 * NUMBER_HEADER_SIZE
+													 */, length);
+			else {
+				Byte[] source = (Byte[]) array;
+				for (int i = 0; i < source.length; i++)
+					bytes[3/* DynamicArrayStore.NUMBER_HEADER_SIZE */+ i] = source[i].byteValue();
+			}
+		} else {
+			Bits bits = Bits.bits(numberOfBytes);
+			bits.put((byte) type.intValue());
+			bits.put((byte) bitsUsedInLastByte);
+			bits.put((byte) requiredBits);
+			type.writeAll(array, length, requiredBits, bits);
+			bytes = bits.asBytes();
+		}
+		return allocateRecords(startBlock, bytes);
+	}
+
+	private static Collection<DynamicRecord> allocateFromString(long startBlock, String[] array) {
+		List<byte[]> stringsAsBytes = new ArrayList<byte[]>();
+		int totalBytesRequired = 5;// DynamicArrayStore.STRING_HEADER_SIZE; //
+									// 1b type + 4b array length
+		for (String string : array) {
+			byte[] bytes = PropertyStore.encodeString(string);
+			stringsAsBytes.add(bytes);
+			totalBytesRequired += 4/* byte[].length */+ bytes.length;
+		}
+
+		ByteBuffer buf = ByteBuffer.allocate(totalBytesRequired);
+		buf.put(PropertyType.STRING.byteValue());
+		buf.putInt(array.length);
+		for (byte[] stringAsBytes : stringsAsBytes) {
+			buf.putInt(stringAsBytes.length);
+			buf.put(stringAsBytes);
+		}
+		return allocateRecords(startBlock, buf.array());
+	}
+
+	private static Collection<DynamicRecord> allocateArrayRecords(long startBlock, Object array) {
+		if (!array.getClass().isArray()) {
+			throw new IllegalArgumentException(array + " not an array");
+		}
+
+		Class<?> type = array.getClass().getComponentType();
+		if (type.equals(String.class)) {
+			return allocateFromString(startBlock, (String[]) array);
+		} else {
+			return allocateFromNumbers(startBlock, array);
+		}
+	}
+
+	public static byte[] getPropertyReferenceAsByteArray(PropertyRecord record) {
+		ByteBuffer buffer = ByteBuffer.allocate(41);
+
+		// Set up the record header
+		short prevModifier = record.getPrevProp() == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (short) ((record
+				.getPrevProp() & 0xF00000000L) >> 28);
+		short nextModifier = record.getNextProp() == Record.NO_NEXT_RELATIONSHIP.intValue() ? 0 : (short) ((record
+				.getNextProp() & 0xF00000000L) >> 32);
+		byte modifiers = (byte) (prevModifier | nextModifier);
+		/*
+		 * [pppp,nnnn] previous, next high bits
+		 */
+		buffer.put(modifiers);
+		buffer.putInt((int) record.getPrevProp()).putInt((int) record.getNextProp());
+
+		// Then go through the blocks
+		int longsAppended = 0; // For marking the end of blocks
+		for (PropertyBlock block : record.getPropertyBlocks()) {
+			long[] propBlockValues = block.getValueBlocks();
+			for (int k = 0; k < propBlockValues.length; k++) {
+				buffer.putLong(propBlockValues[k]);
+			}
+
+			longsAppended += propBlockValues.length;
+		}
+		if (longsAppended < PropertyType.getPayloadSizeLongs()) {
+			buffer.putLong(0);
+		}
+		buffer.flip();
+		return buffer.array();
+	}
+
+	public static void writePropertyKeyStore(String output, Configuration conf) throws IOException {
+
+		MetaData metaData = getMetaData(conf);
+		
+		String indexOutput = output + "/neostore.propertystore.db.index";
+		String keysOutput = output + "/neostore.propertystore.db.index.keys";
+
+		int lastUsedIndexId = 0;
+		int nextKeyBlockId = 1;
+		int blockSize = AbstractNameStore.NAME_STORE_BLOCK_SIZE + AbstractDynamicStore.BLOCK_HEADER_SIZE;
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream idos = fs.create(new Path(indexOutput));
+		FSDataOutputStream kdos = fs.create(new Path(keysOutput));
+
+        int endHeaderSize = blockSize;
+        ByteBuffer buffer = ByteBuffer.allocate( endHeaderSize );
+        buffer.putInt( blockSize );
+        kdos.write(buffer.array());
+
+        for ( String propertyName : metaData.getNodeTypeNames()) {
+		
+			nextKeyBlockId += writePropertyKey(nextKeyBlockId, blockSize, idos, kdos, propertyName);
+			lastUsedIndexId++;
+		}
+
+        for ( String propertyName : metaData.getEdgeTypeNames()) {
+        	// skip from and to
+        	if (!("from".equals(propertyName) || "to".equals(propertyName))) {
+        		nextKeyBlockId += writePropertyKey(nextKeyBlockId, blockSize, idos, kdos, propertyName);
+        		lastUsedIndexId++;
+        	}
+        }
+        
+		String type = PropertyIndexStore.TYPE_DESCRIPTOR + " " + CommonAbstractStore.ALL_STORES_VERSION;
+		byte[] encodedType = UTF8.encode(type);
+		
+		ByteBuffer tailBuffer = ByteBuffer.allocate(encodedType.length);
+		tailBuffer.put(encodedType);
+		tailBuffer.flip();
+		idos.write(tailBuffer.array());
+
+		type = DynamicStringStore.TYPE_DESCRIPTOR + " " + CommonAbstractStore.ALL_STORES_VERSION;
+		encodedType = UTF8.encode(type);
+		tailBuffer = ByteBuffer.allocate(encodedType.length);
+		tailBuffer.put(encodedType);
+		tailBuffer.flip();
+		kdos.write(tailBuffer.array());
+
+		idos.close();
+		kdos.close();
+
+		writePropertyIds(lastUsedIndexId, indexOutput, conf);
+		writePropertyIds(nextKeyBlockId, keysOutput, conf);
+
+		
+	}
+
+	private static int writePropertyKey(int nextKeyBlockId, int blockSize, FSDataOutputStream idos, FSDataOutputStream kdos, String propertyName)
+			throws IOException {
+		ByteBuffer indexBuffer = ByteBuffer.allocate(9);
+		indexBuffer.put(Record.IN_USE.byteValue());
+		indexBuffer.putInt(0);
+		indexBuffer.putInt(nextKeyBlockId);
+
+		idos.write(indexBuffer.array());
+		
+		byte[] name = getStringRecordAsByteArray(nextKeyBlockId, propertyName.getBytes(), blockSize );
+		
+		kdos.write(name, 0, name.length);
+		return (name.length / blockSize);
+	}
+
+	public static void writePropertyIds(long lastTypeId, String output, Configuration conf) throws IOException {
+		String idsOutput = output + ".id";
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream idos = fs.create(new Path(idsOutput));
+
+		ByteBuffer typeBuffer = ByteBuffer.allocate(9);
+		typeBuffer.put((byte) 0).putLong(lastTypeId);
+		typeBuffer.flip();
+		idos.write(typeBuffer.array());
+
+		idos.close();
+
+	}
+
+	public static void writePropertyStoreFooter(String propertiesOutput, Configuration conf) throws IOException {
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream fdos = fs.create(new Path(propertiesOutput + "/neostore.propertystore.db.footer"));
+
+		String type = PropertyStore.TYPE_DESCRIPTOR + " " + CommonAbstractStore.ALL_STORES_VERSION;
+		ByteBuffer tailBuffer = ByteBuffer.allocate(type.length());
+		tailBuffer.put(type.getBytes(Charset.forName("UTF-8")));
+		tailBuffer.flip();
+		fdos.write(tailBuffer.array());
+		fdos.close();
+	}
+
+	public static void writePropertyStringStoreHeader(String propertiesOutput, Configuration conf) throws IOException {
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream hdos = fs.create(new Path(propertiesOutput + "/neostore.propertystore.db.strings.header"));
+
+		int blockSize = 120 + AbstractDynamicStore.BLOCK_HEADER_SIZE;
+
+		ByteBuffer headBuffer = ByteBuffer.allocate(blockSize);
+		headBuffer.putInt(blockSize);
+		// headBuffer.flip();
+		hdos.write(headBuffer.array());
+		hdos.close();
+		
+	}
+
+	public static void writePropertyStringStoreFooter(String propertiesOutput, Configuration conf) throws IOException {
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream fdos = fs.create(new Path(propertiesOutput + "/neostore.propertystore.db.strings.footer"));
+
+		String type = DynamicStringStore.TYPE_DESCRIPTOR + " " + CommonAbstractStore.ALL_STORES_VERSION;
+		ByteBuffer tailBuffer = ByteBuffer.allocate(type.length());
+		tailBuffer.put(type.getBytes(Charset.forName("UTF-8")));
+		tailBuffer.flip();
+		fdos.write(tailBuffer.array());
+
+		fdos.close();
+		
+	}
+
+	public static void writeEmptArrayStore(String propertiesOutput, Configuration conf) throws IOException {
+		FileSystem fs = FileSystem.get(conf);
+		FSDataOutputStream ados = fs.create(new Path(propertiesOutput + "/neostore.propertystore.db.arrays"));
+
+		int blockSize = 120 + AbstractDynamicStore.BLOCK_HEADER_SIZE;
+
+		ByteBuffer headBuffer = ByteBuffer.allocate(blockSize);
+		headBuffer.putInt(blockSize);
+		// headBuffer.flip();
+		ados.write(headBuffer.array());
+
+		String type = DynamicArrayStore.TYPE_DESCRIPTOR + " " + CommonAbstractStore.ALL_STORES_VERSION;
+		ByteBuffer tailBuffer = ByteBuffer.allocate(type.length());
+		tailBuffer.put(type.getBytes(Charset.forName("UTF-8")));
+		tailBuffer.flip();
+		ados.write(tailBuffer.array());
+
+		ados.close();
+		
+		writePropertyIds(0L, propertiesOutput + "/neostore.propertystore.db.arrays", conf);
+		
+		
+	}
+	
+	public static MetaData getMetaData(Configuration conf) {
+		MetaData md = new HardCodedMetaDataImpl(conf);
+		@SuppressWarnings("unchecked")
+		Class<MetaData> mdClass = (Class<MetaData>) conf.getClass(AbstractMetaData.METADATA_CLASS, HardCodedMetaDataImpl.class);
+		try {
+			try {
+				Constructor<MetaData> constructor = mdClass.getConstructor(Configuration.class);
+				md = constructor.newInstance(conf);
+			} catch (NoSuchMethodException nsme) {
+				md = mdClass.newInstance();
+			}
+		} catch (Exception e) {
+			// ignore any exceptions. MetaData's default is already instantiated
+			System.out.println(e.getMessage());
+			e.printStackTrace();
+		}
+		return md;
+	}
+
+}
diff --git a/job/src/main/java/nl/waredingen/graphs/neo/neo4j/ShortArray.java b/job/src/main/java/nl/waredingen/graphs/neo/neo4j/ShortArray.java
new file mode 100644
index 0000000..37658d1
--- /dev/null
+++ b/job/src/main/java/nl/waredingen/graphs/neo/neo4j/ShortArray.java
@@ -0,0 +1,797 @@
+package nl.waredingen.graphs.neo.neo4j;
+
+/**
+ * Copyright (c) 2002-2012 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.IdentityHashMap;
+import java.util.Map;
+
+import org.neo4j.kernel.impl.nioneo.store.PropertyBlock;
+import org.neo4j.kernel.impl.nioneo.store.PropertyType;
+import org.neo4j.kernel.impl.util.Bits;
+
+public enum ShortArray
+{
+    BOOLEAN( PropertyType.BOOL, 1, Boolean.class, boolean.class )
+    {
+        @Override
+        int getRequiredBits( Object array, int arrayLength )
+        {
+            return 1;
+        }
+
+        @Override
+        void writeAll( Object array, int length, int requiredBits, Bits result )
+        {
+            if ( isPrimitive( array ) )
+            {
+                for ( boolean value : (boolean[]) array )
+                {
+                    result.put( value ? 1 : 0, 1 );
+                }
+            } else
+            {
+                for ( boolean value : (Boolean[]) array )
+                {
+                    result.put( value ? 1 : 0, 1 );
+                }
+            }
+        }
+
+        @Override
+        Object createArray( int length, Bits bits, int requiredBits )
+        {
+            if ( length == 0 )
+            {
+                return EMPTY_BOOLEAN_ARRAY;
+            }
+            final boolean[] result = new boolean[length];
+            for ( int i = 0; i < length; i++ )
+            {
+                result[i] = bits.getByte( requiredBits ) != 0;
+            }
+            return result;
+        }
+
+        @Override
+        public Object createEmptyArray()
+        {
+            return EMPTY_BOOLEAN_ARRAY;
+        }
+    },
+    BYTE( PropertyType.BYTE, 8, Byte.class, byte.class )
+    {
+        int getRequiredBits( byte value )
+        {
+            long mask = 1L << maxBits - 1;
+            for ( int i = maxBits; i > 0; i--, mask >>= 1 )
+            {
+                if ( (mask & value) != 0 )
+                {
+                    return i;
+                }
+            }
+            return 1;
+        }
+
+        @Override
+        int getRequiredBits( Object array, int arrayLength )
+        {
+            int highest = 1;
+            if ( isPrimitive( array ) )
+            {
+                for ( byte value : (byte[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            } else
+            {
+                for ( byte value : (Byte[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            }
+            return highest;
+        }
+
+        @Override
+        void writeAll( Object array, int length, int requiredBits, Bits result )
+        {
+            if ( isPrimitive( array ) )
+            {
+                for ( byte b : (byte[]) array )
+                {
+                    result.put( b, requiredBits );
+                }
+            } else
+            {
+                for ( byte b : (Byte[]) array )
+                {
+                    result.put( b, requiredBits );
+                }
+            }
+        }
+
+        @Override
+        Object createArray( int length, Bits bits, int requiredBits )
+        {
+            if ( length == 0 )
+            {
+                return EMPTY_BYTE_ARRAY;
+            }
+            final byte[] result = new byte[length];
+            for ( int i = 0; i < length; i++ )
+            {
+                result[i] = bits.getByte( requiredBits );
+            }
+            return result;
+        }
+
+        @Override
+        public Object createEmptyArray()
+        {
+            return EMPTY_BYTE_ARRAY;
+        }
+
+    },
+    SHORT( PropertyType.SHORT, 16, Short.class, short.class )
+    {
+        int getRequiredBits( short value )
+        {
+            long mask = 1L << maxBits - 1;
+            for ( int i = maxBits; i > 0; i--, mask >>= 1 )
+            {
+                if ( (mask & value) != 0 )
+                {
+                    return i;
+                }
+            }
+            return 1;
+        }
+
+        @Override
+        int getRequiredBits( Object array, int arrayLength )
+        {
+            int highest = 1;
+            if ( isPrimitive( array ) )
+            {
+                for ( short value : (short[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            } else
+            {
+                for ( short value : (Short[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            }
+            return highest;
+        }
+
+        @Override
+        void writeAll( Object array, int length, int requiredBits, Bits result )
+        {
+            if ( isPrimitive( array ) )
+            {
+                for ( short value : (short[]) array )
+                {
+                    result.put( value, requiredBits );
+                }
+            } else
+            {
+                for ( short value : (Short[]) array )
+                {
+                    result.put( value, requiredBits );
+                }
+            }
+        }
+
+        @Override
+        Object createArray( int length, Bits bits, int requiredBits )
+        {
+            if ( length == 0 )
+            {
+                return EMPTY_SHORT_ARRAY;
+            }
+            final short[] result = new short[length];
+            for ( int i = 0; i < length; i++ )
+            {
+                result[i] = bits.getShort( requiredBits );
+            }
+            return result;
+        }
+
+        @Override
+        public Object createEmptyArray()
+        {
+            return EMPTY_SHORT_ARRAY;
+        }
+    },
+    CHAR( PropertyType.CHAR, 16, Character.class , char.class)
+    {
+        int getRequiredBits( char value )
+        {
+            long mask = 1L << maxBits - 1;
+            for ( int i = maxBits; i > 0; i--, mask >>= 1 )
+            {
+                if ( (mask & value) != 0 )
+                {
+                    return i;
+                }
+            }
+            return 1;
+        }
+
+        @Override
+        int getRequiredBits( Object array, int arrayLength )
+        {
+            int highest = 1;
+            if ( isPrimitive( array ) )
+            {
+                for ( char value : (char[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            } else
+            {
+                for ( char value : (Character[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            }
+            return highest;
+        }
+
+        @Override
+        void writeAll( Object array, int length, int requiredBits, Bits result )
+        {
+            if ( isPrimitive( array ) )
+            {
+                for ( char value : (char[]) array )
+                {
+                    result.put( value, requiredBits );
+                }
+            } else
+            {
+                for ( char value : (Character[]) array )
+                {
+                    result.put( value, requiredBits );
+                }
+            }
+        }
+
+        @Override
+        Object createArray( int length, Bits bits, int requiredBits )
+        {
+            if ( length == 0 )
+            {
+                return EMPTY_CHAR_ARRAY;
+            }
+            final char[] result = new char[length];
+            for ( int i = 0; i < length; i++ )
+            {
+                result[i] = (char) bits.getShort( requiredBits );
+            }
+            return result;
+        }
+
+        @Override
+        public Object createEmptyArray()
+        {
+            return EMPTY_CHAR_ARRAY;
+        }
+    },
+    INT( PropertyType.INT, 32, Integer.class , int.class)
+    {
+        int getRequiredBits( int value )
+        {
+            long mask = 1L << maxBits - 1;
+            for ( int i = maxBits; i > 0; i--, mask >>= 1 )
+            {
+                if ( (mask & value) != 0 )
+                {
+                    return i;
+                }
+            }
+            return 1;
+        }
+
+        @Override
+        int getRequiredBits( Object array, int arrayLength )
+        {
+            int highest = 1;
+            if ( isPrimitive( array ) )
+            {
+                for ( int value : (int[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            } else
+            {
+                for ( int value : (Integer[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            }
+            return highest;
+        }
+
+        @Override
+        void writeAll( Object array, int length, int requiredBits, Bits result )
+        {
+            if ( isPrimitive( array ) )
+            {
+                for ( int value : (int[]) array )
+                {
+                    result.put( value, requiredBits );
+                }
+            } else
+            {
+                for ( int value : (Integer[]) array )
+                {
+                    result.put( value, requiredBits );
+                }
+            }
+        }
+
+        @Override
+        Object createArray( int length, Bits bits, int requiredBits )
+        {
+            if ( length == 0 )
+            {
+                return EMPTY_INT_ARRAY;
+            }
+            final int[] result = new int[length];
+            for ( int i = 0; i < length; i++ )
+            {
+                result[i] = bits.getInt( requiredBits );
+            }
+            return result;
+        }
+
+        @Override
+        public Object createEmptyArray()
+        {
+            return EMPTY_INT_ARRAY;
+        }
+    },
+    LONG( PropertyType.LONG, 64, Long.class , long.class)
+    {
+        public int getRequiredBits( long value )
+        {
+            long mask = 1L << maxBits - 1;
+            for ( int i = maxBits; i > 0; i--, mask >>= 1 )
+            {
+                if ( (mask & value) != 0 )
+                {
+                    return i;
+                }
+            }
+            return 1;
+        }
+
+
+        @Override
+        int getRequiredBits( Object array, int arrayLength )
+        {
+            int highest = 1;
+            if ( isPrimitive( array ) )
+            {
+                for ( long value : (long[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            } else
+            {
+                for ( long value : (Long[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            }
+            return highest;
+        }
+
+        @Override
+        void writeAll( Object array, int length, int requiredBits, Bits result )
+        {
+            if ( isPrimitive( array ) )
+            {
+                for ( long value : (long[]) array )
+                {
+                    result.put( value, requiredBits );
+                }
+            } else
+            {
+                for ( long value : (Long[]) array )
+                {
+                    result.put( value, requiredBits );
+                }
+            }
+        }
+
+        @Override
+        Object createArray( int length, Bits bits, int requiredBits )
+        {
+            if ( length == 0 )
+            {
+                return EMPTY_LONG_ARRAY;
+            }
+            final long[] result = new long[length];
+            for ( int i = 0; i < length; i++ )
+            {
+                result[i] = bits.getLong( requiredBits );
+            }
+            return result;
+        }
+
+        @Override
+        public Object createEmptyArray()
+        {
+            return EMPTY_LONG_ARRAY;
+        }
+    },
+    FLOAT( PropertyType.FLOAT, 32, Float.class ,float.class)
+    {
+        int getRequiredBits( float value )
+        {
+            int v = Float.floatToIntBits( value );
+            long mask = 1L << maxBits - 1;
+            for ( int i = maxBits; i > 0; i--, mask >>= 1 )
+            {
+                if ( (mask & v) != 0 )
+                {
+                    return i;
+                }
+            }
+            return 1;
+        }
+
+        @Override
+        int getRequiredBits( Object array, int arrayLength )
+        {
+            int highest = 1;
+            if ( isPrimitive( array ) )
+            {
+                for ( float value : (float[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            } else
+            {
+                for ( float value : (Float[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            }
+            return highest;
+        }
+
+        @Override
+        void writeAll( Object array, int length, int requiredBits, Bits result )
+        {
+            if ( isPrimitive( array ) )
+            {
+                for ( float value : (float[]) array )
+                {
+                    result.put( Float.floatToIntBits( value ), requiredBits );
+                }
+            } else
+            {
+                for ( float value : (Float[]) array )
+                {
+                    result.put( Float.floatToIntBits( value ), requiredBits );
+                }
+            }
+        }
+
+        @Override
+        Object createArray( int length, Bits bits, int requiredBits )
+        {
+            if ( length == 0 )
+            {
+                return EMPTY_FLOAT_ARRAY;
+            }
+            final float[] result = new float[length];
+            for ( int i = 0; i < length; i++ )
+            {
+                result[i] = Float.intBitsToFloat( bits.getInt( requiredBits ) );
+            }
+            return result;
+        }
+
+        @Override
+        public Object createEmptyArray()
+        {
+            return EMPTY_FLOAT_ARRAY;
+        }
+    },
+    DOUBLE( PropertyType.DOUBLE, 64, Double.class, double.class )
+    {
+        int getRequiredBits( double value )
+        {
+            long v = Double.doubleToLongBits( value );
+            long mask = 1L << maxBits - 1;
+            for ( int i = maxBits; i > 0; i--, mask >>= 1 )
+            {
+                if ( (mask & v) != 0 )
+                {
+                    return i;
+                }
+            }
+            return 1;
+        }
+
+        @Override
+        int getRequiredBits( Object array, int arrayLength )
+        {
+            int highest = 1;
+            if ( isPrimitive( array ) )
+            {
+                for ( double value : (double[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            } else
+            {
+                for ( double value : (Double[]) array )
+                {
+                    highest = Math.max( getRequiredBits( value ), highest );
+                }
+            }
+            return highest;
+        }
+
+        @Override
+        void writeAll( Object array, int length, int requiredBits, Bits result )
+        {
+            if ( isPrimitive( array ) )
+            {
+                for ( double value : (double[]) array )
+                {
+                    result.put( Double.doubleToLongBits( value ), requiredBits );
+                }
+            } else
+            {
+                for ( double value : (Double[]) array )
+                {
+                    result.put( Double.doubleToLongBits( value ), requiredBits );
+                }
+            }
+        }
+
+        @Override
+        Object createArray( int length, Bits bits, int requiredBits )
+        {
+            if ( length == 0 )
+            {
+                return EMPTY_DOUBLE_ARRAY;
+            }
+            final double[] result = new double[length];
+            for ( int i = 0; i < length; i++ )
+            {
+                result[i] = Double.longBitsToDouble( bits.getLong( requiredBits ) );
+            }
+            return result;
+        }
+
+        @Override
+        public Object createEmptyArray()
+        {
+            return EMPTY_DOUBLE_ARRAY;
+        }
+    };
+    public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
+    public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
+    public static final short[] EMPTY_SHORT_ARRAY = new short[0];
+    public static final char[] EMPTY_CHAR_ARRAY = new char[0];
+    public static final int[] EMPTY_INT_ARRAY = new int[0];
+    public static final long[] EMPTY_LONG_ARRAY = new long[0];
+    public static final float[] EMPTY_FLOAT_ARRAY = new float[0];
+    public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
+
+    private static boolean isPrimitive( Object array )
+    {
+        return array.getClass().getComponentType().isPrimitive();
+    }
+
+    @SuppressWarnings("rawtypes")
+	private final static Map<Class, ShortArray> all = new IdentityHashMap<Class, ShortArray>( values().length * 2 );
+
+    static
+    {
+        for ( ShortArray shortArray : values() )
+        {
+            all.put( shortArray.primitiveClass, shortArray );
+            all.put( shortArray.boxedClass, shortArray );
+        }
+    }
+
+    final int maxBits;
+
+    private final Class<?> boxedClass;
+    private final Class<?> primitiveClass;
+    private final PropertyType type;
+
+    private ShortArray( PropertyType type, int maxBits, Class<?> boxedClass, Class<?> primitiveClass)
+    {
+        this.type = type;
+        this.maxBits = maxBits;
+        this.boxedClass = boxedClass;
+        this.primitiveClass = primitiveClass;
+    }
+
+    public int intValue()
+    {
+        return type.intValue();
+    }
+
+    abstract Object createArray(int length, Bits bits, int requiredBits);
+
+    public static boolean encode( int keyId, Object array,
+                                  PropertyBlock target, int payloadSizeInBytes )
+    {
+        /*
+         *  If the array is huge, we don't have to check anything else.
+         *  So do the length check first.
+         */
+        int arrayLength = Array.getLength( array );
+        if ( arrayLength > 63 )/*because we only use 6 bits for length*/
+        {
+            return false;
+        }
+
+        ShortArray type = typeOf( array );
+        if ( type == null )
+        {
+            return false;
+        }
+
+        int requiredBits = type.calculateRequiredBitsForArray( array, arrayLength );
+        if ( !willFit( requiredBits, arrayLength, payloadSizeInBytes ) )
+        {
+            // Too big array
+            return false;
+        }
+        final int numberOfBytes = calculateNumberOfBlocksUsed( arrayLength, requiredBits ) * 8;
+        if ( Bits.requiredLongs( numberOfBytes ) > PropertyType.getPayloadSizeLongs() )
+        {
+            return false;
+        }
+        Bits result = Bits.bits( numberOfBytes );
+        // [][][    ,bbbb][bbll,llll][yyyy,tttt][kkkk,kkkk][kkkk,kkkk][kkkk,kkkk]
+        writeHeader( keyId, type, arrayLength, requiredBits, result );
+        type.writeAll( array, arrayLength, requiredBits, result );
+        target.setValueBlocks( result.getLongs() );
+        return true;
+    }
+
+    private static void writeHeader( int keyId, ShortArray type, int arrayLength, int requiredBits, Bits result )
+    {
+        result.put( keyId, 24 );
+        result.put( PropertyType.SHORT_ARRAY.intValue(), 4 );
+        result.put( type.type.intValue(), 4 );
+        result.put( arrayLength, 6 );
+        result.put( requiredBits, 6 );
+    }
+
+    public static Object decode( PropertyBlock block )
+    {
+        Bits bits = Bits.bitsFromLongs(Arrays.copyOf(block.getValueBlocks(), block.getValueBlocks().length));
+        // [][][    ,bbbb][bbll,llll][yyyy,tttt][kkkk,kkkk][kkkk,kkkk][kkkk,kkkk]
+        bits.getInt( 24 ); // Get rid of key
+        bits.getByte( 4 ); // Get rid of short array type
+        int typeId = bits.getByte( 4 );
+        int arrayLength = bits.getByte(6);
+        int requiredBits = bits.getByte( 6 );
+        /*
+         * So, it can be the case that values require 64 bits to store. However, you cannot encode this
+         * value with 6 bits. calculateRequiredBitsForArray never returns 0, because even for an array of
+         * all 0s one bit is required for every value. So when writing, we let it overflow and write out
+         * 0. When we are reading back, we just have to make sure that reading in 0 means 64.
+         */
+        if ( requiredBits == 0 )
+        {
+            requiredBits = 64;
+        }
+        ShortArray type = typeOf( (byte)typeId );
+        return type.createArray(arrayLength, bits, requiredBits);
+    }
+
+
+    private static boolean willFit( int requiredBits, int arrayLength, int payloadSizeInBytes )
+    {
+        int totalBitsRequired = requiredBits*arrayLength;
+        int maxBits = payloadSizeInBytes * 8 - 24 - 4 - 4 - 6 - 6;
+        return totalBitsRequired <= maxBits;
+    }
+
+    public int calculateRequiredBitsForArray(Object array, int arrayLength)
+    {
+        if ( arrayLength == 0 )
+        {
+            return 0;
+        }
+        // return getRequiredBits(findBiggestValue(array, arrayLength));
+        return getRequiredBits(array, arrayLength);
+    }
+
+    public int getRequiredBits( long value )
+    {
+        int highest = 1;
+        long mask = 1;
+        for ( int i = 1; i <= maxBits; i++, mask <<= 1 )
+        {
+            if ( (mask & value) != 0 )
+            {
+                highest = i;
+            }
+        }
+        return highest;
+    }
+
+    abstract int getRequiredBits(Object array, int arrayLength);
+
+    public static ShortArray typeOf( byte typeId )
+    {
+        return ShortArray.values()[typeId-1];
+    }
+
+    public static ShortArray typeOf( Object array )
+    {
+        return ShortArray.all.get(array.getClass().getComponentType());
+    }
+
+    public static int calculateNumberOfBlocksUsed( long firstBlock )
+    {
+        Bits bits = Bits.bitsFromLongs( new long[] {firstBlock} );
+        // bbbb][bbll,llll][yyyy,tttt][kkkk,kkkk][kkkk,kkkk][kkkk,kkkk]
+        bits.getInt( 24 ); // Get rid of key
+        bits.getByte( 4 ); // Get rid of short array type
+        bits.getByte( 4 ); // Get rid of the type
+        int arrayLength = bits.getByte( 6 );
+        int requiredBits = bits.getByte( 6 );
+        if ( requiredBits == 0 )
+        {
+            requiredBits = 64;
+        }
+        return calculateNumberOfBlocksUsed( arrayLength, requiredBits );
+    }
+
+    public static int calculateNumberOfBlocksUsed( int arrayLength, int requiredBits )
+    {
+        int bitsForItems = arrayLength*requiredBits;
+        /*
+         * Key, Property Type (ARRAY), Array Type, Array Length, Bits Per Member, Data
+         */
+        int totalBits = 24 + 4 + 4 + 6 + 6 + bitsForItems;
+        int result = ( totalBits - 1 ) / 64 + 1;
+        return result;
+    }
+
+    abstract void writeAll(Object array, int length, int requiredBits, Bits result);
+
+    public Object createEmptyArray()
+    {
+        return Array.newInstance( primitiveClass, 0 );
+    }
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/PropertyTest.java b/job/src/test/java/nl/waredingen/graphs/neo/PropertyTest.java
new file mode 100644
index 0000000..56c703b
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/PropertyTest.java
@@ -0,0 +1,394 @@
+package nl.waredingen.graphs.neo;
+
+import static org.junit.Assert.assertNotNull;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.neo4j.kernel.impl.nioneo.store.IdGeneratorImpl;
+import org.neo4j.kernel.impl.nioneo.store.PropertyBlock;
+import org.neo4j.kernel.impl.nioneo.store.PropertyType;
+
+public class PropertyTest {
+
+	// @Test
+	// public void test() {
+	// long tst = hexToLong("0000000016000000".getBytes());
+	// System.out.println(tst);
+	// long propBlock = Long.parseLong("0000000016000000", 16);
+	// System.out.println(propBlock);
+	// int type = (int) ((propBlock & 0x000000000F000000L) >> 24);
+	// System.out.println(type);
+	// }
+	//
+	// @Test
+	// public void testBlock1() {
+	// String[] stringBuffer = { "0000000016000000", "bae2608c7b000001",
+	// "00000000000003de", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock2() {
+	// String[] stringBuffer = { "0000000036000000", "bae2608e7b000001",
+	// "000000000001e77f", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock3() {
+	// String[] stringBuffer = { "0000000056000000", "7cf2608c7b000001",
+	// "000000000000078e", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock4() {
+	// String[] stringBuffer = { "0000000076000000", "79e2608c7b000001",
+	// "00000000000007be", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock5() {
+	// String[] stringBuffer = { "0000000096000000", "3dea608c7b000001",
+	// "000000000000076e", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock6() {
+	// String[] stringBuffer = { "0000065396000000", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// PropertyBlock block = toBlock(stringBuffer);
+	// System.out.println(block);
+	// System.out.println(block.getKeyIndexId());
+	// System.out.println(block.getSingleValueLong() >>> 1);
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock7() {
+	// String[] stringBuffer = { "000001dd16000000", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock8() {
+	// String[] stringBuffer = { "0000039276000000", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock9() {
+	// String[] stringBuffer = { "0000039276000000", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock10() {
+	// String[] stringBuffer = { "0000009f36000000", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock11() {
+	// String[] stringBuffer = { "0000039276000000", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock12() {
+	// String[] stringBuffer = { "000000823b000000", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock13() {
+	// String[] stringBuffer = { "db0dc08a7b000001", "0000000000000012",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock14() {
+	// String[] stringBuffer = { "000001023b000002", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock15() {
+	// String[] stringBuffer = { "0000000009000003", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock16() {
+	// String[] stringBuffer = { "000001823b000004", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock17() {
+	// String[] stringBuffer = { "db0dc18a7b000005", "0000000000000012",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock18() {
+	// String[] stringBuffer = { "000000823b000000", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock19() {
+	// String[] stringBuffer = { "db0dc08a7b000001", "0000000000000012",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock20() {
+	// String[] stringBuffer = { "000001023b000002", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock21() {
+	// String[] stringBuffer = { "0000000019000003", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock22() {
+	// String[] stringBuffer = { "000001823b000004", "0000000000000000",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock23() {
+	// String[] stringBuffer = { "db0dc18a7b000005", "0000000000000012",
+	// "0000000000000000", "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock24() {
+	// String[] stringBuffer = {
+	// "000000823b000000","db0dc08a7b000001","0000000000000012",
+	// "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock25() {
+	// String[] stringBuffer = {
+	// "000001023b000000","0000000019000001","0000000000000000",
+	// "0000000000000000" };
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+	//
+	// @Test
+	// public void testBlock26() {
+	// String[] stringBuffer = {
+	// "000001823b000000","db0dc18a7b000001","0000000000000012",
+	// "0000000000000000"};
+	// System.out.println(toBlock(stringBuffer));
+	//
+	// }
+
+	@Test
+	public void testInuseOfDynamicStore2011() {
+		String stringBuffer = "00ffffffffffffffff0008a39c7b00000004974365d2e94eb19a1a1110ab0000010000002221299938";
+		ByteBuffer buf = getBufferFromIntLikeString(stringBuffer);
+		System.out.println(buf);
+		byte modifiers = buf.get();
+		long prevMod = ((modifiers & 0xF0L) << 28);
+		long nextMod = ((modifiers & 0x0FL) << 32);
+		long prevProp = buf.getInt() & 0xFFFFFFFFL;
+		long nextProp = buf.getInt() & 0xFFFFFFFFL;
+		long recordPrevProp = longFromIntAndMod(prevProp, prevMod);
+		long recordNextProp = longFromIntAndMod(nextProp, nextMod);
+
+		System.out.println(recordPrevProp);
+		System.out.println(recordNextProp);
+		System.out.println(toBlock(buf));
+	}
+
+	@Test
+	public void testInuseOfDynamicStoreNeo() {
+		String stringBuffer = "00000000c6ffffffff000005021b000001000000000000000000000000000000000000000000000000";
+		ByteBuffer buf = getBufferFromIntLikeString(stringBuffer);
+		System.out.println(buf);
+		byte modifiers = buf.get();
+		long prevMod = ((modifiers & 0xF0L) << 28);
+		long nextMod = ((modifiers & 0x0FL) << 32);
+		long prevProp = buf.getInt() & 0xFFFFFFFFL;
+		long nextProp = buf.getInt() & 0xFFFFFFFFL;
+		long recordPrevProp = longFromIntAndMod(prevProp, prevMod);
+		long recordNextProp = longFromIntAndMod(nextProp, nextMod);
+
+		System.out.println(recordPrevProp);
+		System.out.println(recordNextProp);
+		System.out.println(toBlock(buf));
+	}
+
+	protected long longFromIntAndMod(long base, long modifier) {
+		return modifier == 0 && base == IdGeneratorImpl.INTEGER_MINUS_ONE ? -1 : base | modifier;
+	}
+
+	private ByteBuffer getBufferFromIntLikeString(String s) {
+		int len = s.length();
+		ByteBuffer buf = ByteBuffer.allocate(len / 2);
+
+		byte[] data = new byte[len / 2];
+		for (int i = 0; i < len; i += 2) {
+			data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
+		}
+		buf.put(data);
+		buf.flip();
+		return buf;
+	}
+
+	private PropertyBlock toBlock(String[] stringBuffer) {
+		long header = hexToLong(stringBuffer[0].getBytes());
+		PropertyType type = PropertyType.getPropertyType(header, true);
+
+		assertNotNull(type);
+
+		PropertyBlock toReturn = new PropertyBlock();
+		// toReturn.setInUse( true );
+		int numBlocks = type.calculateNumberOfBlocksUsed(header);
+		long[] blockData = new long[numBlocks];
+		blockData[0] = header; // we already have that
+		for (int i = 1; i < numBlocks; i++) {
+			blockData[i] = hexToLong(stringBuffer[1].getBytes());
+		}
+		toReturn.setValueBlocks(blockData);
+		return toReturn;
+	}
+
+	private PropertyBlock toBlock(ByteBuffer buffer) {
+		long header = buffer.getLong();
+		PropertyType type = PropertyType.getPropertyType(header, true);
+
+		assertNotNull(type);
+
+		PropertyBlock toReturn = new PropertyBlock();
+		// toReturn.setInUse( true );
+		int numBlocks = type.calculateNumberOfBlocksUsed(header);
+		long[] blockData = new long[numBlocks];
+		blockData[0] = header; // we already have that
+		for (int i = 1; i < numBlocks; i++) {
+			blockData[i] = buffer.getLong();
+		}
+		toReturn.setValueBlocks(blockData);
+		return toReturn;
+	}
+
+	private long hexToLong(byte[] bytes) {
+
+		if (bytes.length > 16) {
+			throw new IllegalArgumentException("Byte array too long (max 16 elements)");
+		}
+		long v = 0;
+		for (int i = 0; i < bytes.length; i += 2) {
+			byte b1 = (byte) (bytes[i] & 0xFF);
+
+			b1 -= 48;
+			if (b1 > 9)
+				b1 -= 39;
+
+			if (b1 < 0 || b1 > 15) {
+				throw new IllegalArgumentException("Illegal hex value: " + bytes[i]);
+			}
+
+			b1 <<= 4;
+
+			byte b2 = (byte) (bytes[i + 1] & 0xFF);
+			b2 -= 48;
+			if (b2 > 9)
+				b2 -= 39;
+
+			if (b2 < 0 || b2 > 15) {
+				throw new IllegalArgumentException("Illegal hex value: " + bytes[i + 1]);
+			}
+
+			v |= (((b1 & 0xF0) | (b2 & 0x0F))) & 0x00000000000000FFL;
+
+			if (i + 2 < bytes.length)
+				v <<= 8;
+		}
+
+		return v;
+	}
+
+	private byte[] longToHex(final long l) {
+		long v = l & 0xFFFFFFFFFFFFFFFFL;
+
+		byte[] result = new byte[16];
+		Arrays.fill(result, 0, result.length, (byte) 0);
+
+		for (int i = 0; i < result.length; i += 2) {
+			byte b = (byte) ((v & 0xFF00000000000000L) >> 56);
+
+			byte b2 = (byte) (b & 0x0F);
+			byte b1 = (byte) ((b >> 4) & 0x0F);
+
+			if (b1 > 9)
+				b1 += 39;
+			b1 += 48;
+
+			if (b2 > 9)
+				b2 += 39;
+			b2 += 48;
+
+			result[i] = (byte) (b1 & 0xFF);
+			result[i + 1] = (byte) (b2 & 0xFF);
+
+			v <<= 8;
+		}
+
+		return result;
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/RownumPartitionerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/RownumPartitionerTest.java
new file mode 100644
index 0000000..2a3654b
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/RownumPartitionerTest.java
@@ -0,0 +1,68 @@
+package nl.waredingen.graphs.neo;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.nodes.NodeOutputRownumPartitioner;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Text;
+import org.junit.Before;
+import org.junit.Test;
+
+public class RownumPartitionerTest {
+	private Configuration conf = new Configuration();
+	private NodeOutputRownumPartitioner<LongWritable, Text> partitioner = new NodeOutputRownumPartitioner<LongWritable, Text>();
+
+	@Before
+	public void setup() {
+		conf.set(AbstractMetaData.METADATA_NUMBER_OF_NODES, "100");
+		partitioner.setConf(conf);
+	}
+	
+	@Test
+	public void testPartitioningWith50Reducers() {
+		assertThat(partitioner.getPartition(new LongWritable(0), new Text(), 50), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(1), new Text(), 50), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(2), new Text(), 50), is(1));
+		assertThat(partitioner.getPartition(new LongWritable(3), new Text(), 50), is(1));
+		assertThat(partitioner.getPartition(new LongWritable(4), new Text(), 50), is(2));
+		assertThat(partitioner.getPartition(new LongWritable(5), new Text(), 50), is(2));
+		assertThat(partitioner.getPartition(new LongWritable(6), new Text(), 50), is(3));
+		assertThat(partitioner.getPartition(new LongWritable(7), new Text(), 50), is(3));
+		assertThat(partitioner.getPartition(new LongWritable(8), new Text(), 50), is(4));
+		assertThat(partitioner.getPartition(new LongWritable(9), new Text(), 50), is(4));
+		assertThat(partitioner.getPartition(new LongWritable(10), new Text(), 50), is(5));
+		assertThat(partitioner.getPartition(new LongWritable(11), new Text(), 50), is(5));
+		assertThat(partitioner.getPartition(new LongWritable(12), new Text(), 50), is(6));
+		assertThat(partitioner.getPartition(new LongWritable(98), new Text(), 50), is(49));
+		assertThat(partitioner.getPartition(new LongWritable(99), new Text(), 50), is(49));
+	}
+
+	@Test
+	public void testPartitioningWith7Reducers() {
+		
+		assertThat(partitioner.getPartition(new LongWritable(0), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(1), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(2), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(3), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(4), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(5), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(6), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(7), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(8), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(9), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(10), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(11), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(12), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(13), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(14), new Text(), 7), is(0));
+		assertThat(partitioner.getPartition(new LongWritable(15), new Text(), 7), is(1));
+		assertThat(partitioner.getPartition(new LongWritable(16), new Text(), 7), is(1));
+		assertThat(partitioner.getPartition(new LongWritable(29), new Text(), 7), is(2));
+		assertThat(partitioner.getPartition(new LongWritable(98), new Text(), 7), is(6));
+		assertThat(partitioner.getPartition(new LongWritable(99), new Text(), 7), is(6));
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/DualInputMapReduceDriver.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/DualInputMapReduceDriver.java
new file mode 100644
index 0000000..511d184
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/DualInputMapReduceDriver.java
@@ -0,0 +1,396 @@
+package nl.waredingen.graphs.neo.mapreduce;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.conf.Configured;
+import org.apache.hadoop.io.RawComparator;
+import org.apache.hadoop.mapreduce.Counters;
+import org.apache.hadoop.mapreduce.Mapper;
+import org.apache.hadoop.mapreduce.Reducer;
+import org.apache.hadoop.mrunit.MapReduceDriverBase;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+
+//import com.google.common.collect.Lists;
+
+/**
+ * Extension to MapReduceDriver which allows you to test as if you were using
+ * MultipleInputs with two input streams and two mappers. Useful for testing
+ * reduce-side joins.
+ * 
+ * @param <KIN1>
+ *            Type of input key of mapper 1
+ * @param <VIN1>
+ *            Type of input value of mapper 1
+ * @param <KIN2>
+ *            Type of input key of mapper 2
+ * @param <VIN2>
+ *            Type of input value of mapper 2
+ * @param <KMAP>
+ *            Type of output key of both mappers, e.g. if we are doing a join
+ *            the join key.
+ * @param <VMAP>
+ *            Type of output value of both mappers, e.g. a common base class of
+ *            VIN1 and VIN2.
+ * @param <KOUT>
+ *            Type of output key from the reducer.
+ * @param <VOUT>
+ *            Type of output value from the reducer.
+ * 
+ * @author Jacob Metcalf
+ */
+
+@SuppressWarnings("rawtypes")
+public class DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP extends Comparable, VMAP, KOUT, VOUT> extends
+		MapReduceDriverBase<KIN1, VIN1, KMAP, VMAP, KOUT, VOUT> {
+
+	protected Mapper<KIN1, VIN1, KMAP, VMAP> firstMapper;
+	protected Mapper<KIN2, VIN2, KMAP, VMAP> secondMapper;
+	protected Reducer<KMAP, VMAP, KMAP, VMAP> combiner;
+	protected Reducer<KMAP, VMAP, KOUT, VOUT> reducer;
+	protected Counters counters = new Counters();
+	@SuppressWarnings("unchecked")
+	protected List<Pair<KIN2, VIN2>> secondInputList = new ArrayList();
+
+	/**
+	 * Set the First Mapper instance to use with this test driver
+	 * 
+	 * @param m
+	 *            the Mapper instance to use
+	 */
+	public void setFirstMapper(final Mapper<KIN1, VIN1, KMAP, VMAP> mapper) {
+		firstMapper = mapper;
+	}
+
+	/**
+	 * Sets the First Mapper instance to use and returns self for fluent style
+	 * */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withFirstMapper(
+			final Mapper<KIN1, VIN1, KMAP, VMAP> mapper) {
+		setFirstMapper(mapper);
+		return this;
+	}
+
+	/**
+	 * @return the First Mapper object being used by this test
+	 */
+	public Mapper<KIN1, VIN1, KMAP, VMAP> getFirstMapper() {
+		return firstMapper;
+	}
+
+	/**
+	 * Set the Second Mapper instance to use with this test driver
+	 * 
+	 * @param m
+	 *            the Second Mapper instance to use
+	 */
+	public void setSecondMapper(final Mapper<KIN2, VIN2, KMAP, VMAP> mapper) {
+		secondMapper = mapper;
+	}
+
+	/**
+	 * Sets the Second Mapper instance to use and returns self for fluent style
+	 * */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withSecondMapper(
+			final Mapper<KIN2, VIN2, KMAP, VMAP> mapper) {
+		setSecondMapper(mapper);
+		return this;
+	}
+
+	/**
+	 * @return the Second Mapper object being used by this test
+	 */
+	public Mapper<KIN2, VIN2, KMAP, VMAP> getSecondMapper() {
+		return secondMapper;
+	}
+
+	/**
+	 * Sets the reducer object to use for this test. Since the input object
+	 * could be VMAP1 or VMAP2 we will have to specify Object.
+	 * 
+	 * @param r
+	 *            The reducer object to use
+	 */
+	public void setReducer(final Reducer<KMAP, VMAP, KOUT, VOUT> r) {
+		reducer = r;
+	}
+
+	/**
+	 * Identical to setReducer(), but with fluent programming style
+	 * 
+	 * @param r
+	 *            The Reducer to use
+	 * @return this
+	 */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withReducer(
+			final Reducer<KMAP, VMAP, KOUT, VOUT> r) {
+		setReducer(r);
+		return this;
+	}
+
+	/**
+	 * @return the Reducer object being used for this test
+	 */
+	public Reducer<KMAP, VMAP, KOUT, VOUT> getReducer() {
+		return reducer;
+	}
+
+	/**
+	 * Sets the reducer object to use as a combiner for this test
+	 * 
+	 * @param c
+	 *            The combiner object to use
+	 */
+	public void setCombiner(final Reducer<KMAP, VMAP, KMAP, VMAP> c) {
+		combiner = c;
+	}
+
+	/**
+	 * Identical to setCombiner(), but with fluent programming style
+	 * 
+	 * @param c
+	 *            The Combiner to use
+	 * @return this
+	 */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withCombiner(
+			final Reducer<KMAP, VMAP, KMAP, VMAP> c) {
+		setCombiner(c);
+		return this;
+	}
+
+	/**
+	 * @return the Combiner object being used for this test
+	 */
+	public Reducer<KMAP, VMAP, KMAP, VMAP> getCombiner() {
+		return combiner;
+	}
+
+	/**
+	 * Identical to setGroupingCompataor(), but with fluent programming style
+	 * 
+	 * @param g
+	 *            The grouping comparator to use
+	 * @return this
+	 */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withKeyGroupingComparator(
+			final RawComparator<KMAP> g) {
+		setKeyGroupingComparator(g);
+		return this;
+	}
+
+	/**
+	 * @return the Grouping Comparator being used for the shuffle on this test
+	 */
+	public Comparator<KMAP> getGroupingComparator() {
+		return keyGroupComparator;
+	}
+
+	/**
+	 * Identical to setKeyOrderCompataor(), but with fluent programming style
+	 * 
+	 * @param s
+	 *            The key order comparator to use
+	 * @return this
+	 */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withKeyOrderComparator(
+			final RawComparator<KMAP> s) {
+		setKeyOrderComparator(s);
+		return this;
+	}
+
+	/**
+	 * @return the Key order comparator being used for this test
+	 */
+	public Comparator<KMAP> getKeyOrderComparator() {
+		return keyValueOrderComparator;
+	}
+
+	/** @return the counters used in this test */
+	public Counters getCounters() {
+		return counters;
+	}
+
+	/**
+	 * @param configuration
+	 *            The configuration object that will given to the mapper and/or
+	 *            reducer associated with the driver
+	 */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withConfiguration(
+			final Configuration configuration) {
+		setConfiguration(configuration);
+		return this;
+	}
+
+	/**
+	 * Sets the counters object to use for this test.
+	 * 
+	 * @param ctrs
+	 *            The counters object to use.
+	 */
+	public void setCounters(final Counters ctrs) {
+		counters = ctrs;
+		//counterWrapper = new CounterWrapper(counters);
+	}
+
+	/** Sets the counters to use and returns self for fluent style */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withCounters(final Counters ctrs) {
+		setCounters(ctrs);
+		return this;
+	}
+
+	/**
+	 * Identical to addInput() but returns self for fluent programming style
+	 * 
+	 * @param key
+	 * @param val
+	 * @return this
+	 */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withFirstInput(final KIN1 key,
+			final VIN1 val) {
+		addInput(key, val);
+		return this;
+	}
+
+	/**
+	 * Identical to addInput() but returns self for fluent programming style
+	 * 
+	 * @param key
+	 * @param val
+	 * @return this
+	 */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withFirstInput(
+			final Pair<KIN1, VIN1> pair) {
+		addInput(pair);
+		return this;
+	}
+
+	/**
+	 * Adds an input to send to the mapper
+	 * 
+	 * @param key
+	 * @param val
+	 */
+	public void addSecondInput(final KIN2 key, final VIN2 val) {
+		secondInputList.add(new Pair<KIN2, VIN2>(key, val));
+	}
+
+	/**
+	 * Identical to addSecondInput() but returns self for fluent programming
+	 * style
+	 * 
+	 * @param key
+	 * @param val
+	 * @return this
+	 */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withSecondInput(final KIN2 key,
+			final VIN2 val) {
+		addSecondInput(key, val);
+		return this;
+	}
+
+	/**
+	 * Identical to addInput() but returns self for fluent programming style
+	 * 
+	 * @param key
+	 * @param val
+	 * @return this
+	 */
+	public DualInputMapReduceDriver<KIN1, VIN1, KIN2, VIN2, KMAP, VMAP, KOUT, VOUT> withSecondInput(
+			final Pair<KIN2, VIN2> pair) {
+		secondInputList.add(pair);
+		return this;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<Pair<KOUT, VOUT>> run() throws IOException {
+		if (inputList.isEmpty()) {
+			throw new IllegalStateException("No input was provided");
+		}
+		if (firstMapper == null) {
+			throw new IllegalStateException("First Mapper class was	provided");
+		}
+
+		if (secondMapper == null) {
+			throw new IllegalStateException("Second Mapper class was provided");
+		}
+
+		if (reducer == null) {
+			throw new IllegalStateException("No Reducer class was provided");
+		}
+
+		List<Pair<KMAP, VMAP>> mapOutputs = new ArrayList<Pair<KMAP, VMAP>>();
+
+		// Run first map component
+		for (final Pair<KIN1, VIN1> input : this.inputList) {
+			LOG.debug("Mapping first input " + input.toString() + ")");
+
+			mapOutputs.addAll(new MapDriver(firstMapper)
+
+			.withConfiguration(configuration).withCounters(getCounters()).withInput(input).run());
+
+		}
+
+		// Run second map component
+		for (final Pair<KIN2, VIN2> input : this.secondInputList) {
+			LOG.debug("Mapping second input " + input.toString() + ")");
+
+			mapOutputs.addAll(new MapDriver(secondMapper)
+
+			.withConfiguration(configuration).withCounters(getCounters()).withInput(input).run());
+		}
+
+		// Configure grouping and sorting comparators
+		if (keyGroupComparator instanceof Configured) {
+			((Configured) keyGroupComparator).setConf(configuration);
+		}
+		if (keyValueOrderComparator instanceof Configured) {
+			((Configured) keyValueOrderComparator).setConf(configuration);
+		}
+
+		if (this.getCombiner() != null) {
+			// User has specified a combiner. Run this and replace the mapper
+			// outputs
+			// with the result of the combiner.
+			LOG.debug("Starting combine phase with combiner: " + combiner);
+			mapOutputs = new ReducePhaseRunner<KMAP, VMAP>().runReduce(shuffle(mapOutputs), combiner);
+		}
+
+		// Run the reduce phase.
+		LOG.debug("Starting reduce phase with reducer: " + reducer);
+		return new ReducePhaseRunner<KOUT, VOUT>().runReduce(shuffle(mapOutputs), reducer);
+	}
+
+	/**
+	 * Have to copy class as its private.
+	 */
+	private class ReducePhaseRunner<OUTKEY, OUTVAL> {
+		private List<Pair<OUTKEY, OUTVAL>> runReduce(final List<Pair<KMAP, List<VMAP>>> inputs,
+				final Reducer<KMAP, VMAP, OUTKEY, OUTVAL> reducer) throws IOException {
+
+			final List<Pair<OUTKEY, OUTVAL>> reduceOutputs = new ArrayList<Pair<OUTKEY, OUTVAL>>();
+
+			for (final Pair<KMAP, List<VMAP>> input : inputs) {
+				final KMAP inputKey = input.getFirst();
+				final List<VMAP> inputValues = input.getSecond();
+				final StringBuilder sb = new StringBuilder();
+				formatValueList(inputValues, sb);
+				LOG.debug("Reducing input (" + inputKey.toString() + ", " + sb.toString() + ")");
+
+				@SuppressWarnings("unchecked")
+				final ReduceDriver<KMAP, VMAP, OUTKEY, OUTVAL> reduceDriver = new ReduceDriver(reducer)
+						.withCounters(getCounters())
+
+						.withConfiguration(configuration).withInputKey(inputKey).withInputValues(inputValues);
+				reduceOutputs.addAll(reduceDriver.run());
+			}
+
+			return reduceOutputs;
+		}
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputMapperTest.java
new file mode 100644
index 0000000..8e61937
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputMapperTest.java
@@ -0,0 +1,59 @@
+package nl.waredingen.graphs.neo.mapreduce.edges;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.DoubleSurroundingEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EdgeOutputMapperTest {
+	private MapDriver<NullWritable, DoubleSurroundingEdgeWritable, LongWritable, FullEdgeWritable> driver;
+	private List<Pair<LongWritable, FullEdgeWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<NullWritable, DoubleSurroundingEdgeWritable, LongWritable, FullEdgeWritable>(new EdgeOutputMapper());
+	}
+
+	@Test
+	public void shouldOutputAsEdgeWhenNodeIdMatchesFromNode() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(0,0,0,1,100,2,-1),new SurroundingEdgeWritable(1,0,0,1,100,1,-1))).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new LongWritable(0)));
+		assertThat(output.get(0).getSecond(), equalTo(new FullEdgeWritable(0,1,100,2,-1,1,-1)));
+
+	}
+
+	@Test
+	public void shouldOutputAsEdgeWhereEdgeIdIsTheKeyAndNodeIdMatchesFromNode() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(2,3,2,0,130,-1,2),new SurroundingEdgeWritable(0,3,2,0,130,-1,2))).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new LongWritable(3)));
+		assertThat(output.get(0).getSecond(), equalTo(new FullEdgeWritable(2,0,130,-1,2,-1,2)));
+
+	}
+
+	@Test
+	public void shouldNotOutputAsEdgeWhenNodeIdDoesNotMatchFromNode() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(0,3,2,0,130,-1,2),new SurroundingEdgeWritable(2,3,2,0,130,-1,2))).run();
+
+		assertThat(output.size(), is(0));
+	}
+
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputReducerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputReducerTest.java
new file mode 100644
index 0000000..135167b
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/EdgeOutputReducerTest.java
@@ -0,0 +1,40 @@
+package nl.waredingen.graphs.neo.mapreduce.edges;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgeWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EdgeOutputReducerTest {
+	private ReduceDriver<LongWritable, FullEdgeWritable, NullWritable, BytesWritable> driver;
+	private List<Pair<NullWritable, BytesWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new ReduceDriver<LongWritable, FullEdgeWritable, NullWritable, BytesWritable>(new EdgeOutputReducer());
+	}
+
+	@Test
+	public void shouldOutputAsSomeEdge() throws Exception {
+		output = driver.withInputKey(new LongWritable(1)).withInputValue(new FullEdgeWritable(2,0,110,-1,2,-1,2)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new BytesWritable(Neo4JUtils.getEdgeAsByteArray(1L, 2L, 0L, 0, -1L, 2L, -1L, 2L, 110L))));
+
+	}
+	
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundMapReduceTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundMapReduceTest.java
new file mode 100644
index 0000000..d98215f
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundMapReduceTest.java
@@ -0,0 +1,59 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.AscLongDescLongKeyComparator;
+import nl.waredingen.graphs.neo.mapreduce.AscLongDescLongKeyGroupingComparator;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.MapReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EdgeSurroundMapReduceTest {
+
+	private MapReduceDriver<NullWritable, NodeEdgeWritable, AscLongDescLongWritable, EdgeWritable, NullWritable, SurroundingEdgeWritable> driver;
+	private List<Pair<NullWritable, SurroundingEdgeWritable>> output;
+
+	@SuppressWarnings("unchecked")
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapReduceDriver<NullWritable, NodeEdgeWritable, AscLongDescLongWritable, EdgeWritable, NullWritable, SurroundingEdgeWritable>(new EdgeSurroundMapper(),new EdgeSurroundReducer());
+		driver.setKeyGroupingComparator(new AscLongDescLongKeyGroupingComparator());
+		driver.setKeyOrderComparator(new AscLongDescLongKeyComparator());
+	}
+
+	@Test
+	public void shouldjoinFromNodeAndEdge() throws Exception {
+		driver.withInput(NullWritable.get(), new NodeEdgeWritable(0,1,0,0,1,100));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(0,1,2,0,2,120));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(1,3,0,0,1,100));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(1,3,1,1,2,110));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(2,5,1,1,2,110));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(2,5,2,0,2,120));
+		output = driver.run();
+
+		assertThat(output.size(), is(6));
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new SurroundingEdgeWritable(0,2,0,2,120,0,-1)));
+		assertThat(output.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(1).getSecond(), equalTo(new SurroundingEdgeWritable(0,0,0,1,100,-1,2)));
+		assertThat(output.get(2).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(2).getSecond(), equalTo(new SurroundingEdgeWritable(1,1,1,2,110,0,-1)));
+		assertThat(output.get(3).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(3).getSecond(), equalTo(new SurroundingEdgeWritable(1,0,0,1,100,-1,1)));
+		assertThat(output.get(4).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(4).getSecond(), equalTo(new SurroundingEdgeWritable(2,2,0,2,120,1,-1)));
+		assertThat(output.get(5).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(5).getSecond(), equalTo(new SurroundingEdgeWritable(2,1,1,2,110,-1,2)));
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundMapperTest.java
new file mode 100644
index 0000000..91ecf41
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundMapperTest.java
@@ -0,0 +1,76 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaDataFromConfigImpl;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EdgeSurroundMapperTest {
+	private MapDriver<NullWritable, NodeEdgeWritable, AscLongDescLongWritable, EdgeWritable> driver;
+	private List<Pair<AscLongDescLongWritable, EdgeWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<NullWritable, NodeEdgeWritable, AscLongDescLongWritable, EdgeWritable>(new EdgeSurroundMapper());
+	}
+
+	@Test
+	public void shouldOutputAsNode() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new NodeEdgeWritable(0,1,3,2,0,5)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(0), new LongWritable(3))));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeWritable(3,2,0,5)));
+
+	}
+
+	@Test
+	public void shouldOutputAsNodeWhereNodeIdIsTheKey() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new NodeEdgeWritable(11,21,3,2,0,5)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(11), new LongWritable(3))));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeWritable(3,2,0,5)));
+
+	}
+
+	@Test
+	public void shouldOutputAsNodeWhereNodeIdIsTheKeyAndSomeEdgePropertiesArePresent() throws Exception {
+		Configuration config = new Configuration();
+		config.setClass("neo.input.metadata.class", MetaDataFromConfigImpl.class, MetaData.class);
+		config.setStrings("neo.input.metadata.node.property.names", "identifier", "name");
+		config.set("neo.input.metadata.node.id.name", "identifier");
+		config.setClass("neo.input.metadata.node.property.type.identifier", Long.class, Object.class);
+		config.setClass("neo.input.metadata.node.property.type.name", String.class, Object.class);
+		config.setStrings("neo.input.metadata.edge.property.names", "from", "to", "prop1", "prop2");
+		config.setClass("neo.input.metadata.edge.property.type.from", Long.class, Object.class);
+		config.setClass("neo.input.metadata.edge.property.type.to", Long.class, Object.class);
+		config.setClass("neo.input.metadata.edge.property.type.prop1", String.class, Object.class);
+		config.setClass("neo.input.metadata.edge.property.type.prop2", String.class, Object.class);
+		driver.setConfiguration(config);
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new NodeEdgeWritable(11,21,3,2,0,5)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(11), new LongWritable(3))));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeWritable(3,2,0,5)));
+
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundReducerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundReducerTest.java
new file mode 100644
index 0000000..94f8637
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/EdgeSurroundReducerTest.java
@@ -0,0 +1,95 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaDataFromConfigImpl;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EdgeSurroundReducerTest {
+	private ReduceDriver<AscLongDescLongWritable, EdgeWritable, NullWritable, SurroundingEdgeWritable> driver;
+	private List<Pair<NullWritable, SurroundingEdgeWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new ReduceDriver<AscLongDescLongWritable, EdgeWritable, NullWritable, SurroundingEdgeWritable>(new EdgeSurroundReducer());
+	}
+
+	@Test
+	public void shouldOutputSurroundingEdges() throws Exception {
+		List<EdgeWritable> values = new ArrayList<EdgeWritable>();
+		values.add(new EdgeWritable(3,2,1,130));
+		values.add(new EdgeWritable(1,1,2,110));
+		values.add(new EdgeWritable(2,1,3,120));
+		values.add(new EdgeWritable(4,3,1,140));
+		//Unfortunately no multiple keys can be added to this reducer, as is in real life.
+		//This results in an incorrect relnum in this test
+		output = driver.withInputKey(new AscLongDescLongWritable(new LongWritable(1), new LongWritable(3))).withInputValues(values).run();
+
+		assertThat(output.size(), is(4));
+
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new SurroundingEdgeWritable(1,3,2,1,130,1,-1)));
+		assertThat(output.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(1).getSecond(), equalTo(new SurroundingEdgeWritable(1,1,1,2,110,2,3)));
+		assertThat(output.get(2).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(2).getSecond(), equalTo(new SurroundingEdgeWritable(1,2,1,3,120,4,1)));
+		assertThat(output.get(3).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(3).getSecond(), equalTo(new SurroundingEdgeWritable(1,4,3,1,140,-1,2)));
+
+	}
+
+	@Test
+	public void shouldOutputSurroundingEdgesWithProperties() throws Exception {
+		List<EdgeWritable> values = new ArrayList<EdgeWritable>();
+		values.add(new EdgeWritable(3,2,1,130));
+		values.add(new EdgeWritable(1,1,2,110));
+		values.add(new EdgeWritable(2,1,3,120));
+		values.add(new EdgeWritable(4,3,1,140));
+		
+		Configuration config = new Configuration();
+		config.setClass("neo.input.metadata.class", MetaDataFromConfigImpl.class, MetaData.class);
+		config.setStrings("neo.input.metadata.node.property.names", "identifier", "name");
+		config.set("neo.input.metadata.node.id.name", "identifier");
+		config.setClass("neo.input.metadata.node.property.type.identifier", Long.class, Object.class);
+		config.setClass("neo.input.metadata.node.property.type.name", String.class, Object.class);
+		config.setStrings("neo.input.metadata.edge.property.names", "from", "to", "prop1", "prop2");
+		config.setClass("neo.input.metadata.edge.property.type.from", Long.class, Object.class);
+		config.setClass("neo.input.metadata.edge.property.type.to", Long.class, Object.class);
+		config.setClass("neo.input.metadata.edge.property.type.prop1", String.class, Object.class);
+		config.setClass("neo.input.metadata.edge.property.type.prop2", String.class, Object.class);
+		driver.setConfiguration(config);
+
+		//Unfortunately no multiple keys can be added to this reducer, as is in real life.
+		//This results in an incorrect relnum in this test
+		output = driver.withInputKey(new AscLongDescLongWritable(new LongWritable(1), new LongWritable(3))).withInputValues(values).run();
+		
+		assertThat(output.size(), is(4));
+		
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new SurroundingEdgeWritable(1,3,2,1,130,1,-1)));
+		assertThat(output.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(1).getSecond(), equalTo(new SurroundingEdgeWritable(1,1,1,2,110,2,3)));
+		assertThat(output.get(2).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(2).getSecond(), equalTo(new SurroundingEdgeWritable(1,2,1,3,120,4,1)));
+		assertThat(output.get(3).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(3).getSecond(), equalTo(new SurroundingEdgeWritable(1,4,3,1,140,-1,2)));
+		
+	}
+	
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeSurroundMapReduceAndJoinSurroundingEdgesMapReduceTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeSurroundMapReduceAndJoinSurroundingEdgesMapReduceTest.java
new file mode 100644
index 0000000..1e19fc0
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeSurroundMapReduceAndJoinSurroundingEdgesMapReduceTest.java
@@ -0,0 +1,88 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.AscLongDescLongKeyComparator;
+import nl.waredingen.graphs.neo.mapreduce.AscLongDescLongKeyGroupingComparator;
+import nl.waredingen.graphs.neo.mapreduce.edges.surround.EdgeSurroundMapper;
+import nl.waredingen.graphs.neo.mapreduce.edges.surround.EdgeSurroundReducer;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.DoubleSurroundingEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.MapReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EdgeSurroundMapReduceAndJoinSurroundingEdgesMapReduceTest {
+
+	private MapReduceDriver<NullWritable, SurroundingEdgeWritable, EdgeWritable, SurroundingEdgeWritable, NullWritable, DoubleSurroundingEdgeWritable> driver2;
+	private List<Pair<NullWritable, DoubleSurroundingEdgeWritable>> output2;
+	private MapReduceDriver<NullWritable, NodeEdgeWritable, AscLongDescLongWritable, EdgeWritable, NullWritable, SurroundingEdgeWritable> driver;
+	private List<Pair<NullWritable, SurroundingEdgeWritable>> output;
+
+	@SuppressWarnings("unchecked")
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapReduceDriver<NullWritable, NodeEdgeWritable, AscLongDescLongWritable, EdgeWritable, NullWritable, SurroundingEdgeWritable>(new EdgeSurroundMapper(),new EdgeSurroundReducer());
+		driver.setKeyGroupingComparator(new AscLongDescLongKeyGroupingComparator());
+		driver.setKeyOrderComparator(new AscLongDescLongKeyComparator());
+
+		driver2 = new MapReduceDriver<NullWritable, SurroundingEdgeWritable, EdgeWritable, SurroundingEdgeWritable, NullWritable, DoubleSurroundingEdgeWritable>(new JoinSurroundingEdgesMapper(),new JoinSurroundingEdgesReducer());
+		driver2.setKeyGroupingComparator(new EdgeWritableKeyGroupingComparator());
+		driver2.setKeyOrderComparator(new EdgeWritableKeyComparator());
+	}
+
+	@Test
+	public void shouldjoinFromNodeAndEdge() throws Exception {
+		driver.withInput(NullWritable.get(), new NodeEdgeWritable(0,1,0,0,1,100));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(0,1,2,0,2,120));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(1,3,0,0,1,100));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(1,3,1,1,2,110));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(2,5,1,1,2,110));
+		driver.addInput(NullWritable.get(), new NodeEdgeWritable(2,5,2,0,2,120));
+		output = driver.run();
+
+		assertThat(output.size(), is(6));
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new SurroundingEdgeWritable(0,2,0,2,120,0,-1)));
+		assertThat(output.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(1).getSecond(), equalTo(new SurroundingEdgeWritable(0,0,0,1,100,-1,2)));
+		assertThat(output.get(2).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(2).getSecond(), equalTo(new SurroundingEdgeWritable(1,1,1,2,110,0,-1)));
+		assertThat(output.get(3).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(3).getSecond(), equalTo(new SurroundingEdgeWritable(1,0,0,1,100,-1,1)));
+		assertThat(output.get(4).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(4).getSecond(), equalTo(new SurroundingEdgeWritable(2,2,0,2,120,1,-1)));
+		assertThat(output.get(5).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(5).getSecond(), equalTo(new SurroundingEdgeWritable(2,1,1,2,110,-1,2)));
+
+		driver2.withInput(output.get(0)).withInput(output.get(1)).withInput(output.get(2)).withInput(output.get(3)).withInput(output.get(4)).withInput(output.get(5));
+		output2 = driver2.run();
+
+		assertThat(output2.size(), is(6));
+		assertThat(output2.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output2.get(0).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(0,0,0,1,100,-1,2), new SurroundingEdgeWritable(1,0,0,1,100,-1,1))));
+		assertThat(output2.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output2.get(1).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(1,0,0,1,100,-1,1), new SurroundingEdgeWritable(0,0,0,1,100,-1,2))));
+		assertThat(output2.get(2).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output2.get(2).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(1,1,1,2,110,0,-1), new SurroundingEdgeWritable(2,1,1,2,110,-1,2))));
+		assertThat(output2.get(3).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output2.get(3).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(2,1,1,2,110,-1,2), new SurroundingEdgeWritable(1,1,1,2,110,0,-1))));
+		assertThat(output2.get(4).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output2.get(4).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(0,2,0,2,120,0,-1), new SurroundingEdgeWritable(2,2,0,2,120,1,-1))));
+		assertThat(output2.get(5).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output2.get(5).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(2,2,0,2,120,1,-1), new SurroundingEdgeWritable(0,2,0,2,120,0,-1))));
+	}
+}
+
+
+
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeWritableComparatorTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeWritableComparatorTest.java
new file mode 100644
index 0000000..0274dce
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/EdgeWritableComparatorTest.java
@@ -0,0 +1,93 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround.join;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.mapreduce.Partitioner;
+import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;
+import org.junit.Test;
+
+public class EdgeWritableComparatorTest {
+
+	@Test
+	public void testEdgeWritablesAreEqual() {
+		EdgeWritable e1 = new EdgeWritable(3, 2, 0, 130);
+		EdgeWritable e2 = new EdgeWritable(3, 2, 0, 130);
+		
+		assertTrue(e1.equals(e2));
+		assertEquals(0, e1.compareTo(e2));
+		assertEquals(0, e2.compareTo(e1));
+		assertEquals(0, e1.compareTo(e1));
+		assertEquals(0, e2.compareTo(e2));
+	}
+
+	@Test
+	public void testEdgeWritablesAreEqualInTheKeyGroupingComparator() {
+		EdgeWritable e1 = new EdgeWritable(3, 2, 0, 130);
+		EdgeWritable e2 = new EdgeWritable(3, 2, 0, 130);
+		
+		EdgeWritableKeyGroupingComparator comp = new EdgeWritableKeyGroupingComparator();
+		assertEquals(0, comp.compare(e1, e2));
+		assertEquals(0, comp.compare(e2, e1));
+	}
+	
+	@Test
+	public void testEdgeWritablesAreNotEqualInTheKeyGroupingComparator() {
+		EdgeWritable e1 = new EdgeWritable(3, 2, 0, 130);
+		EdgeWritable e2 = new EdgeWritable(4, 2, 1, 140);
+		
+		EdgeWritableKeyGroupingComparator comp = new EdgeWritableKeyGroupingComparator();
+		assertEquals(-1, comp.compare(e1, e2));
+		assertEquals(1, comp.compare(e2, e1));
+	}
+	
+	@Test
+	public void testEdgeWritablesAreEqualInTheKeySortingComparator() {
+		EdgeWritable e1 = new EdgeWritable(3, 2, 0, 130);
+		EdgeWritable e2 = new EdgeWritable(3, 2, 0, 130);
+		
+		EdgeWritableKeyComparator comp = new EdgeWritableKeyComparator();
+		assertEquals(0, comp.compare(e1, e2));
+		assertEquals(0, comp.compare(e2, e1));
+	}
+	
+	@Test
+	public void testEdgeWritablesAreNotEqualInTheKeySortingComparator() {
+		EdgeWritable e1 = new EdgeWritable(3, 2, 0, 130);
+		EdgeWritable e2 = new EdgeWritable(4, 2, 1, 140);
+		
+		EdgeWritableKeyComparator comp = new EdgeWritableKeyComparator();
+		assertEquals(-1, comp.compare(e1, e2));
+		assertEquals(1, comp.compare(e2, e1));
+	}
+	
+	@Test
+	public void testEdgeWritablesAreNonEqual() {
+		EdgeWritable e1 = new EdgeWritable(3, 2, 0, 130);
+		EdgeWritable e2 = new EdgeWritable(4, 0, 2, 140);
+		
+		assertFalse(e1.equals(e2));
+		assertEquals(-1, e1.compareTo(e2));
+		assertEquals(1, e2.compareTo(e1));
+		assertEquals(0, e1.compareTo(e1));
+		assertEquals(0, e2.compareTo(e2));
+	}
+
+	@Test
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public void testEdgeWritablesAreEquallyPartitioned() {
+		EdgeWritable e1 = new EdgeWritable(3, 2, 0, 130);
+		EdgeWritable e2 = new EdgeWritable(3, 2, 0, 130);
+		
+		Partitioner p = new HashPartitioner<EdgeWritable, SurroundingEdgeWritable>();
+		assertEquals(p.getPartition(e1, new SurroundingEdgeWritable(), 50), p.getPartition(e2, new SurroundingEdgeWritable(), 50));
+		assertEquals(p.getPartition(e1, new SurroundingEdgeWritable(), 100), p.getPartition(e2, new SurroundingEdgeWritable(), 100));
+		assertEquals(p.getPartition(e1, new SurroundingEdgeWritable(), 5), p.getPartition(e2, new SurroundingEdgeWritable(), 5));
+		assertEquals(p.getPartition(e1, new SurroundingEdgeWritable(), 1), p.getPartition(e2, new SurroundingEdgeWritable(), 1));
+		assertEquals(p.getPartition(e1, new SurroundingEdgeWritable(0,3,2,0,130,-1,2), 50), p.getPartition(e2, new SurroundingEdgeWritable(2,3,2,0,130,-1,2), 50));
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesMapReduceTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesMapReduceTest.java
new file mode 100644
index 0000000..1465d91
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesMapReduceTest.java
@@ -0,0 +1,56 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.DoubleSurroundingEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.MapReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JoinSurroundingEdgesMapReduceTest {
+
+	private MapReduceDriver<NullWritable, SurroundingEdgeWritable, EdgeWritable, SurroundingEdgeWritable, NullWritable, DoubleSurroundingEdgeWritable> driver;
+	private List<Pair<NullWritable, DoubleSurroundingEdgeWritable>> output;
+
+	@SuppressWarnings("unchecked")
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapReduceDriver<NullWritable, SurroundingEdgeWritable, EdgeWritable, SurroundingEdgeWritable, NullWritable, DoubleSurroundingEdgeWritable>(new JoinSurroundingEdgesMapper(),new JoinSurroundingEdgesReducer());
+		driver.setKeyGroupingComparator(new EdgeWritableKeyGroupingComparator());
+		driver.setKeyOrderComparator(new EdgeWritableKeyComparator());
+	}
+
+	@Test
+	public void shouldjoinFromNodeAndEdge() throws Exception {
+		driver.withInput(NullWritable.get(), new SurroundingEdgeWritable(0,2,0,2,120,0,-1));
+		driver.addInput(NullWritable.get(), new SurroundingEdgeWritable(0,0,0,1,100,-1,2));
+		driver.addInput(NullWritable.get(), new SurroundingEdgeWritable(1,1,1,2,110,0,-1));
+		driver.addInput(NullWritable.get(), new SurroundingEdgeWritable(1,0,0,1,100,-1,1));
+		driver.addInput(NullWritable.get(), new SurroundingEdgeWritable(2,2,0,2,120,1,-1));
+		driver.addInput(NullWritable.get(), new SurroundingEdgeWritable(2,1,1,2,110,-1,2));
+		output = driver.run();
+
+		assertThat(output.size(), is(6));
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(0,0,0,1,100,-1,2), new SurroundingEdgeWritable(1,0,0,1,100,-1,1))));
+		assertThat(output.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(1).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(1,0,0,1,100,-1,1), new SurroundingEdgeWritable(0,0,0,1,100,-1,2))));
+		assertThat(output.get(2).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(2).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(1,1,1,2,110,0,-1), new SurroundingEdgeWritable(2,1,1,2,110,-1,2))));
+		assertThat(output.get(3).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(3).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(2,1,1,2,110,-1,2), new SurroundingEdgeWritable(1,1,1,2,110,0,-1))));
+		assertThat(output.get(4).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(4).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(0,2,0,2,120,0,-1), new SurroundingEdgeWritable(2,2,0,2,120,1,-1))));
+		assertThat(output.get(5).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(5).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(2,2,0,2,120,1,-1), new SurroundingEdgeWritable(0,2,0,2,120,0,-1))));
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesMapperTest.java
new file mode 100644
index 0000000..3721371
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesMapperTest.java
@@ -0,0 +1,47 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JoinSurroundingEdgesMapperTest {
+	private MapDriver<NullWritable, SurroundingEdgeWritable, EdgeWritable, SurroundingEdgeWritable> driver;
+	private List<Pair<EdgeWritable, SurroundingEdgeWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<NullWritable, SurroundingEdgeWritable, EdgeWritable, SurroundingEdgeWritable>(new JoinSurroundingEdgesMapper());
+	}
+
+	@Test
+	public void shouldOutputAsJoin() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new SurroundingEdgeWritable(0,3,2,0,130,-1,2)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new EdgeWritable(3,2,0,130)));
+		assertThat(output.get(0).getSecond(), equalTo(new SurroundingEdgeWritable(0,3,2,0,130,-1,2)));
+	}
+
+	@Test
+	public void shouldOutputAsJoinForOtherNode() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new SurroundingEdgeWritable(2,3,2,0,130,1,-1)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new EdgeWritable(3,2,0,130)));
+		assertThat(output.get(0).getSecond(), equalTo(new SurroundingEdgeWritable(2,3,2,0,130,1,-1)));
+	}
+	
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesReducerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesReducerTest.java
new file mode 100644
index 0000000..6c00233
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/edges/surround/join/JoinSurroundingEdgesReducerTest.java
@@ -0,0 +1,45 @@
+package nl.waredingen.graphs.neo.mapreduce.edges.surround.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.DoubleSurroundingEdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.SurroundingEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JoinSurroundingEdgesReducerTest {
+	private ReduceDriver<EdgeWritable, SurroundingEdgeWritable, NullWritable, DoubleSurroundingEdgeWritable> driver;
+	private List<Pair<NullWritable, DoubleSurroundingEdgeWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new ReduceDriver<EdgeWritable, SurroundingEdgeWritable, NullWritable, DoubleSurroundingEdgeWritable>(new JoinSurroundingEdgesReducer());
+	}
+
+	@Test
+	public void shouldOutputAsJoinedSurroundingEdges() throws Exception {
+		ArrayList<SurroundingEdgeWritable> values = new ArrayList<SurroundingEdgeWritable>();
+		values.add(new SurroundingEdgeWritable(0,2,0,2,120,3,0));
+		values.add(new SurroundingEdgeWritable(2,2,0,2,120,3,1));
+		output = driver.withInputKey(new EdgeWritable(2,0,2,120)).withInputValues(values).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(0,2,0,2,120,3,0), new SurroundingEdgeWritable(2,2,0,2,120,3,1))));
+		assertThat(output.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(1).getSecond(), equalTo(new DoubleSurroundingEdgeWritable(new SurroundingEdgeWritable(2,2,0,2,120,3,1),new SurroundingEdgeWritable(0,2,0,2,120,3,0))));
+
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesMapReduceTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesMapReduceTest.java
new file mode 100644
index 0000000..89cc93b
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesMapReduceTest.java
@@ -0,0 +1,77 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaDataFromConfigImpl;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.mapreduce.MapReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class GroupNodesAndEdgesMapReduceTest {
+	private MapReduceDriver<NullWritable, Text, NodeEdgeIdWritable, EdgeWritable, NullWritable, NodeEdgeWritable> driver;
+	private List<Pair<NullWritable, NodeEdgeWritable>> output;
+
+	@SuppressWarnings("unchecked")
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapReduceDriver<NullWritable, Text, NodeEdgeIdWritable, EdgeWritable, NullWritable, NodeEdgeWritable>(new GroupNodesAndEdgesMapper(), new GroupNodesAndEdgesReducer());
+		driver.setKeyGroupingComparator(new NodeAndEdgeIdKeyGroupingComparator());
+		driver.setKeyOrderComparator(new NodeAndEdgeIdKeyComparator());
+	}
+
+	@Test
+	public void shouldOutputWithFromAndToNode() throws Exception {
+		output = driver.withInput(NullWritable.get(), new Text("0	A	B	5	0	1	1	3")).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new NodeEdgeWritable(0,1,0,0,1,5)));
+
+		assertThat(output.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(1).getSecond(), equalTo(new NodeEdgeWritable(1,3,0,0,1,5)));
+
+	}
+	
+	@Test
+	public void shouldOutputWithSomeExtraEdgeProperties() throws Exception {
+		Configuration config = new Configuration();
+		config.setClass(AbstractMetaData.METADATA_CLASS, MetaDataFromConfigImpl.class, MetaData.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_NAMES, "identifier", "name");
+		config.set(MetaDataFromConfigImpl.METADATA_NODE_ID_NAME, "identifier");
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX +"identifier", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX +"name", String.class, Object.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_NAMES, "from", "to", "prop1", "prop2");
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX +"from", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX +"to", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX +"prop1", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX +"prop2", String.class, Object.class);
+		driver.setConfiguration(config);
+
+		output = driver.withInput(NullWritable.get(), new Text("0	A	B	5	0	1	1	3")).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new NodeEdgeWritable(0,1,0,0,1,5)));
+
+		assertThat(output.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(1).getSecond(), equalTo(new NodeEdgeWritable(1,3,0,0,1,5)));
+
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesMapperTest.java
new file mode 100644
index 0000000..e8aab5c
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesMapperTest.java
@@ -0,0 +1,120 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaDataFromConfigImpl;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class GroupNodesAndEdgesMapperTest {
+	private MapDriver<NullWritable, Text, NodeEdgeIdWritable, EdgeWritable> driver;
+	private List<Pair<NodeEdgeIdWritable, EdgeWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<NullWritable, Text, NodeEdgeIdWritable, EdgeWritable>(new GroupNodesAndEdgesMapper());
+	}
+
+	@Test
+	public void shouldOutputWithFromAndToNode() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new Text("0	A	B	5	0	1	1	3")).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(new NodeEdgeIdWritable(0,1,0)));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeWritable(0,0,1,5)));
+
+		assertThat(output.get(1).getFirst(), equalTo(new NodeEdgeIdWritable(1,3,0)));
+		assertThat(output.get(1).getSecond(), equalTo(new EdgeWritable(0,0,1,5)));
+
+	}
+
+	@Test
+	public void shouldOutputWithFromAndToNodeAndSomeEdgeProperties() throws Exception {
+		Configuration config = new Configuration();
+		config.setClass(AbstractMetaData.METADATA_CLASS, MetaDataFromConfigImpl.class, MetaData.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_NAMES, "identifier", "name");
+		config.set(MetaDataFromConfigImpl.METADATA_NODE_ID_NAME, "identifier");
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "identifier", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "name", String.class, Object.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_NAMES, "from", "to", "prop1", "prop2");
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "from", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "to", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "prop1", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "prop2", String.class, Object.class);
+		driver.setConfiguration(config);
+		
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new Text("0	A	B	5	0	1	1	3")).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(new NodeEdgeIdWritable(0,1,0)));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeWritable(0,0,1,5)));
+
+		assertThat(output.get(1).getFirst(), equalTo(new NodeEdgeIdWritable(1,3,0)));
+		assertThat(output.get(1).getSecond(), equalTo(new EdgeWritable(0,0,1,5)));
+
+	}
+
+	/*
+	 * RA 3 C A 2 C Cname 0 A Aname RB 0 A B 0 A Aname 1 B Bname RC 2 A C 0 A
+	 * Aname 2 C Cname RC 1 B C 1 B Bname 2 C Cname
+	 */
+
+	@Test
+	public void shouldOutputForMultipleInputs() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new Text("3	C	A	5	2	1	0	3")).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(new NodeEdgeIdWritable(2,1,3)));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeWritable(3,2,0,5)));
+
+		assertThat(output.get(1).getFirst(), equalTo(new NodeEdgeIdWritable(0,3,3)));
+		assertThat(output.get(1).getSecond(), equalTo(new EdgeWritable(3,2,0,5)));
+
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new Text("0	A	B	5	0	1	1	3")).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(new NodeEdgeIdWritable(0,1,0)));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeWritable(0,0,1,5)));
+
+		assertThat(output.get(1).getFirst(), equalTo(new NodeEdgeIdWritable(1,3,0)));
+		assertThat(output.get(1).getSecond(), equalTo(new EdgeWritable(0,0,1,5)));
+
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new Text("2	A	C	5	0	1	2	3")).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(new NodeEdgeIdWritable(0,1,2)));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeWritable(2,0,2,5)));
+
+		assertThat(output.get(1).getFirst(), equalTo(new NodeEdgeIdWritable(2,3,2)));
+		assertThat(output.get(1).getSecond(), equalTo(new EdgeWritable(2,0,2,5)));
+
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new Text("1	B	C	5	1	2	2	3")).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(new NodeEdgeIdWritable(1,2,1)));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeWritable(1,1,2,5)));
+
+		assertThat(output.get(1).getFirst(), equalTo(new NodeEdgeIdWritable(2,3,1)));
+		assertThat(output.get(1).getSecond(), equalTo(new EdgeWritable(1,1,2,5)));
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesReducerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesReducerTest.java
new file mode 100644
index 0000000..dc30d57
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/GroupNodesAndEdgesReducerTest.java
@@ -0,0 +1,38 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class GroupNodesAndEdgesReducerTest {
+	private ReduceDriver<NodeEdgeIdWritable, EdgeWritable, NullWritable, NodeEdgeWritable> driver;
+	private List<Pair<NullWritable, NodeEdgeWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new ReduceDriver<NodeEdgeIdWritable, EdgeWritable, NullWritable, NodeEdgeWritable>(new GroupNodesAndEdgesReducer());
+	}
+
+	@Test
+	public void shouldOutputAsIs() throws Exception {
+		output = driver.withInputKey(new NodeEdgeIdWritable(0,1,0)).withInputValue(new EdgeWritable(0,0,1,5)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new NodeEdgeWritable(0, 1,0,0,1,5)));
+
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyComparatorTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyComparatorTest.java
new file mode 100644
index 0000000..3b1b71b
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyComparatorTest.java
@@ -0,0 +1,32 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+
+import org.junit.Test;
+
+public class NodeAndEdgeIdKeyComparatorTest {
+
+	@Test
+	public void shouldSortNodeKeysOnEdgeIdAscKey() {
+		NodeEdgeIdWritable firstKey = new NodeEdgeIdWritable(0,1,0);
+		NodeEdgeIdWritable secondKey = new NodeEdgeIdWritable(0,1,1);
+		
+		NodeAndEdgeIdKeyComparator comp = new NodeAndEdgeIdKeyComparator();
+
+		assertThat(comp.compare(firstKey, secondKey), is(-1));
+	}
+
+
+	@Test
+	public void shouldSortNodeKeysOnKeyIfDifferent() {
+		NodeEdgeIdWritable firstKey = new NodeEdgeIdWritable(0,1,0);
+		NodeEdgeIdWritable secondKey = new NodeEdgeIdWritable(1,1,1);
+		
+		NodeAndEdgeIdKeyComparator comp = new NodeAndEdgeIdKeyComparator();
+
+		assertThat(comp.compare(firstKey, secondKey), is(-1));
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyGroupingComparatorTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyGroupingComparatorTest.java
new file mode 100644
index 0000000..44bfb28
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyGroupingComparatorTest.java
@@ -0,0 +1,22 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+
+import org.junit.Test;
+
+public class NodeAndEdgeIdKeyGroupingComparatorTest {
+
+	@Test
+	public void shouldEqualNodeKeyAndEdgeKey() {
+		NodeEdgeIdWritable firstKey = new NodeEdgeIdWritable(0,1,0);
+		NodeEdgeIdWritable secondKey = new NodeEdgeIdWritable(0,1,1);
+		
+		NodeAndEdgeIdKeyGroupingComparator comp = new NodeAndEdgeIdKeyGroupingComparator();
+
+		assertThat(comp.compare(firstKey, secondKey), is(0));
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyPartitionerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyPartitionerTest.java
new file mode 100644
index 0000000..6b171ce
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/group/NodeAndEdgeIdKeyPartitionerTest.java
@@ -0,0 +1,37 @@
+package nl.waredingen.graphs.neo.mapreduce.group;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeIdWritable;
+
+import org.junit.Test;
+
+public class NodeAndEdgeIdKeyPartitionerTest {
+
+	@Test
+	public void testSamePartitionForNodeAndEdgeIdKey() {
+		NodeEdgeIdWritable firstKey = new NodeEdgeIdWritable(0,1,0);
+		NodeEdgeIdWritable secondKey = new NodeEdgeIdWritable(0,1,1);
+		
+		NodeAndEdgeIdKeyPartitioner partitioner = new NodeAndEdgeIdKeyPartitioner();
+		
+		assertThat(partitioner.getPartition(firstKey, new EdgeWritable(), 2), is(partitioner.getPartition(secondKey, new EdgeWritable(), 2)));
+		assertThat(partitioner.getPartition(firstKey, new EdgeWritable(), 50), is(partitioner.getPartition(secondKey, new EdgeWritable(), 50)));
+
+	}
+
+	@Test
+	public void testNonNegativePartitionForNodeAndEdgeKey() {
+		NodeEdgeIdWritable nodeKey = new NodeEdgeIdWritable(3663243826L,1,1);
+
+		NodeAndEdgeIdKeyPartitioner partitioner = new NodeAndEdgeIdKeyPartitioner();
+		
+		assertTrue(partitioner.getPartition(nodeKey, new EdgeWritable(), 50) >= 0);
+
+	}
+	
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/input/InputTypeConversionTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/input/InputTypeConversionTest.java
new file mode 100644
index 0000000..80647a2
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/input/InputTypeConversionTest.java
@@ -0,0 +1,52 @@
+package nl.waredingen.graphs.neo.mapreduce.input;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Scanner;
+
+import org.junit.Test;
+
+public class InputTypeConversionTest {
+
+	private Scanner getScanner(String s) {
+		Scanner scanner = new Scanner(s);
+		scanner.useDelimiter("\t");
+		scanner.useRadix(10);
+		
+		return scanner;
+	}
+	
+	@Test
+	public void testScanning() {
+		Scanner scanner = getScanner("This\tis\ta\ttest\twith\t12\t129\t260\t"+(Integer.MAX_VALUE - 3)+"\t"+(Long.MAX_VALUE - 3)+"\tand some extra fields:\teen\t\t\tvier\t\ttrue\tfalse");
+		while(scanner.hasNext()) {
+//			System.out.println(scanner.next());
+			if (scanner.hasNextByte()) {
+				System.out.println("Byte : "+scanner.nextByte());
+			}
+			else if (scanner.hasNextShort()) {
+				System.out.println("Short : "+scanner.nextShort());
+			}
+			else if (scanner.hasNextInt()) {
+				System.out.println("Int : "+scanner.nextInt());
+			}
+			else if (scanner.hasNextLong()) {
+				System.out.println("Long : "+scanner.nextLong());
+			}
+			else if (scanner.hasNextFloat()) {
+				System.out.println("Float : "+scanner.nextFloat());
+			}
+			else if (scanner.hasNextDouble()) {
+				System.out.println("Double : "+scanner.nextDouble());
+			}
+			else if (scanner.hasNextBoolean()) {
+				System.out.println("Boolean : "+scanner.nextBoolean());
+			}
+			else {
+				System.out.println("String : "+scanner.next());
+			}
+		}
+		assertEquals("Testing 123", "Testing 123");
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/input/MetaDataTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/input/MetaDataTest.java
new file mode 100644
index 0000000..ea6ac26
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/input/MetaDataTest.java
@@ -0,0 +1,134 @@
+package nl.waredingen.graphs.neo.mapreduce.input;
+
+import static org.junit.Assert.*;
+
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.conf.Configuration;
+import org.junit.Before;
+import org.junit.Test;
+
+public class MetaDataTest {
+
+	private Configuration config;
+	
+	@Before
+	public void setup() {
+		config = new Configuration();
+	}
+	
+	@Test
+	public void testHardCodedMetaData() {
+			config.setClass(AbstractMetaData.METADATA_CLASS, HardCodedMetaDataImpl.class, MetaData.class);
+			MetaData md = Neo4JUtils.getMetaData(config);
+			
+			assertEquals(0, md.getNumberOfNodes());
+			assertEquals(0, md.getNumberOfEdges());
+			assertEquals(2, md.getNodePropertySize());
+			assertEquals(0, md.getNodeIdIndex());
+			assertArrayEquals(new String[] {"identifier", "name"}, md.getNodePropertyNames());
+			assertEquals(1, md.getNodePropertyIndexForName("name"));
+			assertEquals(-1, md.getNodePropertyIndexForName("unknown"));
+			assertEquals(2, md.getEdgePropertySize());
+			assertEquals(0, md.getEdgeFromNodeIdIndex());
+			assertEquals(1, md.getEdgeToNodeIdIndex());
+			assertArrayEquals(new String[] { "from", "to" }, md.getEdgePropertyNames());
+			assertEquals(-1, md.getEdgePropertyIndexForName("unknown"));
+			assertEquals(Long.class, md.getNodePropertyTypeForName("identifier"));
+			assertEquals(String.class, md.getNodePropertyTypeForName("name"));
+			assertEquals(Long.class, md.getEdgePropertyTypeForName("from"));
+			assertEquals(Long.class, md.getEdgePropertyTypeForName("to"));
+
+	}
+
+	@Test
+	public void testHardCodedMetaDataWithNodesCountAndEdgesCountFromConfig() {
+			config.setClass(AbstractMetaData.METADATA_CLASS, HardCodedMetaDataImpl.class, MetaData.class);
+			config.setLong(AbstractMetaData.METADATA_NUMBER_OF_NODES, 42L);
+			config.setLong(AbstractMetaData.METADATA_NUMBER_OF_EDGES, 4242L);
+
+			MetaData md = Neo4JUtils.getMetaData(config);
+			
+			assertEquals(42, md.getNumberOfNodes());
+			assertEquals(4242, md.getNumberOfEdges());
+			assertEquals(2, md.getNodePropertySize());
+			assertEquals(0, md.getNodeIdIndex());
+			assertArrayEquals(new String[] {"identifier", "name"}, md.getNodePropertyNames());
+			assertEquals(1, md.getNodePropertyIndexForName("name"));
+			assertEquals(-1, md.getNodePropertyIndexForName("unknown"));
+			assertEquals(2, md.getEdgePropertySize());
+			assertEquals(0, md.getEdgeFromNodeIdIndex());
+			assertEquals(1, md.getEdgeToNodeIdIndex());
+			assertArrayEquals(new String[] { "from", "to" }, md.getEdgePropertyNames());
+			assertEquals(-1, md.getEdgePropertyIndexForName("unknown"));
+			assertEquals(Long.class, md.getNodePropertyTypeForName("identifier"));
+			assertEquals(String.class, md.getNodePropertyTypeForName("name"));
+			assertEquals(Long.class, md.getEdgePropertyTypeForName("from"));
+			assertEquals(Long.class, md.getEdgePropertyTypeForName("to"));
+
+	}
+
+	@Test
+	public void testHardCodedMetaDataIsTheDefault() {
+		MetaData md = Neo4JUtils.getMetaData(config);
+		
+		assertEquals(0, md.getNumberOfNodes());
+		assertEquals(0, md.getNumberOfEdges());
+		assertEquals(2, md.getNodePropertySize());
+		assertEquals(0, md.getNodeIdIndex());
+		assertArrayEquals(new String[] {"identifier", "name"}, md.getNodePropertyNames());
+		assertEquals(1, md.getNodePropertyIndexForName("name"));
+		assertEquals(-1, md.getNodePropertyIndexForName("unknown"));
+		assertEquals(2, md.getEdgePropertySize());
+		assertEquals(0, md.getEdgeFromNodeIdIndex());
+		assertEquals(1, md.getEdgeToNodeIdIndex());
+		assertArrayEquals(new String[] { "from", "to" }, md.getEdgePropertyNames());
+		assertEquals(-1, md.getEdgePropertyIndexForName("unknown"));
+		assertEquals(Long.class, md.getNodePropertyTypeForName("identifier"));
+		assertEquals(String.class, md.getNodePropertyTypeForName("name"));
+		assertEquals(Long.class, md.getEdgePropertyTypeForName("from"));
+		assertEquals(Long.class, md.getEdgePropertyTypeForName("to"));
+		
+	}
+	
+	@Test
+	public void testConfigPopulatedMetaData() {
+		populateConfigWithMetaData();
+
+		MetaData md = Neo4JUtils.getMetaData(config);
+		
+		assertEquals(42, md.getNumberOfNodes());
+		assertEquals(4242, md.getNumberOfEdges());
+		assertEquals(3, md.getNodePropertySize());
+		assertEquals(0, md.getNodeIdIndex());
+		assertArrayEquals(new String[] {"id", "name", "accountnumber"}, md.getNodePropertyNames());
+		assertEquals(1, md.getNodePropertyIndexForName("name"));
+		assertEquals(-1, md.getNodePropertyIndexForName("unknown"));
+		assertEquals(3, md.getEdgePropertySize());
+		assertEquals(0, md.getEdgeFromNodeIdIndex());
+		assertEquals(1, md.getEdgeToNodeIdIndex());
+		assertEquals(2, md.getEdgePropertyIndexForName("amount"));
+		assertArrayEquals(new String[] { "from", "to", "amount" }, md.getEdgePropertyNames());
+		assertEquals(-1, md.getEdgePropertyIndexForName("unknown"));
+		assertEquals(Long.class, md.getNodePropertyTypeForName("id"));
+		assertEquals(String.class, md.getNodePropertyTypeForName("name"));
+		assertEquals(Integer.class, md.getEdgePropertyTypeForName("amount"));
+		
+	}
+
+	private void populateConfigWithMetaData() {
+		config.setClass(AbstractMetaData.METADATA_CLASS, MetaDataFromConfigImpl.class, MetaData.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_NAMES, "id", "name", "accountnumber");
+		config.set(MetaDataFromConfigImpl.METADATA_NODE_ID_NAME, "id");
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "id", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "name", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "accountnumber", Integer.class, Object.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_NAMES, "from", "to", "amount");
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "id", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "name", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "amount", Integer.class, Object.class);
+		config.setLong(AbstractMetaData.METADATA_NUMBER_OF_NODES, 42L);
+		config.setLong(AbstractMetaData.METADATA_NUMBER_OF_EDGES, 4242L);
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinFromEdgesMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinFromEdgesMapperTest.java
new file mode 100644
index 0000000..2c7cc2f
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinFromEdgesMapperTest.java
@@ -0,0 +1,39 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JoinFromEdgesMapperTest {
+	private MapDriver<NullWritable, BytesWritable, Text, Text> driver;
+	private List<Pair<Text, Text>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<NullWritable, BytesWritable, Text, Text>(new JoinFromEdgesMapper());
+	}
+
+	@Test
+	public void shouldOutputAsFromNode() throws Exception {
+		Text val = new Text("0	A	B	100");
+		BytesWritable bv = new BytesWritable(val.getBytes());
+		output = driver.withInputKey(NullWritable.get()).withInputValue(bv).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new Text("EA")));
+		assertThat(output.get(0).getSecond(), equalTo(new Text("0	A	B	100")));
+
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinFromNodesAndEdgesMapReduceTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinFromNodesAndEdgesMapReduceTest.java
new file mode 100644
index 0000000..fbcc221
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinFromNodesAndEdgesMapReduceTest.java
@@ -0,0 +1,49 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.DualInputMapReduceDriver;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JoinFromNodesAndEdgesMapReduceTest {
+
+	private DualInputMapReduceDriver<NullWritable,BytesWritable,NullWritable,BytesWritable,Text,Text,NullWritable,Text> driver;
+	private List<Pair<NullWritable, Text>> output;
+
+	@SuppressWarnings("unchecked")
+	@Before
+	public void setUp() throws Exception {
+		driver = new DualInputMapReduceDriver<NullWritable,BytesWritable,NullWritable,BytesWritable, Text, Text, NullWritable, Text>();
+		driver.setFirstMapper(new JoinNodesMapper());
+		driver.setSecondMapper(new JoinFromEdgesMapper());
+		driver.setReducer(new JoinNodesAndEdgesReducer());
+		driver.setKeyGroupingComparator(new NodeKeyGroupingComparator());
+		driver.setKeyOrderComparator(new NodeAndEdgeKeyComparator());
+	}
+
+	@Test
+	public void shouldjoinFromNodeAndEdge() throws Exception {
+		Text nodeA = new Text("0	A	1");
+		BytesWritable nodeAInput = new BytesWritable(nodeA.getBytes());
+		Text nodeB = new Text("1	B	3");
+		BytesWritable nodeBInput = new BytesWritable(nodeB.getBytes());
+		Text edge = new Text("0	A	B	5");
+		BytesWritable edgeInput = new BytesWritable(edge.getBytes());
+		driver.withFirstInput(NullWritable.get(), nodeAInput).addInput(NullWritable.get(), nodeBInput);
+		output = driver.withSecondInput(NullWritable.get(), edgeInput).run();
+
+		assertThat(output.size(), is(1));
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new Text("0	A	B	5	0	1")));
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesAndEdgesReducerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesAndEdgesReducerTest.java
new file mode 100644
index 0000000..1931656
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesAndEdgesReducerTest.java
@@ -0,0 +1,39 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JoinNodesAndEdgesReducerTest {
+	private ReduceDriver<Text, Text, NullWritable, Text> driver;
+	private List<Pair<NullWritable, Text>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new ReduceDriver<Text, Text, NullWritable, Text>(new JoinNodesAndEdgesReducer());
+	}
+
+	@Test
+	public void shouldOutputAsNode() throws Exception {
+		ArrayList<Text> values = new ArrayList<Text>();
+		values.add(new Text("0"));
+		values.add(new Text("0	A	B"));
+		output = driver.withInputKey(new Text("NA")).withInputValues(values).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new Text("0	A	B	0")));
+
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesMapperTest.java
new file mode 100644
index 0000000..b0d2eff
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinNodesMapperTest.java
@@ -0,0 +1,38 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JoinNodesMapperTest {
+	private MapDriver<NullWritable, BytesWritable, Text, Text> driver;
+	private List<Pair<Text, Text>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<NullWritable, BytesWritable, Text, Text>(new JoinNodesMapper());
+	}
+
+	@Test
+	public void shouldOutputAsNodeIndex() throws Exception {
+		Text val = new Text("0	A	1");
+		BytesWritable bv = new BytesWritable(val.getBytes());
+		output = driver.withInputKey(NullWritable.get()).withInputValue(bv).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new Text("NA")));
+		assertThat(output.get(0).getSecond(), equalTo(new Text("0	1")));
+
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinToEdgesMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinToEdgesMapperTest.java
new file mode 100644
index 0000000..ac83575
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinToEdgesMapperTest.java
@@ -0,0 +1,35 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JoinToEdgesMapperTest {
+	private MapDriver<NullWritable, Text, Text, Text> driver;
+	private List<Pair<Text, Text>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<NullWritable, Text, Text, Text>(new JoinToEdgesMapper());
+	}
+
+	@Test
+	public void shouldOutputAsToNode() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new Text("0	A	B	0	1")).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new Text("EB")));
+		assertThat(output.get(0).getSecond(), equalTo(new Text("0	A	B	0	1")));
+
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinToNodesAndEdgesMapReduceTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinToNodesAndEdgesMapReduceTest.java
new file mode 100644
index 0000000..0318bb0
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/JoinToNodesAndEdgesMapReduceTest.java
@@ -0,0 +1,49 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.DualInputMapReduceDriver;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JoinToNodesAndEdgesMapReduceTest {
+
+	private DualInputMapReduceDriver<NullWritable,BytesWritable,NullWritable,Text,Text,Text,NullWritable,Text> driver;
+	private List<Pair<NullWritable, Text>> output;
+
+	@SuppressWarnings("unchecked")
+	@Before
+	public void setUp() throws Exception {
+		driver = new DualInputMapReduceDriver<NullWritable, BytesWritable, NullWritable, Text, Text, Text, NullWritable, Text>();
+		driver.setFirstMapper(new JoinNodesMapper());
+		driver.setSecondMapper(new JoinToEdgesMapper());
+		driver.setReducer(new JoinNodesAndEdgesReducer());
+		driver.setKeyGroupingComparator(new NodeKeyGroupingComparator());
+		driver.setKeyOrderComparator(new NodeAndEdgeKeyComparator());
+	}
+
+	@Test
+	public void shouldjoinToNodeAndEdgeWithFromNode() throws Exception {
+		Text nodeA = new Text("0	A	1");
+		BytesWritable nodeAInput = new BytesWritable(nodeA.getBytes());
+		Text nodeB = new Text("1	B	3");
+		BytesWritable nodeBInput = new BytesWritable(nodeB.getBytes());
+		Text edgeWithFromNodeJoined = new Text("0	A	B	5	0	1");
+
+		driver.withFirstInput(NullWritable.get(), nodeAInput).addInput(NullWritable.get(), nodeBInput);
+		output = driver.withSecondInput(NullWritable.get(), edgeWithFromNodeJoined).run();
+
+		assertThat(output.size(), is(1));
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new Text("0	A	B	5	0	1	1	3")));
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyComparatorTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyComparatorTest.java
new file mode 100644
index 0000000..93e5e0f
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyComparatorTest.java
@@ -0,0 +1,31 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.*;
+
+import org.apache.hadoop.io.Text;
+import org.junit.Test;
+
+public class NodeAndEdgeKeyComparatorTest {
+
+	@Test
+	public void shouldSortNodeKeyBeforeEdgeKey() {
+		Text nodeKey = new Text("NA");
+		Text edgeKey = new Text("EA");
+		
+		NodeAndEdgeKeyComparator comp = new NodeAndEdgeKeyComparator();
+
+		assertThat(comp.compare(nodeKey, edgeKey), is(-9));
+	}
+
+	@Test
+	public void shouldSortUnorderedNodeKeyBeforeEdgeKey() {
+		Text nodeKey = new Text("NA");
+		Text edgeKey = new Text("EA");
+		
+		NodeAndEdgeKeyComparator comp = new NodeAndEdgeKeyComparator();
+
+		assertThat(comp.compare(edgeKey, nodeKey), is(9));
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyPartitionerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyPartitionerTest.java
new file mode 100644
index 0000000..edb362f
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/NodeAndEdgeKeyPartitionerTest.java
@@ -0,0 +1,34 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.*;
+
+import org.apache.hadoop.io.Text;
+import org.junit.Test;
+
+public class NodeAndEdgeKeyPartitionerTest {
+
+	@Test
+	public void testSamePartitionForNodeAndEdgeKey() {
+		Text nodeKey = new Text("NA");
+		Text edgeKey = new Text("EA");
+		
+		NodeAndEdgeKeyPartitioner partitioner = new NodeAndEdgeKeyPartitioner();
+		
+		assertThat(partitioner.getPartition(nodeKey, new Text(), 2), is(partitioner.getPartition(edgeKey, new Text(), 2)));
+		assertThat(partitioner.getPartition(nodeKey, new Text(), 50), is(partitioner.getPartition(edgeKey, new Text(), 50)));
+
+	}
+
+	@Test
+	public void testNonNegativePartitionForNodeAndEdgeKey() {
+		Text nodeKey = new Text("N3663243826");
+
+		NodeAndEdgeKeyPartitioner partitioner = new NodeAndEdgeKeyPartitioner();
+		
+		assertTrue(partitioner.getPartition(nodeKey, new Text(), 50) >= 0);
+
+	}
+	
+	
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/NodeKeyGroupingComparatorTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/NodeKeyGroupingComparatorTest.java
new file mode 100644
index 0000000..764f770
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/join/NodeKeyGroupingComparatorTest.java
@@ -0,0 +1,31 @@
+package nl.waredingen.graphs.neo.mapreduce.join;
+
+import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.*;
+
+import org.apache.hadoop.io.Text;
+import org.junit.Test;
+
+public class NodeKeyGroupingComparatorTest {
+
+	@Test
+	public void shouldEqualNodeKeyAndEdgeKey() {
+		Text nodeKey = new Text("NA");
+		Text edgeKey = new Text("EA");
+		
+		NodeKeyGroupingComparator comp = new NodeKeyGroupingComparator();
+
+		assertThat(comp.compare(nodeKey, edgeKey), is(0));
+	}
+
+	@Test
+	public void shouldEqualNodeKeyAndEdgeKeyInUnorderedWay() {
+		Text nodeKey = new Text("NA");
+		Text edgeKey = new Text("EA");
+		
+		NodeKeyGroupingComparator comp = new NodeKeyGroupingComparator();
+
+		assertThat(comp.compare(edgeKey, nodeKey), is(0));
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputMapperTest.java
new file mode 100644
index 0000000..75c238b
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputMapperTest.java
@@ -0,0 +1,49 @@
+package nl.waredingen.graphs.neo.mapreduce.nodes;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodeEdgeWritable;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NodeOutputMapperTest {
+	private MapDriver<NullWritable, NodeEdgeWritable, LongWritable, EdgeIdPropIdWritable> driver;
+	private List<Pair<LongWritable, EdgeIdPropIdWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<NullWritable, NodeEdgeWritable, LongWritable, EdgeIdPropIdWritable>(new NodeOutputMapper());
+	}
+
+	@Test
+	public void shouldOutputAsNode() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new NodeEdgeWritable(0,1,3,2,0,5)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new LongWritable(0)));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeIdPropIdWritable(3,1)));
+
+	}
+
+	@Test
+	public void shouldOutputAsNodeWhereNodeIdIsTheKey() throws Exception {
+		output = driver.withInputKey(NullWritable.get()).withInputValue(new NodeEdgeWritable(11,21,3,2,0,5)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(new LongWritable(11)));
+		assertThat(output.get(0).getSecond(), equalTo(new EdgeIdPropIdWritable(3,21)));
+
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputReducerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputReducerTest.java
new file mode 100644
index 0000000..b30f090
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/nodes/NodeOutputReducerTest.java
@@ -0,0 +1,53 @@
+package nl.waredingen.graphs.neo.mapreduce.nodes;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgeIdPropIdWritable;
+import nl.waredingen.graphs.neo.neo4j.Neo4JUtils;
+
+import org.apache.hadoop.io.BytesWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.NullWritable;
+import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NodeOutputReducerTest {
+	private ReduceDriver<LongWritable, EdgeIdPropIdWritable, NullWritable, BytesWritable> driver;
+	private List<Pair<NullWritable, BytesWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new ReduceDriver<LongWritable, EdgeIdPropIdWritable, NullWritable, BytesWritable>(new NodeOutputReducer());
+	}
+
+	@Test
+	public void shouldOutputAsSomeNode() throws Exception {
+		output = driver.withInputKey(new LongWritable(1)).withInputValue(new EdgeIdPropIdWritable(3,0)).run();
+
+		assertThat(output.size(), is(1));
+
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new BytesWritable(Neo4JUtils.getNodeAsByteArray(2L, 3L, 0L))));
+
+	}
+	
+	@Test
+	public void shouldOutputAsRootAndFirstNode() throws Exception {
+		output = driver.withInputKey(new LongWritable(0)).withInputValue(new EdgeIdPropIdWritable(3,0)).run();
+
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(0).getSecond(), equalTo(new BytesWritable(Neo4JUtils.getNodeAsByteArray(0L, -1L, -1L))));
+		assertThat(output.get(1).getFirst(), equalTo(NullWritable.get()));
+		assertThat(output.get(1).getSecond(), equalTo(new BytesWritable(Neo4JUtils.getNodeAsByteArray(1L, 3L, 0L))));
+
+	}
+	
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesMapperTest.java
new file mode 100644
index 0000000..e44ee9b
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesMapperTest.java
@@ -0,0 +1,148 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaDataFromConfigImpl;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgePropertiesWritable;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EdgePreparePropertiesMapperTest {
+
+	private MapDriver<Text, Text, AscLongDescLongWritable, FullEdgePropertiesWritable> driver;
+	private List<Pair<AscLongDescLongWritable, FullEdgePropertiesWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<Text, Text, AscLongDescLongWritable, FullEdgePropertiesWritable>(new EdgePreparePropertiesMapper());
+	}
+
+	@Test
+	public void shouldOutputAsProperties() throws Exception {
+		driver.setConfiguration(populateConfigWithMetaData());
+		output = driver.withInputKey(new Text("0")).withInputValue(new Text("A	B	Prop3	Prop4	AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect")).run();
+
+		FullEdgePropertiesWritable edge1 = new FullEdgePropertiesWritable(0, "A", "B", 0, 0, -1, -1, 5, "Prop3");
+		edge1.add(6, "Prop4", 0);
+		FullEdgePropertiesWritable edge2 = new FullEdgePropertiesWritable(0, "A", "B", 1, 1, -1, -1, 7, "AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect");
+		
+		assertThat(output.size(), is(2));
+
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(0),new LongWritable(0))));
+		assertThat(output.get(0).getSecond(), equalTo(edge1));
+		assertThat(output.get(1).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(0),new LongWritable(1))));
+		assertThat(output.get(1).getSecond(), equalTo(edge2));
+
+	}
+
+	@Test
+	public void shouldOutputAsPropertiesWithVeryLongPropValue() throws Exception {
+		driver.setConfiguration(populateConfigWithMetaData());
+		output = driver.withInputKey(new Text("1")).withInputValue(new Text("B	C	Prop1	Prop2	AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrectAndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect")).run();
+		
+		FullEdgePropertiesWritable edge1 = new FullEdgePropertiesWritable(1, "B", "C", 0, 0, -1, -1, 5, "Prop1");
+		edge1.add(6, "Prop2", 0);
+		FullEdgePropertiesWritable edge2 = new FullEdgePropertiesWritable(1, "B", "C", 1, 2, -1, -1, 7, "AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrectAndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect");
+		
+		assertThat(output.size(), is(2));
+		
+
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(1),new LongWritable(0))));
+		assertThat(output.get(0).getSecond(), equalTo(edge1));
+		assertThat(output.get(1).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(1),new LongWritable(1))));
+		assertThat(output.get(1).getSecond(), equalTo(edge2));
+		
+	}
+	
+	@Test
+	public void shouldOutputAsPropertiesWithVeryLongPropValueAndLargeNodeSize() throws Exception {
+		driver.setConfiguration(populateConfigWithMetaDataWithLargeNodeSize());
+		output = driver.withInputKey(new Text("1")).withInputValue(new Text("B	C	Prop1	Prop2	AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrectAndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect")).run();
+		
+		FullEdgePropertiesWritable edge1 = new FullEdgePropertiesWritable(1, "B", "C", 0, 0, -1, -1, 5, "Prop1");
+		edge1.add(6, "Prop2", 0);
+		FullEdgePropertiesWritable edge2 = new FullEdgePropertiesWritable(1, "B", "C", 1, 2, -1, -1, 7, "AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrectAndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect");
+		
+		assertThat(output.size(), is(2));
+		
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(1),new LongWritable(0))));
+		assertThat(output.get(0).getSecond(), equalTo(edge1));
+		assertThat(output.get(1).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(1),new LongWritable(1))));
+		assertThat(output.get(1).getSecond(), equalTo(edge2));
+		
+	}
+	
+	@Test
+	public void shouldOutputAsPropertiesWithVeryLongPropValueAndLargeNodeSizeAndHighEdgeId() throws Exception {
+		driver.setConfiguration(populateConfigWithMetaDataWithLargeNodeSize());
+		output = driver.withInputKey(new Text("700000000")).withInputValue(new Text("B	C	Prop1	Prop2	AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrectAndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect")).run();
+		
+		FullEdgePropertiesWritable edge1 = new FullEdgePropertiesWritable(700000000, "B", "C", 0, 0, -1, -1, 5, "Prop1");
+		edge1.add(6, "Prop2", 0);
+		FullEdgePropertiesWritable edge2 = new FullEdgePropertiesWritable(700000000, "B", "C", 1, 2, -1, -1, 7, "AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrectAndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect");
+		
+		assertThat(output.size(), is(2));
+		
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(700000000L),new LongWritable(0))));
+		assertThat(output.get(0).getSecond(), equalTo(edge1));
+		assertThat(output.get(1).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(700000000L),new LongWritable(1))));
+		assertThat(output.get(1).getSecond(), equalTo(edge2));
+		
+	}
+	
+	private Configuration populateConfigWithMetaData() {
+		Configuration config = new Configuration();
+		config.setClass(AbstractMetaData.METADATA_CLASS, MetaDataFromConfigImpl.class, MetaData.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_NAMES, "id", "name", "prop3", "prop4", "longprop");
+		config.set(MetaDataFromConfigImpl.METADATA_NODE_ID_NAME, "id");
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "id", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "name", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "prop3", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "prop4", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "longprop", String.class, Object.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_NAMES, "from", "to", "prop1", "prop2", "longprop");
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "from", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "to", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "prop1", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "prop2", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "longprop", String.class, Object.class);
+		config.setLong(AbstractMetaData.METADATA_NUMBER_OF_NODES, 0L);
+		config.setLong(AbstractMetaData.METADATA_NUMBER_OF_EDGES, 1L);
+		return config;
+	}
+
+	private Configuration populateConfigWithMetaDataWithLargeNodeSize() {
+		Configuration config = new Configuration();
+		config.setClass(AbstractMetaData.METADATA_CLASS, MetaDataFromConfigImpl.class, MetaData.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_NAMES, "id", "name", "prop3", "prop4", "longprop");
+		config.set(MetaDataFromConfigImpl.METADATA_NODE_ID_NAME, "id");
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "id", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "name", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "prop3", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "prop4", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "longprop", String.class, Object.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_NAMES, "from", "to", "prop1", "prop2", "longprop");
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "from", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "to", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "prop1", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "prop2", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "longprop", String.class, Object.class);
+		config.setLong(AbstractMetaData.METADATA_NUMBER_OF_NODES, 250000000L);
+		config.setLong(AbstractMetaData.METADATA_NUMBER_OF_EDGES, 1L);
+		return config;
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesReducerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesReducerTest.java
new file mode 100644
index 0000000..a2e892f
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePreparePropertiesReducerTest.java
@@ -0,0 +1,48 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgePropertiesWritable;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EdgePreparePropertiesReducerTest {
+	private ReduceDriver<AscLongDescLongWritable, FullEdgePropertiesWritable, LongWritable, FullEdgePropertiesWritable> driver;
+	private List<Pair<LongWritable, FullEdgePropertiesWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new ReduceDriver<AscLongDescLongWritable, FullEdgePropertiesWritable, LongWritable, FullEdgePropertiesWritable>(new EdgePreparePropertiesReducer());
+	}
+
+	@Test
+	public void shouldOutputSurroundingProperties() throws Exception {
+		List<FullEdgePropertiesWritable> values = new ArrayList<FullEdgePropertiesWritable>();
+		values.add(new FullEdgePropertiesWritable(1, "A", "B", 2, 2, -1, -1, 0, "longblahorsomething"));
+		values.add(new FullEdgePropertiesWritable(1, "A", "B", 1, 0, -1, -1, 1, "otherblah"));
+		values.add(new FullEdgePropertiesWritable(1, "A", "B", 0, 0, -1, -1, 2, "blah"));
+		//Unfortunately no multiple keys can be added to this reducer, as is in real life.
+		output = driver.withInputKey(new AscLongDescLongWritable(new LongWritable(1), new LongWritable(3))).withInputValues(values).run();
+
+		assertThat(output.size(), is(3));
+
+		assertThat(output.get(0).getFirst(), equalTo(new LongWritable(1)));
+		assertThat(output.get(0).getSecond(), equalTo(new FullEdgePropertiesWritable(1, "A", "B", 2, 2, 1, -1, 0, "longblahorsomething")));
+		assertThat(output.get(1).getFirst(), equalTo(new LongWritable(1)));
+		assertThat(output.get(1).getSecond(), equalTo(new FullEdgePropertiesWritable(1, "A", "B", 1, 0, 0, 2, 1, "otherblah")));
+		assertThat(output.get(2).getFirst(), equalTo(new LongWritable(1)));
+		assertThat(output.get(2).getSecond(), equalTo(new FullEdgePropertiesWritable(1, "A", "B", 0, 0, -1, 1, 2, "blah")));
+
+	}
+	
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertiesOutputMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertiesOutputMapperTest.java
new file mode 100644
index 0000000..dc74576
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/EdgePropertiesOutputMapperTest.java
@@ -0,0 +1,95 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.misc.RowNumberJob;
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.EdgePropertyOutputCountersAndValueWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullEdgePropertiesWritable;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.ByteWritable;
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class EdgePropertiesOutputMapperTest {
+
+	private MapDriver<LongWritable, FullEdgePropertiesWritable, ByteMarkerIdPropIdWritable, EdgePropertyOutputCountersAndValueWritable> driver;
+	private List<Pair<ByteMarkerIdPropIdWritable, EdgePropertyOutputCountersAndValueWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<LongWritable, FullEdgePropertiesWritable, ByteMarkerIdPropIdWritable, EdgePropertyOutputCountersAndValueWritable>(new EdgePropertyOutputMapper());
+		Configuration configuration = new Configuration();
+		configuration.setLong(AbstractMetaData.METADATA_NUMBER_OF_NODES, 1);
+		configuration.setInt("mapred.reduce.tasks", 3);
+		driver.setConfiguration(configuration );
+	}
+
+	@Test
+	public void shouldOutputAsProperties() throws Exception {
+		FullEdgePropertiesWritable edge = new FullEdgePropertiesWritable(0, "A", "B", 4, 0, -1, 1, 0, "AProp");
+		edge.add(1, "BProp", 0);
+		output = driver.withInputKey(new LongWritable(0)).withInputValue(edge).run();
+
+		assertThat(output.size(), is(3));
+
+		EdgePropertyOutputCountersAndValueWritable val = new EdgePropertyOutputCountersAndValueWritable();
+		val.setValues(new LongWritable(0), edge);
+		
+		assertThat(output.get(0).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.VALUE_MARKER), new LongWritable(0), new IntWritable(4))));
+		assertThat(output.get(0).getSecond(), equalTo(val));
+
+		val = new EdgePropertyOutputCountersAndValueWritable();
+		val.setValues(EdgePropertyOutputCountersAndValueWritable.EMPTY_ID, EdgePropertyOutputCountersAndValueWritable.EMPTY_VAL);
+		val.setCounter(1, 0, 1);
+		
+		assertThat(output.get(1).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.COUNTER_MARKER), new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE))));
+		assertThat(output.get(1).getSecond(), equalTo(val));
+
+		val = new EdgePropertyOutputCountersAndValueWritable();
+		val.setValues(EdgePropertyOutputCountersAndValueWritable.EMPTY_ID, EdgePropertyOutputCountersAndValueWritable.EMPTY_VAL);
+		val.setCounter(2, 0, 1);
+		
+		assertThat(output.get(2).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.COUNTER_MARKER), new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE))));
+		assertThat(output.get(2).getSecond(), equalTo(val));
+
+	}
+	
+	@Test
+	public void shouldOutputAsPropertieswithPropertyIdAsTheKey() throws Exception {
+		output = driver.withInputKey(new LongWritable(1)).withInputValue(new FullEdgePropertiesWritable(1, "A", "B", 2, 40, 1, 2, 4, "AProp")).run();
+
+		assertThat(output.size(), is(3));
+
+		EdgePropertyOutputCountersAndValueWritable val = new EdgePropertyOutputCountersAndValueWritable();
+		val.setValues(new LongWritable(1), new FullEdgePropertiesWritable(1, "A", "B", 2, 40, 1, 2, 4, "AProp"));
+		
+		assertThat(output.get(0).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.VALUE_MARKER), new LongWritable(1), new IntWritable(2))));
+		assertThat(output.get(0).getSecond(), equalTo(val));
+		
+		val = new EdgePropertyOutputCountersAndValueWritable();
+		val.setValues(EdgePropertyOutputCountersAndValueWritable.EMPTY_ID, EdgePropertyOutputCountersAndValueWritable.EMPTY_VAL);
+		val.setCounter(1, 0, 0);
+		
+		assertThat(output.get(1).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.COUNTER_MARKER), new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE))));
+		assertThat(output.get(1).getSecond(), equalTo(val));
+		
+		val = new EdgePropertyOutputCountersAndValueWritable();
+		val.setValues(EdgePropertyOutputCountersAndValueWritable.EMPTY_ID, EdgePropertyOutputCountersAndValueWritable.EMPTY_VAL);
+		val.setCounter(2, 40, 1);
+		
+		assertThat(output.get(2).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.COUNTER_MARKER), new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE))));
+		assertThat(output.get(2).getSecond(), equalTo(val));
+		
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesMapReduceTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesMapReduceTest.java
new file mode 100644
index 0000000..012440b
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesMapReduceTest.java
@@ -0,0 +1,94 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.AscLongDescLongKeyComparator;
+import nl.waredingen.graphs.neo.mapreduce.AscLongDescLongKeyGroupingComparator;
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaDataFromConfigImpl;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullNodePropertiesWritable;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.mapreduce.MapReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NodePreparePropertiesMapReduceTest {
+
+	private MapReduceDriver<Text, Text, AscLongDescLongWritable, FullNodePropertiesWritable,LongWritable, FullNodePropertiesWritable> driver;
+	private List<Pair<LongWritable, FullNodePropertiesWritable>> output;
+
+	@SuppressWarnings("unchecked")
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapReduceDriver<Text, Text, AscLongDescLongWritable, FullNodePropertiesWritable,LongWritable, FullNodePropertiesWritable>(new NodePreparePropertiesMapper(), new NodePreparePropertiesReducer());
+		driver.setKeyGroupingComparator(new AscLongDescLongKeyGroupingComparator());
+		driver.setKeyOrderComparator(new AscLongDescLongKeyComparator());
+	}
+
+	@Test
+	public void shouldPrepareTheProps() throws Exception {
+		driver.setConfiguration(populateConfigWithRealMetaData());
+		output = driver.withInput(new Text("2"),new Text("384160409	1-3WH-21474    	000000111509024	A	I	A.J. HOP 	2518CT    	'S-GRAVENHAGE	STORT")).run();
+
+		FullNodePropertiesWritable node1 = new FullNodePropertiesWritable(2, "384160409", 0, 0, -1, 1, 0, "384160409");
+		node1.add(1, "1-3WH-21474", 0);
+		FullNodePropertiesWritable node2 = new FullNodePropertiesWritable(2, "384160409", 1, 0, 0, 2, 2, "000000111509024");
+		node2.add(3, "A", 0);
+		node2.add(4, "I", 0);
+		FullNodePropertiesWritable node3 = new FullNodePropertiesWritable(2, "384160409", 2, 0, 1, 3, 5, "A.J. HOP");
+		node3.add(6, "2518CT", 0);
+		FullNodePropertiesWritable node4 = new FullNodePropertiesWritable(2, "384160409", 3, 0, 2, -1, 7, "'S-GRAVENHAGE");
+		node4.add(8, "STORT", 0);
+		assertThat(output.size(), is(4));
+
+		assertThat(output.get(0).getFirst(), equalTo(new LongWritable(2)));
+		assertThat(output.get(0).getSecond(), equalTo(node4));
+		assertThat(output.get(1).getFirst(), equalTo(new LongWritable(2)));
+		assertThat(output.get(1).getSecond(), equalTo(node3));
+		assertThat(output.get(2).getFirst(), equalTo(new LongWritable(2)));
+		assertThat(output.get(2).getSecond(), equalTo(node2));
+		assertThat(output.get(3).getFirst(), equalTo(new LongWritable(2)));
+		assertThat(output.get(3).getSecond(), equalTo(node1));
+	}
+	
+	private Configuration populateConfigWithRealMetaData() {
+		Configuration conf = new Configuration();
+		conf.set(AbstractMetaData.METADATA_NUMBER_OF_NODES, "" + 1);
+		conf.set(AbstractMetaData.METADATA_NUMBER_OF_EDGES, "" + 0);
+		
+		conf.setClass(AbstractMetaData.METADATA_CLASS, MetaDataFromConfigImpl.class, MetaData.class);
+
+		conf.setStrings(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_NAMES, "rekening", "integraalklantnummer", "klantnummer", "cddklasse", "individu_organisatie_code", "naam", "postcode", "woonplaats", "label");
+		conf.set(MetaDataFromConfigImpl.METADATA_NODE_ID_NAME, "rekening");
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "rekening", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "integraalklantnummer", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "klantnummer", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "cddklasse", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "individu_organisatie_code", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "naam", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "postcode", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "woonplaats", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "label", String.class, Object.class);
+
+		conf.setStrings(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_NAMES, "from", "to", "netto", "eerste", "laatste", "aantal");
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "from", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "to", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "netto", Long.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "eerste", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "laatste", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "aantal", Long.class, Object.class);
+		return conf;
+	}
+	
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesMapperTest.java
new file mode 100644
index 0000000..f9029ac
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesMapperTest.java
@@ -0,0 +1,144 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.MetaDataFromConfigImpl;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullNodePropertiesWritable;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NodePreparePropertiesMapperTest {
+
+	private MapDriver<Text, Text, AscLongDescLongWritable, FullNodePropertiesWritable> driver;
+	private List<Pair<AscLongDescLongWritable, FullNodePropertiesWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<Text, Text, AscLongDescLongWritable, FullNodePropertiesWritable>(new NodePreparePropertiesMapper());
+	}
+
+	@Test
+	public void shouldOutputAsProperties() throws Exception {
+		driver.setConfiguration(populateConfigWithMetaData());
+		output = driver.withInputKey(new Text("0")).withInputValue(new Text("A	Aname	Prop3	Prop4	AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect")).run();
+
+		FullNodePropertiesWritable node1 = new FullNodePropertiesWritable(0, "A", 0, 0, -1, -1, 0, "A");
+		node1.add(1, "Aname", 0);
+		FullNodePropertiesWritable node2 = new FullNodePropertiesWritable(0, "A", 1, 0, -1, -1, 2, "Prop3");
+		node2.add(3, "Prop4", 0);
+		FullNodePropertiesWritable node3 = new FullNodePropertiesWritable(0, "A", 2, 1, -1, -1, 4, "AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect");
+
+		assertThat(output.size(), is(3));
+		
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(0),new LongWritable(0))));
+		assertThat(output.get(0).getSecond(), equalTo(node1));
+		assertThat(output.get(1).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(0),new LongWritable(1))));
+		assertThat(output.get(1).getSecond(), equalTo(node2));
+		assertThat(output.get(2).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(0),new LongWritable(2))));
+		assertThat(output.get(2).getSecond(), equalTo(node3));
+
+	}
+
+	@Test
+	public void shouldOutputAsPropertiesWithVeryLongPropValue() throws Exception {
+		output = driver.withInputKey(new Text("1")).withInputValue(new Text("Prop1	AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrectAndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect")).run();
+		
+		FullNodePropertiesWritable node1 = new FullNodePropertiesWritable(1, "Prop1", 0, 0, -1, -1, 0, "Prop1");
+		node1.add(1, "AndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrectAndAPropWithAverryLongvalueBecauseWeKindOfNeedToFindOutIfABlockCountIsPresentAndCorrect", 2);
+		assertThat(output.size(), is(1));
+		
+
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(1),new LongWritable(0))));
+		assertThat(output.get(0).getSecond(), equalTo(node1));
+		
+	}
+	
+	private Configuration populateConfigWithMetaData() {
+		Configuration config = new Configuration();
+		config.setClass(AbstractMetaData.METADATA_CLASS, MetaDataFromConfigImpl.class, MetaData.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_NAMES, "id", "name", "prop3", "prop4", "longprop");
+		config.set(MetaDataFromConfigImpl.METADATA_NODE_ID_NAME, "id");
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "id", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "name", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "prop3", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "prop4", String.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "longprop", String.class, Object.class);
+		config.setStrings(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_NAMES, "from", "to");
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "from", Long.class, Object.class);
+		config.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "to", Long.class, Object.class);
+		config.setLong(AbstractMetaData.METADATA_NUMBER_OF_NODES, 1L);
+		config.setLong(AbstractMetaData.METADATA_NUMBER_OF_EDGES, 0L);
+		return config;
+	}
+	
+	@Test
+	public void shouldOutputAsPropertiesWithRealValues() throws Exception {
+		driver.setConfiguration(populateConfigWithRealMetaData());
+		output = driver.withInputKey(new Text("2")).withInputValue(new Text("384160409	1-3WH-21474    	000000111509024	A	I	A.J. HOP 	2518CT    	'S-GRAVENHAGE	STORT")).run();
+		
+		FullNodePropertiesWritable node1 = new FullNodePropertiesWritable(2, "384160409", 0, 0, -1, -1, 0, "384160409");
+		node1.add(1, "1-3WH-21474", 0);
+		FullNodePropertiesWritable node2 = new FullNodePropertiesWritable(2, "384160409", 1, 0, -1, -1, 2, "000000111509024");
+		node2.add(3, "A", 0);
+		node2.add(4, "I", 0);
+		FullNodePropertiesWritable node3 = new FullNodePropertiesWritable(2, "384160409", 2, 0, -1, -1, 5, "A.J. HOP");
+		node3.add(6, "2518CT", 0);
+		FullNodePropertiesWritable node4 = new FullNodePropertiesWritable(2, "384160409", 3, 0, -1, -1, 7, "'S-GRAVENHAGE");
+		node4.add(8, "STORT", 0);
+		assertThat(output.size(), is(4));
+		
+
+		assertThat(output.get(0).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(2),new LongWritable(0))));
+		assertThat(output.get(0).getSecond(), equalTo(node1));
+		assertThat(output.get(1).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(2),new LongWritable(1))));
+		assertThat(output.get(1).getSecond(), equalTo(node2));
+		assertThat(output.get(2).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(2),new LongWritable(2))));
+		assertThat(output.get(2).getSecond(), equalTo(node3));
+		assertThat(output.get(3).getFirst(), equalTo(new AscLongDescLongWritable(new LongWritable(2),new LongWritable(3))));
+		assertThat(output.get(3).getSecond(), equalTo(node4));
+		
+	}
+	
+	private Configuration populateConfigWithRealMetaData() {
+		Configuration conf = new Configuration();
+		conf.set(AbstractMetaData.METADATA_NUMBER_OF_NODES, "" + 1);
+		conf.set(AbstractMetaData.METADATA_NUMBER_OF_EDGES, "" + 0);
+		
+		conf.setClass(AbstractMetaData.METADATA_CLASS, MetaDataFromConfigImpl.class, MetaData.class);
+
+		conf.setStrings(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_NAMES, "rekening", "integraalklantnummer", "klantnummer", "cddklasse", "individu_organisatie_code", "naam", "postcode", "woonplaats", "label");
+		conf.set(MetaDataFromConfigImpl.METADATA_NODE_ID_NAME, "rekening");
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "rekening", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "integraalklantnummer", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "klantnummer", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "cddklasse", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "individu_organisatie_code", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "naam", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "postcode", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "woonplaats", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_NODE_PROPERTY_TYPE_PREFIX + "label", String.class, Object.class);
+
+		conf.setStrings(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_NAMES, "from", "to", "netto", "eerste", "laatste", "aantal");
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "from", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "to", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "netto", Long.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "eerste", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "laatste", String.class, Object.class);
+		conf.setClass(MetaDataFromConfigImpl.METADATA_EDGE_PROPERTY_TYPE_PREFIX + "aantal", Long.class, Object.class);
+		return conf;
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesReducerTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesReducerTest.java
new file mode 100644
index 0000000..6cd3637
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePreparePropertiesReducerTest.java
@@ -0,0 +1,48 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import nl.waredingen.graphs.neo.mapreduce.input.writables.AscLongDescLongWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullNodePropertiesWritable;
+
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mrunit.mapreduce.ReduceDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NodePreparePropertiesReducerTest {
+	private ReduceDriver<AscLongDescLongWritable, FullNodePropertiesWritable, LongWritable, FullNodePropertiesWritable> driver;
+	private List<Pair<LongWritable, FullNodePropertiesWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new ReduceDriver<AscLongDescLongWritable, FullNodePropertiesWritable, LongWritable, FullNodePropertiesWritable>(new NodePreparePropertiesReducer());
+	}
+
+	@Test
+	public void shouldOutputSurroundingProperties() throws Exception {
+		List<FullNodePropertiesWritable> values = new ArrayList<FullNodePropertiesWritable>();
+		values.add(new FullNodePropertiesWritable(1, "A", 2, 2, -1, -1, 0, "longblahorsomething"));
+		values.add(new FullNodePropertiesWritable(1, "A", 1, 0, -1, -1, 1, "otherblah"));
+		values.add(new FullNodePropertiesWritable(1, "A", 0, 0, -1, -1, 2, "blah"));
+		//Unfortunately no multiple keys can be added to this reducer, as is in real life.
+		output = driver.withInputKey(new AscLongDescLongWritable(new LongWritable(1), new LongWritable(3))).withInputValues(values).run();
+
+		assertThat(output.size(), is(3));
+
+		assertThat(output.get(0).getFirst(), equalTo(new LongWritable(1)));
+		assertThat(output.get(0).getSecond(), equalTo(new FullNodePropertiesWritable(1, "A", 2, 2, 1, -1, 0, "longblahorsomething")));
+		assertThat(output.get(1).getFirst(), equalTo(new LongWritable(1)));
+		assertThat(output.get(1).getSecond(), equalTo(new FullNodePropertiesWritable(1, "A", 1, 0, 0, 2, 1, "otherblah")));
+		assertThat(output.get(2).getFirst(), equalTo(new LongWritable(1)));
+		assertThat(output.get(2).getSecond(), equalTo(new FullNodePropertiesWritable(1, "A", 0, 0, -1, 1, 2, "blah")));
+
+	}
+	
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertiesOutputMapperTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertiesOutputMapperTest.java
new file mode 100644
index 0000000..f3e263e
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/NodePropertiesOutputMapperTest.java
@@ -0,0 +1,95 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+
+import nl.waredingen.graphs.misc.RowNumberJob;
+import nl.waredingen.graphs.neo.mapreduce.input.AbstractMetaData;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.ByteMarkerIdPropIdWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.FullNodePropertiesWritable;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.NodePropertyOutputCountersAndValueWritable;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.io.ByteWritable;
+import org.apache.hadoop.io.IntWritable;
+import org.apache.hadoop.io.LongWritable;
+import org.apache.hadoop.mrunit.mapreduce.MapDriver;
+import org.apache.hadoop.mrunit.types.Pair;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NodePropertiesOutputMapperTest {
+
+	private MapDriver<LongWritable, FullNodePropertiesWritable, ByteMarkerIdPropIdWritable, NodePropertyOutputCountersAndValueWritable> driver;
+	private List<Pair<ByteMarkerIdPropIdWritable, NodePropertyOutputCountersAndValueWritable>> output;
+
+	@Before
+	public void setUp() throws Exception {
+		driver = new MapDriver<LongWritable, FullNodePropertiesWritable, ByteMarkerIdPropIdWritable, NodePropertyOutputCountersAndValueWritable>(new NodePropertyOutputMapper());
+		Configuration configuration = new Configuration();
+		configuration.setLong(AbstractMetaData.METADATA_NUMBER_OF_NODES, 1);
+		configuration.setInt("mapred.reduce.tasks", 3);
+		driver.setConfiguration(configuration );
+	}
+
+	@Test
+	public void shouldOutputAsProperties() throws Exception {
+		FullNodePropertiesWritable node = new FullNodePropertiesWritable(0, "A", 0, 0, -1, 1, 0,"A");
+		node.add(1, "Aname", 0);
+		output = driver.withInputKey(new LongWritable(0)).withInputValue(node).run();
+
+		assertThat(output.size(), is(3));
+
+		NodePropertyOutputCountersAndValueWritable val = new NodePropertyOutputCountersAndValueWritable();
+		val.setValues(new LongWritable(0), node);
+		
+		assertThat(output.get(0).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.VALUE_MARKER), new LongWritable(0), new IntWritable(0))));
+		assertThat(output.get(0).getSecond(), equalTo(val));
+
+		val = new NodePropertyOutputCountersAndValueWritable();
+		val.setValues(NodePropertyOutputCountersAndValueWritable.EMPTY_ID, NodePropertyOutputCountersAndValueWritable.EMPTY_VAL);
+		val.setCounter(1, 0, 1);
+		
+		assertThat(output.get(1).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.COUNTER_MARKER), new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE))));
+		assertThat(output.get(1).getSecond(), equalTo(val));
+
+		val = new NodePropertyOutputCountersAndValueWritable();
+		val.setValues(NodePropertyOutputCountersAndValueWritable.EMPTY_ID, NodePropertyOutputCountersAndValueWritable.EMPTY_VAL);
+		val.setCounter(2, 0, 1);
+		
+		assertThat(output.get(2).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.COUNTER_MARKER), new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE))));
+		assertThat(output.get(2).getSecond(), equalTo(val));
+
+	}
+	
+	@Test
+	public void shouldOutputAsPropertieswithPropertyIdAsTheKey() throws Exception {
+		output = driver.withInputKey(new LongWritable(1)).withInputValue(new FullNodePropertiesWritable(1, "A", 1, 40, 1, 2, 1, "Aname")).run();
+
+		assertThat(output.size(), is(3));
+
+		NodePropertyOutputCountersAndValueWritable val = new NodePropertyOutputCountersAndValueWritable();
+		val.setValues(new LongWritable(1), new FullNodePropertiesWritable(1, "A", 1, 40, 1, 2, 1, "Aname"));
+		
+		assertThat(output.get(0).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.VALUE_MARKER), new LongWritable(1), new IntWritable(1))));
+		assertThat(output.get(0).getSecond(), equalTo(val));
+		
+		val = new NodePropertyOutputCountersAndValueWritable();
+		val.setValues(NodePropertyOutputCountersAndValueWritable.EMPTY_ID, NodePropertyOutputCountersAndValueWritable.EMPTY_VAL);
+		val.setCounter(1, 0, 0);
+		
+		assertThat(output.get(1).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.COUNTER_MARKER), new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE))));
+		assertThat(output.get(1).getSecond(), equalTo(val));
+		
+		val = new NodePropertyOutputCountersAndValueWritable();
+		val.setValues(NodePropertyOutputCountersAndValueWritable.EMPTY_ID, NodePropertyOutputCountersAndValueWritable.EMPTY_VAL);
+		val.setCounter(2, 40, 1);
+		
+		assertThat(output.get(2).getFirst(), equalTo(new ByteMarkerIdPropIdWritable(new ByteWritable(RowNumberJob.COUNTER_MARKER), new LongWritable(Long.MIN_VALUE), new IntWritable(Integer.MIN_VALUE))));
+		assertThat(output.get(2).getSecond(), equalTo(val));
+		
+	}
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/PropertyListWritableComparatorTest.java b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/PropertyListWritableComparatorTest.java
new file mode 100644
index 0000000..f5b4845
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/mapreduce/properties/PropertyListWritableComparatorTest.java
@@ -0,0 +1,61 @@
+package nl.waredingen.graphs.neo.mapreduce.properties;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import nl.waredingen.graphs.neo.mapreduce.input.writables.PropertyListWritable;
+
+import org.apache.hadoop.io.Text;
+import org.apache.hadoop.mapreduce.Partitioner;
+import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;
+import org.junit.Test;
+
+public class PropertyListWritableComparatorTest {
+
+	@Test
+	public void testPropertyListWritablesAreEqual() {
+		PropertyListWritable e1 = new PropertyListWritable();
+		e1.setKeys(0,1,2);
+		e1.setValues("prop3", "prop2", "prop0");
+		PropertyListWritable e2 = new PropertyListWritable();
+		e2.setKeys(0,1,2);
+		e2.setValues("prop3", "prop2", "prop0");
+		
+		assertTrue(e1.equals(e2));
+		assertEquals(0, e1.compareTo(e2));
+		assertEquals(0, e2.compareTo(e1));
+		assertEquals(0, e1.compareTo(e1));
+		assertEquals(0, e2.compareTo(e2));
+	}
+
+	@Test
+	public void testPropertyListWritablesAreNonEqual() {
+		PropertyListWritable e1 = new PropertyListWritable();
+		e1.setKeys(0,1,2);
+		e1.setValues("prop3", "prop2", "prop0");
+		PropertyListWritable e2 = new PropertyListWritable();
+		e2.setKeys(0,1,2);
+		e2.setValues("prop3", "prop2", "prop1");
+		
+		assertFalse(e1.equals(e2));
+		assertEquals(-1, e1.compareTo(e2));
+		assertEquals(1, e2.compareTo(e1));
+		assertEquals(0, e1.compareTo(e1));
+		assertEquals(0, e2.compareTo(e2));
+	}
+
+	@Test
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public void testPropertyListWritablesAreEquallyPartitioned() {
+		PropertyListWritable e1 = new PropertyListWritable();
+		e1.setKeys(0,1,2);
+		e1.setValues("prop3", "prop2", "prop0");
+		PropertyListWritable e2 = new PropertyListWritable();
+		e2.setKeys(0,1,2);
+		e2.setValues("prop3", "prop2", "prop0");
+		
+		Partitioner p = new HashPartitioner<PropertyListWritable, Text>();
+		assertEquals(p.getPartition(e1, new Text(), 50), p.getPartition(e2, new Text(), 50));
+	}
+
+}
diff --git a/job/src/test/java/nl/waredingen/graphs/neo/neo4j/Neo4jUtilsTest.java b/job/src/test/java/nl/waredingen/graphs/neo/neo4j/Neo4jUtilsTest.java
new file mode 100644
index 0000000..cd7a664
--- /dev/null
+++ b/job/src/test/java/nl/waredingen/graphs/neo/neo4j/Neo4jUtilsTest.java
@@ -0,0 +1,342 @@
+package nl.waredingen.graphs.neo.neo4j;
+
+import static org.junit.Assert.*;
+
+import java.util.List;
+
+import org.junit.Test;
+import org.neo4j.kernel.impl.nioneo.store.DynamicRecord;
+import org.neo4j.kernel.impl.nioneo.store.PropertyBlock;
+import org.neo4j.kernel.impl.nioneo.store.PropertyType;
+import org.neo4j.kernel.impl.nioneo.store.Record;
+
+public class Neo4jUtilsTest {
+
+	@Test
+	public void testPropertyStoreShortestStringValue() {
+		String s = "kort";
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, s, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.SHORT_STRING, block.getType());
+		assertEquals(s, PropertyType.SHORT_STRING.getValue(block, null));
+	}
+
+	@Test
+	public void testPropertyStoreShortStringValue() {
+		String s = "nietzoheelkortMaarTochbestwelkort120";
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, s, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.SHORT_STRING, block.getType());
+		assertEquals(s, PropertyType.SHORT_STRING.getValue(block, null));
+	}
+
+	@Test
+	public void testPropertyStoreLongStringValue() {
+		String s = "nietzoheelkortMaarTochbestwelkortmaarlangerdan120zodatditineenapartenamesstorekomt";
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, s, 201L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.STRING, block.getType());
+		assertEquals(201L, block.getSingleValueLong());
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(1, valueBlocks.length);
+		for (long l : valueBlocks) {
+			
+			//keyId | (((long) type.intValue()) << 24) | (longValue << 28)
+			long expected = block.getKeyIndexId() | (((long) PropertyType.STRING.intValue()) << 24) | (201L <<28) ;
+			assertEquals(expected, l);
+		}
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(1, valueRecords.size());
+		DynamicRecord record = valueRecords.get(0);
+		assertNotNull(record);
+		assertEquals(PropertyType.STRING.intValue(),record.getType());
+		assertEquals(Record.NO_NEXT_BLOCK.intValue(), record.getNextBlock());
+		assertEquals(201L, record.getId());
+		assertEquals(82, record.getLength());
+		assertEquals(201L, record.getLongId());
+		assertEquals(s, new String(record.getData()));
+
+	}
+
+	@Test
+	public void testPropertyStoreVeryLongStringValue() {
+		String s = 
+"Bestwelheeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeelerglang.iniedergevalzolangdathetde120tekensoverschrijdt.ditomtetestenofookeenlangestringmetallerleinextblockswerkt.";
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 22, s, 202L);
+		assertNotNull(block);
+		assertEquals(22, block.getKeyIndexId());
+		assertEquals(PropertyType.STRING, block.getType());
+		assertEquals(202L, block.getSingleValueLong());
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(1, valueBlocks.length);
+		for (long l : valueBlocks) {
+			
+			//keyId | (((long) type.intValue()) << 24) | (longValue << 28)
+			long expected = block.getKeyIndexId() | (((long) PropertyType.STRING.intValue()) << 24) | (202L <<28) ;
+			assertEquals(expected, l);
+		}
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(2, valueRecords.size());
+		String result = "";
+		for (DynamicRecord record : valueRecords) {
+			assertNotNull(record);
+			assertEquals(PropertyType.STRING.intValue(),record.getType());
+			result += new String(record.getData());
+		}
+		
+		DynamicRecord record = valueRecords.get(0);
+		assertEquals(203, record.getNextBlock());
+		assertEquals(202L, record.getId());
+		assertEquals(120, record.getLength());
+		assertEquals(202L, record.getLongId());
+		
+		record = valueRecords.get(1);
+		assertEquals(Record.NO_NEXT_BLOCK.intValue(), record.getNextBlock());
+		assertEquals(203L, record.getId());
+		assertEquals(93, record.getLength());
+		assertEquals(203L, record.getLongId());
+		assertEquals(s, result);
+
+
+	}
+
+	@Test
+	public void testPropertyStoreReallyVeryLongStringValue() {
+		String s = 
+"Bestwelheeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeelerglang.iniedergevalzolangdathetde120tekensoverschrijdt.ditomtetestenofookeenlangestringmetallerleinextblockswerkt.Endanookmetechtveelblockswant2isnatuurlijknietgenoeg";
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, s, 203L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.STRING, block.getType());
+		assertEquals(203L, block.getSingleValueLong());
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(1, valueBlocks.length);
+		for (long l : valueBlocks) {
+			
+			//keyId | (((long) type.intValue()) << 24) | (longValue << 28)
+			long expected = block.getKeyIndexId() | (((long) PropertyType.STRING.intValue()) << 24) | (203L <<28) ;
+			assertEquals(expected, l);
+		}
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(3, valueRecords.size());
+		String result = "";
+		for (DynamicRecord record : valueRecords) {
+			assertNotNull(record);
+			assertEquals(PropertyType.STRING.intValue(),record.getType());
+			result += new String(record.getData());
+		}
+		
+		DynamicRecord record = valueRecords.get(0);
+		assertEquals(204, record.getNextBlock());
+		assertEquals(203L, record.getId());
+		assertEquals(120, record.getLength());
+		assertEquals(203L, record.getLongId());
+		
+		record = valueRecords.get(1);
+		assertEquals(205, record.getNextBlock());
+		assertEquals(204L, record.getId());
+		assertEquals(120, record.getLength());
+		assertEquals(204L, record.getLongId());
+
+		record = valueRecords.get(2);
+		assertEquals(Record.NO_NEXT_BLOCK.intValue(), record.getNextBlock());
+		assertEquals(205L, record.getId());
+		assertEquals(25, record.getLength());
+		assertEquals(205L, record.getLongId());
+
+		assertEquals(s, result);
+
+
+	}
+
+	@Test
+	public void testPropertyStoreLongValue() {
+		long input = 123L;
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, input, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.LONG, block.getType());
+		
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(1, valueBlocks.length);
+		assertEquals(input, PropertyType.LONG.getValue(block, null));
+
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(0, valueRecords.size());
+
+	}
+
+	@Test
+	public void testPropertyStoreLargeLongValue() {
+		long input = Long.MAX_VALUE -1;
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, input, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.LONG, block.getType());
+		
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(2, valueBlocks.length);
+		assertEquals(input, PropertyType.LONG.getValue(block, null));
+		
+		long expected = block.getKeyIndexId() | (((long) PropertyType.LONG.intValue()) << 24) | (0L <<28) ;
+
+		assertEquals(expected, valueBlocks[0]);
+		assertEquals(input, valueBlocks[1]);
+
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(0, valueRecords.size());
+
+	}
+
+	@Test
+	public void testPropertyStoreIntValue() {
+		int input = 1234;
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, input, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.INT, block.getType());
+		
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(1, valueBlocks.length);
+		long expected = block.getKeyIndexId() | (((long) PropertyType.INT.intValue()) << 24) | (1234L <<28) ;
+
+		assertEquals(expected, valueBlocks[0]);
+		assertEquals(input, PropertyType.INT.getValue(block, null));
+
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(0, valueRecords.size());
+
+	}
+
+	@Test
+	public void testPropertyStoreShortValue() {
+		short input = 42;
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, input, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.SHORT, block.getType());
+		
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(1, valueBlocks.length);
+		long expected = block.getKeyIndexId() | (((long) PropertyType.SHORT.intValue()) << 24) | (42L <<28) ;
+
+		assertEquals(expected, valueBlocks[0]);
+		assertEquals(input, PropertyType.SHORT.getValue(block, null));
+
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(0, valueRecords.size());
+
+	}
+
+	@Test
+	public void testPropertyStoreByteValue() {
+		byte input = 127;
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, input, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.BYTE, block.getType());
+		
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(1, valueBlocks.length);
+		assertEquals(input, PropertyType.BYTE.getValue(block, null));
+
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(0, valueRecords.size());
+
+	}
+
+	@Test
+	public void testPropertyStoreFloatValue() {
+		float input = 123456.78F;
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, input, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.FLOAT, block.getType());
+		
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(1, valueBlocks.length);
+		assertEquals(input, PropertyType.FLOAT.getValue(block, null));
+
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(0, valueRecords.size());
+
+	}
+
+	@Test
+	public void testPropertyStoreLargeFloatValue() {
+		float input = Float.MAX_VALUE - 0.000000000001F;
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, input, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.FLOAT, block.getType());
+		
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(1, valueBlocks.length);
+		assertEquals(input, PropertyType.FLOAT.getValue(block, null));
+
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(0, valueRecords.size());
+
+	}
+
+	@Test
+	public void testPropertyStoreDoubleValue() {
+		double input = 1.99D;
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, input, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.DOUBLE, block.getType());
+		
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(2, valueBlocks.length);
+
+		long expected = block.getKeyIndexId() | (((long) PropertyType.DOUBLE.intValue()) << 24) | (0L <<28) ;
+		
+		assertEquals(expected, valueBlocks[0]);
+		assertEquals(input, PropertyType.DOUBLE.getValue(block, null));
+
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(0, valueRecords.size());
+
+	}
+
+	@Test
+	public void testPropertyStoreLargeDoubleValue() {
+		double input = Double.MAX_VALUE -0.0000000000000001D;
+		PropertyBlock block = new PropertyBlock(); 
+		Neo4JUtils.encodeValue(block, 0, input, -1L);
+		assertNotNull(block);
+		assertEquals(0, block.getKeyIndexId());
+		assertEquals(PropertyType.DOUBLE, block.getType());
+		
+		long[] valueBlocks = block.getValueBlocks();
+		assertEquals(2, valueBlocks.length);
+		
+		long expected = block.getKeyIndexId() | (((long) PropertyType.DOUBLE.intValue()) << 24) | (0L <<28) ;
+
+		assertEquals(expected, valueBlocks[0]);
+		assertEquals(input, PropertyType.DOUBLE.getValue(block, null));
+
+		List<DynamicRecord> valueRecords = block.getValueRecords();
+		assertEquals(0, valueRecords.size());
+
+	}
+
+
+}
diff --git a/job/workflow.txt b/job/workflow.txt
new file mode 100644
index 0000000..03a3ebb
--- /dev/null
+++ b/job/workflow.txt
@@ -0,0 +1,98 @@
+1111111111111111111111111111
+First create a nodes and a edges file from the input:
+
+
+hadoop jar target/graphs-0.1-SNAPSHOT-job.jar prepare-bgp ../samples/bgp-sample.txt ./nodes ./edges
+
+This creates:
+cat nodes/part-00000 
+cat edges/part-00000 
+
+222222222222222222222222222
+Add unique rownumbers to them
+
+
+hadoop jar target/graphs-0.1-SNAPSHOT-job.jar rownumbers ./nodes ./nodes-withrows
+
+cat nodes-withrows/part-r-00000 
+
+hadoop jar target/graphs-0.1-SNAPSHOT-job.jar rownumbers ./edges ./edges-withrows
+cat edges-withrows/part-r-00000 
+
+cat edges-withrows/part-r-00000 | awk '{print $2"\t"$3"\t"$1}' > ../samples/edges-with-row.txt
+
+cat nodes-withrows/part-r-00000 | awk '{print $2"\t"$3"\t"$1}' > ../samples/nodes-with-row.txt
+
+cat ../samples/edges-with-row.txt 
+cat ../samples/nodes-with-row.txt 
+
+3333333333333333333333333333
+Do the normal 1 machine import to see that a graph db is created
+
+hadoop jar target/graphs-0.1-SNAPSHOT-job.jar neo4j-import ../samples/nodes-with-row.txt ../samples/edges-with-row.txt ./neodb "name,rownum" "rownum"
+
+
+cp -R neodb ~/dev/neo4j/neo4j-community-1.8.M05/data/graph.db
+
+can inspect the files with hexdump to explain the file format
+hexdump ~/dev/neo4j/neo4j-community-1.8.M05/data/graph.db/neostore.nodestore.db
+hexdump ~/dev/neo4j/neo4j-community-1.8.M05/data/graph.db/neostore.relationshipstore.db
+
+
+
+4444444444444444444444444444
+Explain the file format
+
+Nodes:
+9 byte records with:
+1 byte use flag
+4 byte id of first relationship
+4 byte id of first property
+
+Edges:
+33 byte records with:
+1 byte use flag
+4 byte from node id
+4 byte to node id
+4 byte relationship type
+4 byte from node previous rel id
+4 byte from node next rel id
+4 byte to node previous rel id
+4 byte to node next rel id
+4 byte id of first property
+
+5555555555555555555555555555
+Do the distributed creation of the nodes file
+hadoop jar target/graphs-0.1-SNAPSHOT-job.jar neographnodes ../samples/nodes-with-row.txt ../samples/edges-with-row.txt ./neograph
+hadoop jar target/graphs-0.1-SNAPSHOT-job.jar neographedges ../samples/nodes-with-row.txt ../samples/edges-with-row.txt ./neograph
+
+hexdump ./neograph/neostore.nodestore.db/part-00000
+hexdump ./neograph/neostore.relationshipstore.db/part-00000
+
+
+
+
+
+Steps for NODES
+
+join nodes and edges on id and idfrom
+join nodes and edges on id and idto
+union those two joins
+sort descending on relnum
+grab only the first of every id
+sort by rownum
+create byterecords per node
+
+Steps for EDGES
+join nodes and edges on id and idfrom
+join nodes and edges on id and idto
+union those two joins
+sort descending on relnum
+get out the duplicates on id, from, to and relnum (the selfjoined records)
+sort again on relnum descending (cascading won't let me loopo through the previous sortresult twice)
+get out the next and previous rels if any
+selfjoin on from to relnum to combine all info of a relation
+filter out the duplicates
+filter out the selfjoined ones
+sort on relnum (prepare for output)
+create byterecord per rel
diff --git a/samples/simple-edges.txt b/samples/simple-edges.txt
new file mode 100644
index 0000000..3e7fdaf
--- /dev/null
+++ b/samples/simple-edges.txt
@@ -0,0 +1,4 @@
+A	B
+B	C
+A	C
+C	A
diff --git a/samples/simple-nodes.txt b/samples/simple-nodes.txt
new file mode 100644
index 0000000..a633d6d
--- /dev/null
+++ b/samples/simple-nodes.txt
@@ -0,0 +1,3 @@
+A	Aname
+B	BnameWhichIsVeryLongBecauseWeNeedSomeProofThatOurPropertyStringStoreIsRealyWorkingOkAndAlsoSpanningTwoBlocksOfThe120ByteLargeBlockSize
+C	Cname